Fix Bazel sharding test that relied on tests being run in declaration order

Default to randomized test case order
Small include cleanup
2025-04-29 17:15:15 +02:00 · 2025-04-29 17:00:09 +02:00 · 2025-04-29 13:15:34 +02:00 · 2025-04-27 21:14:04 -06:00 · 2025-04-27 11:08:50 -06:00 · 2025-04-27 11:08:48 -06:00
164 changed files with 4710 additions and 2495 deletions
--- a/.bazelrc
+++ b/.bazelrc
@@ -1,3 +1,6 @@
+# Enable Bzlmod for every Bazel command
+common --enable_bzlmod
+
 build --enable_platform_specific_config

 build:gcc9 --cxxopt=-std=c++2a
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -34,7 +34,7 @@ Checks: >-
  -modernize-pass-by-value,

  performance-*,
-  -performance-enum-size,
+  performance-enum-size,

  portability-*,

@@ -49,6 +49,7 @@ Checks: >-
  -readability-implicit-bool-conversion,
  -readability-isolate-declaration,
  -readability-magic-numbers,
+  -readability-math-missing-parentheses, #no, 'a + B * C' obeying math rules is not confusing,
  -readability-named-parameter,
  -readability-qualified-auto,
  -readability-redundant-access-specifiers,
--- a/.conan/test_package/CMakeLists.txt
+++ b/.conan/test_package/CMakeLists.txt
@@ -1,8 +1,7 @@
-cmake_minimum_required(VERSION 3.15)
-project(PackageTest CXX)
+cmake_minimum_required(VERSION 3.16)
+project(PackageTest LANGUAGES CXX)

 find_package(Catch2 CONFIG REQUIRED)

 add_executable(test_package test_package.cpp)
 target_link_libraries(test_package Catch2::Catch2WithMain)
-target_compile_features(test_package PRIVATE cxx_std_14)
--- a/.github/workflows/linux-bazel-builds.yml
+++ b/.github/workflows/linux-bazel-builds.yml
@@ -1,4 +1,4 @@
-name: Bazel build
+name: Linux Builds (Bazel)

 on: [push, pull_request]

@@ -7,18 +7,18 @@ jobs:
    name: Linux Ubuntu 22.04 Bazel build <GCC 11.2.0>
    runs-on: ubuntu-22.04
    strategy:
+      fail-fast: false
      matrix:
        compilation_mode: [fastbuild, dbg, opt]

    steps:
    - uses: actions/checkout@v4

-    - name: Mount bazel cache
+    - 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}} //...
+    - name: Build
+      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 (meson)
+name: Linux Builds (Meson)

 on: [push, pull_request]

@@ -7,6 +7,7 @@ jobs:
    name: meson ${{matrix.cxx}}, C++${{matrix.std}}, ${{matrix.build_type}}
    runs-on: ubuntu-22.04
    strategy:
+      fail-fast: false
      matrix:
        cxx:
          - g++-11
@@ -25,7 +26,7 @@ jobs:
        sudo apt-get update
        sudo apt-get install -y meson ninja-build ${{matrix.other_pkgs}}

-    - name: Configure build
+    - name: Configure
      env:
        CXX: ${{matrix.cxx}}
        CXXFLAGS: -std=c++${{matrix.std}} ${{matrix.cxxflags}}
@@ -34,11 +35,10 @@ jobs:
      run: |
        meson -Dbuildtype=${{matrix.build_type}} ${{runner.workspace}}/meson-build

-    - name: Build tests + lib
+    - name: Build
      working-directory: ${{runner.workspace}}/meson-build
      run: ninja

-    - name: Run tests
+    - name: Test
      working-directory: ${{runner.workspace}}/meson-build
-      run: |
-        meson test --verbose
+      run: meson test --verbose
--- a/.github/workflows/linux-other-builds.yml
+++ b/.github/workflows/linux-other-builds.yml
@@ -1,72 +1,73 @@
 # The builds in this file are more complex (e.g. they need custom CMake
 # configuration) and thus are unsuitable to the simple build matrix
 # approach used in simple-builds
-name: Linux builds (complex)
+name: Linux Builds (Complex)

 on: [push, pull_request]

 jobs:
  build:
    name: ${{matrix.build_description}}, ${{matrix.cxx}}, C++${{matrix.std}} ${{matrix.build_type}}
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    strategy:
+      fail-fast: false
      matrix:
        # We add builds one by one in this case, because there are no
        # dimensions that are shared across the builds
        include:

          # Single surrogate header build
-          - cxx: clang++-10
+          - cxx: clang++-14
            build_description: Surrogates build
            build_type: Debug
            std: 14
-            other_pkgs: clang-10
+            other_pkgs: clang-14
            cmake_configurations: -DCATCH_BUILD_SURROGATES=ON

-          # Extras and examples with gcc-7
-          - cxx: g++-7
+          # Extras and examples with gcc-11
+          - cxx: g++-11
            build_description: Extras + Examples
            build_type: Debug
            std: 14
-            other_pkgs: g++-7
+            other_pkgs: g++-11
            cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON
-          - cxx: g++-7
+          - cxx: g++-11
            build_description: Extras + Examples
            build_type: Release
            std: 14
-            other_pkgs: g++-7
+            other_pkgs: g++-11
            cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON

-          # Extras and examples with Clang-10
-          - cxx: clang++-10
+          # Extras and examples with Clang-14
+          - cxx: clang++-14
            build_description: Extras + Examples
            build_type: Debug
            std: 17
-            other_pkgs: clang-10
+            other_pkgs: clang-14
            cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON
-          - cxx: clang++-10
+          - cxx: clang++-14
            build_description: Extras + Examples
            build_type: Release
            std: 17
-            other_pkgs: clang-10
+            other_pkgs: clang-14
            cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON

-          # Configure tests with Clang-10
-          - cxx: clang++-10
+          # Configure tests with Clang-14
+          - cxx: clang++-14
            build_description: CMake configuration tests
            build_type: Debug
            std: 14
-            other_pkgs: clang-10
+            other_pkgs: clang-14
            cmake_configurations: -DCATCH_ENABLE_CONFIGURE_TESTS=ON

-          # Valgrind test Clang-10
-          - cxx: clang++-10
-            build_description: Valgrind tests
-            build_type: Debug
-            std: 14
-            other_pkgs: clang-10 valgrind
-            cmake_configurations: -DMEMORYCHECK_COMMAND=`which valgrind` -DMEMORYCHECK_COMMAND_OPTIONS="-q --track-origins=yes --leak-check=full --num-callers=50 --show-leak-kinds=definite --error-exitcode=1"
-            other_ctest_args: -T memcheck -LE uses-python
+          # Valgrind test Clang-14
+          # - cxx: clang++-14
+          #   build_description: Valgrind tests
+          #   build_type: Debug
+          #   std: 14
+          #   other_pkgs: clang-14 valgrind
+          #   cmake_configurations: -DMEMORYCHECK_COMMAND=`which valgrind` -DMEMORYCHECK_COMMAND_OPTIONS="-q --track-origins=yes --leak-check=full --num-callers=50 --show-leak-kinds=definite --error-exitcode=1"
+          #   other_ctest_args: -T memcheck -LE uses-python


    steps:
@@ -78,77 +79,51 @@ jobs:
        sudo apt-get install -y ninja-build ${{matrix.other_pkgs}}

    - name: Configure build
-      working-directory: ${{runner.workspace}}
-      env:
-        CXX: ${{matrix.cxx}}
-        CXXFLAGS: ${{matrix.cxxflags}}
      # Note: $GITHUB_WORKSPACE is distinct from ${{runner.workspace}}.
      #       This is important
      run: |
-        cmake -Bbuild -H$GITHUB_WORKSPACE \
+        cmake --preset basic-tests -GNinja \
              -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
+              -DCMAKE_CXX_COMPILER=${{matrix.cxx}} \
              -DCMAKE_CXX_STANDARD=${{matrix.std}} \
-              -DCMAKE_CXX_STANDARD_REQUIRED=ON \
-              -DCMAKE_CXX_EXTENSIONS=OFF \
-              -DCATCH_DEVELOPMENT_BUILD=ON \
-              ${{matrix.cmake_configurations}} \
-              -G Ninja
+              ${{matrix.cmake_configurations}}

-    - name: Build tests + lib
-      working-directory: ${{runner.workspace}}/build
-      run: ninja
+    - name: Build
+      run: cmake --build build
+
+    - name: Test
+      run: ctest --test-dir build -j --output-on-failure

-    - name: Run tests
-      env:
-          CTEST_OUTPUT_ON_FAILURE: 1
-      working-directory: ${{runner.workspace}}/build
-      run: ctest -C ${{matrix.build_type}} -j `nproc` ${{matrix.other_ctest_args}}
  clang-tidy:
-    name: clang-tidy ${{matrix.version}}, ${{matrix.build_description}}, C++${{matrix.std}} ${{matrix.build_type}}
+    name: clang-tidy
    runs-on: ubuntu-22.04
-    strategy:
-      matrix:
-        include:
-          - version: "15"
-            build_description: all
-            build_type: Debug
-            std: 17
-            other_pkgs: ''
-            cmake_configurations: -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON
    steps:
    - uses: actions/checkout@v4

    - name: Prepare environment
      run: |
        sudo apt-get update
-        sudo apt-get install -y ninja-build clang-${{matrix.version}} clang-tidy-${{matrix.version}} ${{matrix.other_pkgs}}
+        sudo apt-get install -y ninja-build clang-15 clang-tidy-15

-    - name: Configure build
-      working-directory: ${{runner.workspace}}
-      env:
-        CXX: clang++-${{matrix.version}}
-        CXXFLAGS: ${{matrix.cxxflags}}
+    - name: Configure
      # Note: $GITHUB_WORKSPACE is distinct from ${{runner.workspace}}.
      #       This is important
      run: |
-        clangtidy="clang-tidy-${{matrix.version}};-use-color"
+        clangtidy="clang-tidy-15;-use-color"
        # Use a dummy compiler/linker/ar/ranlib to effectively disable the
        # compilation and only run clang-tidy.
-        cmake -Bbuild -H$GITHUB_WORKSPACE \
-              -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
-              -DCMAKE_CXX_STANDARD=${{matrix.std}} \
-              -DCMAKE_CXX_STANDARD_REQUIRED=ON \
-              -DCMAKE_CXX_EXTENSIONS=OFF \
-              -DCATCH_DEVELOPMENT_BUILD=ON \
-              -DCMAKE_CXX_CLANG_TIDY="$clangtidy" \
-              -DCMAKE_CXX_COMPILER_LAUNCHER=/usr/bin/true \
+        cmake --preset basic-tests -GNinja \
              -DCMAKE_AR=/usr/bin/true \
+              -DCMAKE_BUILD_TYPE=Debug \
+              -DCMAKE_CXX_CLANG_TIDY="$clangtidy" \
              -DCMAKE_CXX_COMPILER_AR=/usr/bin/true \
-              -DCMAKE_RANLIB=/usr/bin/true \
+              -DCMAKE_CXX_COMPILER_LAUNCHER=/usr/bin/true \
+              -DCMAKE_CXX_COMPILER=clang++-15 \
              -DCMAKE_CXX_LINK_EXECUTABLE=/usr/bin/true \
-              ${{matrix.cmake_configurations}} \
-              -G Ninja
+              -DCMAKE_CXX_STANDARD=17 \
+              -DCMAKE_RANLIB=/usr/bin/true \
+              -DCATCH_BUILD_EXAMPLES=ON \
+              -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON

    - name: Run clang-tidy
-      working-directory: ${{runner.workspace}}/build
-      run: ninja
+      run: cmake --build build
--- a/.github/workflows/linux-simple-builds.yml
+++ b/.github/workflows/linux-simple-builds.yml
@@ -1,32 +1,33 @@
-name: Linux builds (basic)
+name: Linux Builds (Basic)

 on: [push, pull_request]

 jobs:
  build:
    name: ${{matrix.cxx}}, C++${{matrix.std}}, ${{matrix.build_type}}
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    strategy:
+      fail-fast: false
      matrix:
        cxx:
-          - g++-5
-          - g++-6
          - g++-7
          - g++-8
          - g++-9
          - g++-10
+          - g++-11
+          - g++-12
          - clang++-6.0
          - clang++-7
          - clang++-8
          - clang++-9
          - clang++-10
+          - clang++-11
+          - clang++-12
+          - clang++-13
+          - clang++-14
        build_type: [Debug, Release]
        std: [14]
        include:
-          - cxx: g++-5
-            other_pkgs: g++-5
-          - cxx: g++-6
-            other_pkgs: g++-6
          - cxx: g++-7
            other_pkgs: g++-7
          - cxx: g++-8
@@ -35,6 +36,10 @@ jobs:
            other_pkgs: g++-9
          - cxx: g++-10
            other_pkgs: g++-10
+          - cxx: g++-11
+            other_pkgs: g++-11
+          - cxx: g++-12
+            other_pkgs: g++-12
          - cxx: clang++-6.0
            other_pkgs: clang-6.0
          - cxx: clang++-7
@@ -45,79 +50,64 @@ jobs:
            other_pkgs: clang-9
          - cxx: clang++-10
            other_pkgs: clang-10
-          # Clang 6 + C++17
-          # does not work with the default libstdc++ version thanks
-          # to a disagreement on variant implementation.
-          # - cxx: clang++-6.0
-          #   build_type: Debug
-          #   std: 17
-          #   other_pkgs: clang-6.0
-          # - cxx: clang++-6.0
-          #   build_type: Release
-          #   std: 17
-          #   other_pkgs: clang-6.0
-          # Clang 10 + C++17
-          - cxx: clang++-10
+          - cxx: clang++-11
+            other_pkgs: clang-11
+          - cxx: clang++-12
+            other_pkgs: clang-12
+          - cxx: clang++-13
+            other_pkgs: clang-13
+          - cxx: clang++-14
+            other_pkgs: clang-14
+          # Clang 14 + C++17
+          - cxx: clang++-14
            build_type: Debug
            std: 17
-            other_pkgs: clang-10
-          - cxx: clang++-10
+            other_pkgs: clang-14
+          - cxx: clang++-14
            build_type: Release
            std: 17
-            other_pkgs: clang-10
-          - cxx: clang++-10
+            other_pkgs: clang-14
+          - cxx: clang++-14
            build_type: Debug
            std: 20
-            other_pkgs: clang-10
-          - cxx: clang++-10
+            other_pkgs: clang-14
+          - cxx: clang++-14
            build_type: Release
            std: 20
-            other_pkgs: clang-10
-          - cxx: g++-10
+            other_pkgs: clang-14
+          - cxx: g++-11
            build_type: Debug
            std: 20
-            other_pkgs: g++-10
-          - cxx: g++-10
+            other_pkgs: g++-11
+          - cxx: g++-11
            build_type: Release
            std: 20
-            other_pkgs: g++-10
+            other_pkgs: g++-11

    steps:
    - uses: actions/checkout@v4

-    - name: Add repositories for older GCC
+    - name: Add repositories for older compilers
      run: |
-        sudo apt-add-repository 'deb http://azure.archive.ubuntu.com/ubuntu/ bionic main'
-        sudo apt-add-repository 'deb http://azure.archive.ubuntu.com/ubuntu/ bionic universe'
-      if: ${{ matrix.cxx == 'g++-5' || matrix.cxx == 'g++-6' }}
+        sudo apt-add-repository 'deb http://azure.archive.ubuntu.com/ubuntu/ focal main'
+        sudo apt-add-repository 'deb http://azure.archive.ubuntu.com/ubuntu/ focal universe'

    - name: Prepare environment
      run: |
        sudo apt-get update
        sudo apt-get install -y ninja-build ${{matrix.other_pkgs}}

-    - name: Configure build
-      working-directory: ${{runner.workspace}}
-      env:
-        CXX: ${{matrix.cxx}}
-        CXXFLAGS: ${{matrix.cxxflags}}
+    - name: Configure
      # Note: $GITHUB_WORKSPACE is distinct from ${{runner.workspace}}.
      #       This is important
      run: |
-        cmake -Bbuild -H$GITHUB_WORKSPACE \
+        cmake --preset basic-tests -GNinja \
              -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
+              -DCMAKE_CXX_COMPILER=${{matrix.cxx}} \
+              -DCMAKE_CXX_STANDARD=${{matrix.std}}

-    - name: Build tests + lib
-      working-directory: ${{runner.workspace}}/build
-      run: ninja
+    - name: Build
+      run: cmake --build build

-    - name: Run tests
-      env:
-          CTEST_OUTPUT_ON_FAILURE: 1
-      working-directory: ${{runner.workspace}}/build
-      run: ctest -C ${{matrix.build_type}} -j `nproc`
+    - name: Test
+      run: ctest --test-dir build -j --output-on-failure
--- a/.github/workflows/mac-builds-m1.yml
+++ b/.github/workflows/mac-builds-m1.yml
@@ -1,44 +0,0 @@
-name: M1 Mac builds
-
-on: [push, pull_request]
-
-jobs:
-  build:
-    runs-on: macos-14
-    strategy:
-      matrix:
-        cxx:
-          - clang++
-        build_type: [Debug, Release]
-        std: [14, 17]
-        include:
-          - build_type: Debug
-            examples: ON
-            extra_tests: ON
-
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Configure build
-      working-directory: ${{runner.workspace}}
-      env:
-        CXX: ${{matrix.cxx}}
-        CXXFLAGS: ${{matrix.cxxflags}}
-      run: |
-        cmake -Bbuild -H$GITHUB_WORKSPACE \
-              -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
-              -DCMAKE_CXX_STANDARD=${{matrix.std}} \
-              -DCMAKE_CXX_STANDARD_REQUIRED=ON \
-              -DCATCH_DEVELOPMENT_BUILD=ON \
-              -DCATCH_BUILD_EXAMPLES=${{matrix.examples}} \
-              -DCATCH_BUILD_EXTRA_TESTS=${{matrix.examples}}
-
-    - name: Build tests + lib
-      working-directory: ${{runner.workspace}}/build
-      run: make -j `sysctl -n hw.ncpu`
-
-    - name: Run tests
-      env:
-          CTEST_OUTPUT_ON_FAILURE: 1
-      working-directory: ${{runner.workspace}}/build
-      run: ctest -C ${{matrix.build_type}} -j `sysctl -n hw.ncpu`
--- a/.github/workflows/mac-builds.yml
+++ b/.github/workflows/mac-builds.yml
@@ -1,51 +1,32 @@
-name: Mac builds
+name: Mac Builds

 on: [push, pull_request]

 jobs:
  build:
-    # macos-12 updated to a toolchain that crashes when linking the
-    # test binary. This seems to be a known bug in that version,
-    # and will eventually get fixed in an update. After that, we can go
-    # back to newer macos images.
-    runs-on: macos-11
+    # From macos-14 forward, the baseline "macos-X" image is Arm based,
+    # and not Intel based.
+    runs-on: ${{matrix.image}}
    strategy:
+      fail-fast: false
      matrix:
-        cxx:
-          - g++-11
-          - clang++
+        image: [macos-13, macos-14, macos-15]
        build_type: [Debug, Release]
        std: [14, 17]
-        include:
-          - build_type: Debug
-            examples: ON
-            extra_tests: ON

    steps:
    - uses: actions/checkout@v4

-    - name: Configure build
-      working-directory: ${{runner.workspace}}
-      env:
-        CXX: ${{matrix.cxx}}
-        CXXFLAGS: ${{matrix.cxxflags}}
-      # Note: $GITHUB_WORKSPACE is distinct from ${{runner.workspace}}.
-      #       This is important
+    - name: Configure
      run: |
-        cmake -Bbuild -H$GITHUB_WORKSPACE \
+        cmake --preset basic-tests -GNinja \
              -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}}
+              -DCATCH_BUILD_EXAMPLES=ON \
+              -DCATCH_BUILD_EXTRA_TESTS=ON

-    - name: Build tests + lib
-      working-directory: ${{runner.workspace}}/build
-      run: make -j `sysctl -n hw.ncpu`
+    - name: Build
+      run: cmake --build build

-    - name: Run tests
-      env:
-          CTEST_OUTPUT_ON_FAILURE: 1
-      working-directory: ${{runner.workspace}}/build
-      run: ctest -C ${{matrix.build_type}} -j `sysctl -n hw.ncpu`
+    - name: Test
+      run: ctest --test-dir build -j --output-on-failure
--- a/.github/workflows/package-manager-builds.yaml
+++ b/.github/workflows/package-manager-builds.yaml
@@ -5,7 +5,7 @@ on: [push, pull_request]
 jobs:
  conan_builds:
    name: Conan ${{matrix.conan_version}}
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    strategy:
      matrix:
        conan_version:
--- a/.github/workflows/validate-header-guards.yml
+++ b/.github/workflows/validate-header-guards.yml
@@ -5,7 +5,7 @@ on: [push, pull_request]
 jobs:
  build:
    # Set the type of machine to run on
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    steps:

      - name: Checkout source code
--- a/.github/workflows/windows-simple-builds.yml
+++ b/.github/workflows/windows-simple-builds.yml
@@ -1,4 +1,4 @@
-name: Windows builds (basic)
+name: Windows Builds (Basic)

 on: [push, pull_request]

@@ -7,8 +7,9 @@ jobs:
    name: ${{matrix.os}}, ${{matrix.std}}, ${{matrix.build_type}}, ${{matrix.platform}}
    runs-on: ${{matrix.os}}
    strategy:
+      fail-fast: false
      matrix:
-        os: [windows-2019, windows-2022]
+        os: [windows-2019, windows-2022, windows-2025]
        platform: [Win32, x64]
        build_type: [Debug, Release]
        std: [14, 17]
@@ -16,22 +17,15 @@ jobs:
      - uses: actions/checkout@v4

      - name: Configure build
-        working-directory: ${{runner.workspace}}
        run: |
-          cmake -S $Env:GITHUB_WORKSPACE               `
-                -B ${{runner.workspace}}/build         `
-                -DCMAKE_CXX_STANDARD=${{matrix.std}}   `
+          cmake --preset all-tests `
                -A ${{matrix.platform}} `
-                --preset all-tests
+                -DCMAKE_CXX_STANDARD=${{matrix.std}} `

      - 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%
+        run: ctest --test-dir build -C ${{matrix.build_type}} -j %NUMBER_OF_PROCESSORS% --output-on-failure
        shell: cmd
--- a/.gitignore
+++ b/.gitignore
@@ -25,7 +25,7 @@ Build
 cmake-build-*
 benchmark-dir
 .conan/test_package/build
-.conan/test_package/CMakeUserPresets.json
+**/CMakeUserPresets.json
 bazel-*
 MODULE.bazel.lock
 build-fuzzers
@@ -37,3 +37,4 @@ msvc-sln*
 docs/doxygen
 *.cache
 compile_commands.json
+**/*.unapproved.txt
--- a/BUILD.bazel
+++ b/BUILD.bazel
@@ -56,6 +56,8 @@ expand_template(
        "#cmakedefine CATCH_CONFIG_WCHAR": "",
        "#cmakedefine CATCH_CONFIG_WINDOWS_CRTDBG": "",
        "#cmakedefine CATCH_CONFIG_WINDOWS_SEH": "",
+        "#cmakedefine CATCH_CONFIG_USE_BUILTIN_CONSTANT_P": "",
+        "#cmakedefine CATCH_CONFIG_NO_USE_BUILTIN_CONSTANT_P": "",
    },
    template = "src/catch2/catch_user_config.hpp.in",
 )
@@ -66,7 +68,7 @@ expand_template(
 cc_library(
    name = "catch2_generated",
    hdrs = ["catch2/catch_user_config.hpp"],
-    include_prefix = ".",  # to manipulate -I of dependenices
+    include_prefix = ".",  # to manipulate -I of dependencies
    visibility = ["//visibility:public"],
 )

--- a/CMake/Catch2Config.cmake.in
+++ b/CMake/Catch2Config.cmake.in
@@ -1,6 +1,5 @@
@PACKAGE_INIT@

-
 # Avoid repeatedly including the targets
 if(NOT TARGET Catch2::Catch2)
  # Provide path for scripts
--- a/CMake/CatchConfigOptions.cmake
+++ b/CMake/CatchConfigOptions.cmake
@@ -14,7 +14,6 @@
 #
 # For detailed docs look into docs/configuration.md

-
 macro(AddOverridableConfigOption OptionBaseName)
  option(CATCH_CONFIG_${OptionBaseName} "Read docs/configuration.md for details" OFF)
  option(CATCH_CONFIG_NO_${OptionBaseName} "Read docs/configuration.md for details" OFF)
@@ -44,6 +43,7 @@ set(_OverridableOptions
  "WINDOWS_SEH"
  "GETENV"
  "EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT"
+  "USE_BUILTIN_CONSTANT_P"
 )

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

 include(CheckCXXCompilerFlag)
 function(add_cxx_flag_if_supported_to_targets flagname targets)
-    string(MAKE_C_IDENTIFIER ${flagname} flag_identifier )
+  string(MAKE_C_IDENTIFIER ${flagname} flag_identifier)
  check_cxx_compiler_flag("${flagname}" HAVE_FLAG_${flag_identifier})

-    if (HAVE_FLAG_${flag_identifier})
+  if(HAVE_FLAG_${flag_identifier})
    foreach(target ${targets})
      target_compile_options(${target} PRIVATE ${flagname})
    endforeach()
@@ -24,25 +24,24 @@ function(add_warnings_to_targets targets)
  LIST(LENGTH targets TARGETS_LEN)
  # For now we just assume 2 possibilities: msvc and msvc-like compilers,
  # and other.
-    if (MSVC)
+  if(MSVC)
    foreach(target ${targets})
      # Force MSVC to consider everything as encoded in utf-8
-            target_compile_options( ${target} PRIVATE /utf-8 )
+      target_compile_options(${target} PRIVATE /utf-8)
      # Enable Werror equivalent
-            if (CATCH_ENABLE_WERROR)
-                target_compile_options( ${target} PRIVATE /WX )
+      if(CATCH_ENABLE_WERROR)
+        target_compile_options(${target} PRIVATE /WX)
      endif()

      # MSVC is currently handled specially
-            if ( CMAKE_CXX_COMPILER_ID MATCHES "MSVC" )
+      if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
        STRING(REGEX REPLACE "/W[0-9]" "/W4" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS}) # override default warning level
-                target_compile_options( ${target} PRIVATE /w44265 /w44061 /w44062 /w45038 )
+        target_compile_options(${target} PRIVATE /w44265 /w44061 /w44062 /w45038)
      endif()
    endforeach()
-
  endif()

-    if (NOT MSVC)
+  if(NOT MSVC)
    set(CHECKED_WARNING_FLAGS
      "-Wabsolute-value"
      "-Wall"
@@ -56,6 +55,7 @@ function(add_warnings_to_targets targets)
      "-Wexit-time-destructors"
      "-Wextra"
      "-Wextra-semi"
+      "-Wfloat-equal"
      "-Wglobal-constructors"
      "-Winit-self"
      "-Wmisleading-indentation"
@@ -102,10 +102,10 @@ function(add_warnings_to_targets targets)
      add_cxx_flag_if_supported_to_targets(${warning} "${targets}")
    endforeach()

-        if (CATCH_ENABLE_WERROR)
+    if(CATCH_ENABLE_WERROR)
      foreach(target ${targets})
        # Enable Werror equivalent
-                target_compile_options( ${target} PRIVATE -Werror )
+        target_compile_options(${target} PRIVATE -Werror)
      endforeach()
    endif()
  endif()
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.10)
+cmake_minimum_required(VERSION 3.16)

 # detect if Catch is being bundled,
 # disable testsuite in that case
@@ -8,6 +8,8 @@ else()
  set(NOT_SUBPROJECT OFF)
 endif()

+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+
 option(CATCH_INSTALL_DOCS "Install documentation alongside library" ON)
 option(CATCH_INSTALL_EXTRAS "Install extras (CMake scripts, debugger helpers) alongside library" ON)
 option(CATCH_DEVELOPMENT_BUILD "Build tests, enable warnings, enable Werror, etc" OFF)
@@ -24,30 +26,26 @@ cmake_dependent_option(CATCH_BUILD_SURROGATES "Enable generating and building su
 cmake_dependent_option(CATCH_ENABLE_CONFIGURE_TESTS "Enable CMake configuration tests. WARNING: VERY EXPENSIVE" OFF "CATCH_DEVELOPMENT_BUILD" OFF)
 cmake_dependent_option(CATCH_ENABLE_CMAKE_HELPER_TESTS "Enable CMake helper tests. WARNING: VERY EXPENSIVE" OFF "CATCH_DEVELOPMENT_BUILD" OFF)

-
 # Catch2's build breaks if done in-tree. You probably should not build
 # things in tree anyway, but we can allow projects that include Catch2
 # as a subproject to build in-tree as long as it is not in our tree.
-if (CMAKE_BINARY_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+if(CMAKE_BINARY_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
  message(FATAL_ERROR "Building in-source is not supported! Create a build dir and remove ${CMAKE_SOURCE_DIR}/CMakeCache.txt")
 endif()

 project(Catch2
-  VERSION 3.6.0 # CML version placeholder, don't delete
+  VERSION 3.8.1 # CML version placeholder, don't delete
  LANGUAGES CXX
-  # HOMEPAGE_URL is not supported until CMake version 3.12, which
-  # we do not target yet.
-  # HOMEPAGE_URL "https://github.com/catchorg/Catch2"
+  HOMEPAGE_URL "https://github.com/catchorg/Catch2"
  DESCRIPTION "A modern, C++-native, unit test framework."
 )

-
 # Provide path for scripts. We first add path to the scripts we don't use,
 # but projects including us might, and set the path up to parent scope.
 # Then we also add path that we use to configure the project, but is of
 # no use to top level projects.
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/extras")
-if (NOT NOT_SUBPROJECT)
+if(NOT NOT_SUBPROJECT)
  set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" PARENT_SCOPE)
 endif()
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/CMake")
@@ -71,7 +69,6 @@ if(CATCH_TEST_USE_WMAIN)
  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /ENTRY:wmainCRTStartup")
 endif()

-
 # Basic paths
 set(CATCH_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(SOURCES_DIR ${CATCH_DIR}/src/catch2)
@@ -81,34 +78,38 @@ set(SELF_TEST_DIR ${CATCH_DIR}/tests/SelfTest)
 add_subdirectory(src)

 # Build tests only if requested
-if (BUILD_TESTING AND CATCH_BUILD_TESTING AND NOT_SUBPROJECT)
+if(BUILD_TESTING AND CATCH_BUILD_TESTING AND NOT_SUBPROJECT)
  find_package(PythonInterp 3 REQUIRED)
-    if (NOT PYTHONINTERP_FOUND)
+  if(NOT PYTHONINTERP_FOUND)
    message(FATAL_ERROR "Python not found, but required for tests")
  endif()
+  set(CMAKE_FOLDER "tests")
  add_subdirectory(tests)
 endif()

 if(CATCH_BUILD_EXAMPLES)
+  set(CMAKE_FOLDER "Examples")
  add_subdirectory(examples)
 endif()

 if(CATCH_BUILD_EXTRA_TESTS)
+  set(CMAKE_FOLDER "tests/ExtraTests")
  add_subdirectory(tests/ExtraTests)
 endif()

 if(CATCH_BUILD_FUZZERS)
+  set(CMAKE_FOLDER "fuzzing")
  add_subdirectory(fuzzing)
 endif()

-if (CATCH_DEVELOPMENT_BUILD)
+if(CATCH_DEVELOPMENT_BUILD)
  add_warnings_to_targets("${CATCH_WARNING_TARGETS}")
 endif()

 # Only perform the installation steps when Catch is not being used as
 # a subproject via `add_subdirectory`, or the destinations will break,
 # see https://github.com/catchorg/Catch2/issues/1373
-if (NOT_SUBPROJECT)
+if(NOT_SUBPROJECT)
  configure_package_config_file(
    ${CMAKE_CURRENT_LIST_DIR}/CMake/Catch2Config.cmake.in
    ${CMAKE_CURRENT_BINARY_DIR}/Catch2Config.cmake
@@ -187,15 +188,7 @@ if (NOT_SUBPROJECT)
      ${PKGCONFIG_INSTALL_DIR}
  )

-    # CPack/CMake started taking the package version from project version 3.12
-    # So we need to set the version manually for older CMake versions
-    if(${CMAKE_VERSION} VERSION_LESS "3.12.0")
-        set(CPACK_PACKAGE_VERSION ${PROJECT_VERSION})
-    endif()
-
  set(CPACK_PACKAGE_CONTACT "https://github.com/catchorg/Catch2/")

-
-    include( CPack )
-
+  include(CPack)
 endif()
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -3,9 +3,14 @@
    "configurePresets": [
        {
            "name": "basic-tests",
+            "binaryDir": "build",
+            "installDir": "build/install",
            "displayName": "Basic development build",
            "description": "Enables development build with basic tests that are cheap to build and run",
            "cacheVariables": {
+                "CMAKE_CXX_EXTENSIONS": "OFF",
+                "CMAKE_CXX_STANDARD_REQUIRED": "ON",
+                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
                "CATCH_DEVELOPMENT_BUILD": "ON"
            }
        },
--- a/MAINTAINERS.md
+++ b/MAINTAINERS.md
@@ -0,0 +1,11 @@
+<a id="top"></a>
+# Catch2 Maintainers
+
+## Current
+
+* Chris Thrasher ([@christhrasher](https://github.com/ChrisThrasher)), gpg key: 56FB686C9DFC8E2C
+* Martin Hořeňovský ([@horenmar](https://github.com/horenmar)), gpg key: E29C46F3B8A7502860793B7DECC9C20E314B2360
+
+## Retired
+
+* Phil Nash ([@philsquared](https://github.com/philsquared))
--- a/MODULE.bazel
+++ b/MODULE.bazel
@@ -1,3 +1,4 @@
 module(name = "catch2")

-bazel_dep(name = "bazel_skylib", version = "1.5.0")
+bazel_dep(name = "bazel_skylib", version = "1.7.1")
+bazel_dep(name = "rules_cc", version = "0.0.17")
--- a/WORKSPACE.bazel
+++ b/WORKSPACE.bazel
@@ -1,16 +0,0 @@
-workspace(name = "catch2")
-
-load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
-
-http_archive(
-    name = "bazel_skylib",
-    sha256 = "cd55a062e763b9349921f0f5db8c3933288dc8ba4f76dd9416aac68acee3cb94",
-    urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/bazel-skylib/releases/download/1.5.0/bazel-skylib-1.5.0.tar.gz",
-        "https://github.com/bazelbuild/bazel-skylib/releases/download/1.5.0/bazel-skylib-1.5.0.tar.gz",
-    ],
-)
-
-load("@bazel_skylib//:workspace.bzl", "bazel_skylib_workspace")
-
-bazel_skylib_workspace()
--- a/docs/assertions.md
+++ b/docs/assertions.md
@@ -110,7 +110,7 @@ Expects that an exception is thrown that, when converted to a string, matches th

 e.g.
 ```cpp
-REQUIRE_THROWS_WITH( openThePodBayDoors(), Contains( "afraid" ) && Contains( "can't do that" ) );
+REQUIRE_THROWS_WITH( openThePodBayDoors(), ContainsSubstring( "afraid" ) && ContainsSubstring( "can't do that" ) );
 REQUIRE_THROWS_WITH( dismantleHal(), "My mind is going" );
 ```

--- a/docs/cmake-integration.md
+++ b/docs/cmake-integration.md
@@ -8,6 +8,7 @@
 [`CATCH_CONFIG_*` customization options in CMake](#catch_config_-customization-options-in-cmake)<br>
 [Installing Catch2 from git repository](#installing-catch2-from-git-repository)<br>
 [Installing Catch2 from vcpkg](#installing-catch2-from-vcpkg)<br>
+[Installing Catch2 from Bazel](#installing-catch2-from-bazel)<br>

 Because we use CMake to build Catch2, we also provide a couple of
 integration points for our users.
@@ -80,12 +81,11 @@ to your CMake module path.

 `Catch.cmake` provides function `catch_discover_tests` to get tests from
 a target. This function works by running the resulting executable with
-`--list-test-names-only` flag, and then parsing the output to find all
-existing tests.
+`--list-test` flag, and then parsing the output to find all existing tests.

 #### Usage
 ```cmake
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.16)

 project(baz LANGUAGES CXX VERSION 0.0.1)

@@ -127,6 +127,8 @@ catch_discover_tests(target
                     [OUTPUT_PREFIX prefix]
                     [OUTPUT_SUFFIX suffix]
                     [DISCOVERY_MODE <POST_BUILD|PRE_TEST>]
+                     [SKIP_IS_FAILURE]
+                     [ADD_TAGS_AS_LABELS]
 )
 ```

@@ -210,6 +212,15 @@ execution (useful e.g. in cross-compilation environments).
 calling ``catch_discover_tests``. This provides a mechanism for globally
 selecting a preferred test discovery behavior.

+* `SKIP_IS_FAILURE`
+
+Skipped tests will be marked as failed instead.
+
+* `ADD_TAGS_AS_LABELS`
+
+Add the tags from tests as labels to CTest.
+
+
 ### `ParseAndAddCatchTests.cmake`

 ⚠ This script is [deprecated](https://github.com/catchorg/Catch2/pull/2120)
@@ -228,7 +239,7 @@ parsed are *silently ignored*.
 #### Usage

 ```cmake
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.16)

 project(baz LANGUAGES CXX VERSION 0.0.1)

--- a/docs/command-line.md
+++ b/docs/command-line.md
@@ -123,7 +123,7 @@ specs. You can:
    This allows test cases that are tagged with **either** "[some-tag]" **or**
    "[other-tag]". A test case with both will obviously also pass the filter.

-    Note that commas take precendence over simple concatenation. This means
+    Note that commas take precedence over simple concatenation. This means
    that `[a][b],[c]` accepts tests that are tagged with either both "[a]" and
    "[b]", or tests that are tagged with just "[c]".

--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -158,11 +158,14 @@ by using `_NO_` in the macro, e.g. `CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS`.
    CATCH_CONFIG_ANDROID_LOGWRITE           // Use android's logging system for debug output
    CATCH_CONFIG_GLOBAL_NEXTAFTER           // Use nextafter{,f,l} instead of std::nextafter
    CATCH_CONFIG_GETENV                     // System has a working `getenv`
+    CATCH_CONFIG_USE_BUILTIN_CONSTANT_P     // Use __builtin_constant_p to trigger warnings

 > [`CATCH_CONFIG_ANDROID_LOGWRITE`](https://github.com/catchorg/Catch2/issues/1743) and [`CATCH_CONFIG_GLOBAL_NEXTAFTER`](https://github.com/catchorg/Catch2/pull/1739) were introduced in Catch2 2.10.0

 > `CATCH_CONFIG_GETENV` was [introduced](https://github.com/catchorg/Catch2/pull/2562) in Catch2 3.2.0

+> `CATCH_CONFIG_USE_BUILTIN_CONSTANT_P` was introduced in Catch2 vX.Y.Z
+
 Currently Catch enables `CATCH_CONFIG_WINDOWS_SEH` only when compiled with MSVC, because some versions of MinGW do not have the necessary Win32 API support.

 `CATCH_CONFIG_POSIX_SIGNALS` is on by default, except when Catch is compiled under `Cygwin`, where it is disabled by default (but can be force-enabled by defining `CATCH_CONFIG_POSIX_SIGNALS`).
@@ -183,6 +186,12 @@ With the exception of `CATCH_CONFIG_EXPERIMENTAL_REDIRECT`,
 these toggles can be disabled by using `_NO_` form of the toggle,
 e.g. `CATCH_CONFIG_NO_WINDOWS_SEH`.

+`CATCH_CONFIG_USE_BUILTIN_CONSTANT_P` is ON by default for Clang and GCC
+(but as far as possible, not for other compilers masquerading for these
+two). However, it can cause bugs where the enclosed code is evaluated, even
+though it should not be, e.g. in [#2925](https://github.com/catchorg/Catch2/issues/2925).
+
+
 ### `CATCH_CONFIG_FAST_COMPILE`
 This compile-time flag speeds up compilation of assertion macros by ~20%,
 by disabling the generation of assertion-local try-catch blocks for
--- a/docs/contributing.md
+++ b/docs/contributing.md
@@ -107,8 +107,7 @@ cmake -B debug-build -S . -DCMAKE_BUILD_TYPE=Debug --preset all-tests
 cmake --build debug-build

 # 4. Run the tests using CTest
-cd debug-build
-ctest -j 4 --output-on-failure -C Debug
+ctest -j 4 --output-on-failure -C Debug --test-dir debug-build
 ```
 <sup><a href='/tools/scripts/buildAndTest.sh#L6-L19' title='File snippet `catch2-build-and-test` was extracted from'>snippet source</a> | <a href='#snippet-catch2-build-and-test' title='Navigate to start of snippet `catch2-build-and-test`'>anchor</a></sup>
 <!-- endSnippet -->
--- a/docs/deprecations.md
+++ b/docs/deprecations.md
@@ -35,6 +35,19 @@ being aborted (when using `--abort` or `--abortx`). It is however
 **NOT** invoked for test cases that are [explicitly skipped using the `SKIP`
 macro](skipping-passing-failing.md#top).

+
+### Non-const function for `TEST_CASE_METHOD`
+
+> Deprecated in Catch2 vX.Y.Z
+
+Currently, the member function generated for `TEST_CASE_METHOD` is
+not `const` qualified. In the future, the generated member function will
+be `const` qualified, just as `TEST_CASE_PERSISTENT_FIXTURE` does.
+
+If you are mutating the fixture instance from within the test case, and
+want to keep doing so in the future, mark the mutated members as `mutable`.
+
+
 ---

 [Home](Readme.md#top)
--- a/docs/generators.md
+++ b/docs/generators.md
@@ -21,7 +21,10 @@ The "Generators" `TEST_CASE` will be entered 3 times, and the value of
 `i` will be 1, 3, and 5 in turn. `GENERATE`s can also be used multiple
 times at the same scope, in which case the result will be a cartesian
 product of all elements in the generators. This means that in the snippet
-below, the test case will be run 6 (2\*3) times.
+below, the test case will be run 6 (2\*3) times. The `GENERATE` macro
+is defined in the `catch_generators.hpp` header, so compiling
+the code examples below also requires
+`#include <catch2/generators/catch_generators.hpp>`.

 ```cpp
 TEST_CASE("Generators") {
@@ -103,7 +106,7 @@ a test case,
 * 2 fundamental generators
  * `SingleValueGenerator<T>` -- contains only single element
  * `FixedValuesGenerator<T>` -- contains multiple elements
-* 5 generic generators that modify other generators
+* 5 generic generators that modify other generators (defined in `catch2/generators/catch_generators_adapters.hpp`)
  * `FilterGenerator<T, Predicate>` -- filters out elements from a generator
  for which the predicate returns "false"
  * `TakeGenerator<T>` -- takes first `n` elements from a generator
@@ -111,11 +114,11 @@ a test case,
  * `MapGenerator<T, U, Func>` -- returns the result of applying `Func`
  on elements from a different generator
  * `ChunkGenerator<T>` -- returns chunks (inside `std::vector`) of n elements from a generator
-* 4 specific purpose generators
+* 4 specific purpose generators (defined in `catch2/generators/catch_generators_random.hpp`)
  * `RandomIntegerGenerator<Integral>` -- generates random Integrals from range
  * `RandomFloatGenerator<Float>` -- generates random Floats from range
-  * `RangeGenerator<T>(first, last)` -- generates all values inside a `[first, last)` arithmetic range
-  * `IteratorGenerator<T>` -- copies and returns values from an iterator range
+  * `RangeGenerator<T>(first, last)` -- generates all values inside a `[first, last)` arithmetic range (defined in `catch2/generators/catch_generators_range.hpp`)
+  * `IteratorGenerator<T>` -- copies and returns values from an iterator range (defined in `catch2/generators/catch_generators_range.hpp`)

 > `ChunkGenerator<T>`, `RandomIntegerGenerator<Integral>`, `RandomFloatGenerator<Float>` and `RangeGenerator<T>` were introduced in Catch2 2.7.0.

@@ -216,8 +219,8 @@ For floating point generators, the situation is much more complex.
 Generally Catch2 only promises reproducibility (or even just correctness!)
 on platforms that obey the IEEE-754 standard. Furthermore, reproducibility
 only applies between binaries that perform floating point math in the
-same way, e.g. if you compile a binary targetting the x87 FPU and another
-one targetting SSE2 for floating point math, their results will vary.
+same way, e.g. if you compile a binary targeting the x87 FPU and another
+one targeting SSE2 for floating point math, their results will vary.
 Similarly, binaries compiled with compiler flags that relax the IEEE-754
 adherence, e.g. `-ffast-math`, might provide different results than those
 compiled for strict IEEE-754 adherence.
--- a/docs/list-of-examples.md
+++ b/docs/list-of-examples.md
@@ -8,6 +8,7 @@
 - Assertion: [REQUIRE, CHECK](../examples/030-Asn-Require-Check.cpp)
 - Fixture: [Sections](../examples/100-Fix-Section.cpp)
 - Fixture: [Class-based fixtures](../examples/110-Fix-ClassFixture.cpp)
+- Fixture: [Persistent fixtures](../examples/111-Fix-PersistentFixture.cpp)
 - BDD: [SCENARIO, GIVEN, WHEN, THEN](../examples/120-Bdd-ScenarioGivenWhenThen.cpp)
 - Listener: [Listeners](../examples/210-Evt-EventListeners.cpp)
 - Configuration: [Provide your own output streams](../examples/231-Cfg-OutputStreams.cpp)
--- a/docs/matchers.md
+++ b/docs/matchers.md
@@ -210,15 +210,36 @@ The other miscellaneous matcher utility is exception matching.

 #### Matching exceptions

-Catch2 provides a utility macro for asserting that an expression
-throws exception of specific type, and that the exception has desired
-properties. The macro is `REQUIRE_THROWS_MATCHES(expr, ExceptionType, Matcher)`.
+Because exceptions are a bit special, Catch2 has a separate macro for them.
+
+
+The basic form is
+
+```
+REQUIRE_THROWS_MATCHES(expr, ExceptionType, Matcher)
+```
+
+and it checks that the `expr` throws an exception, that exception is derived
+from the `ExceptionType` type, and then `Matcher::match` is called on
+the caught exception.

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

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

-Catch2 currently provides two matchers for exceptions.
-These are:
+```cpp
+REQUIRE_THROWS_MATCHES(parse(...),
+                       parse_error,
+                       Predicate<parse_error>([] (parse_error const& err) -> bool { return err.line() == 1; })
+);
+```
+
+but if you intend to thoroughly test your error reporting, I recommend
+defining a specialized matcher.
+
+
+Catch2 also provides 2 built-in matchers for checking the error message
+inside an exception (it must be derived from `std::exception`):
 * `Message(std::string message)`.
 * `MessageMatches(Matcher matcher)`.

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

-Note that `DerivedException` in the example above has to derive from
-`std::exception` for the example to work.
-
-> the exception message matcher lives in `catch2/matchers/catch_matchers_exception.hpp`
+> the exception message matchers live in `catch2/matchers/catch_matchers_exception.hpp`


 ### Generic range Matchers
--- a/docs/other-macros.md
+++ b/docs/other-macros.md
@@ -93,30 +93,6 @@ TEST_CASE("STATIC_CHECK showcase", "[traits]") {

 ## Test case related macros

-* `METHOD_AS_TEST_CASE`
-
-`METHOD_AS_TEST_CASE( member-function-pointer, description )` lets you
-register a member function of a class as a Catch2 test case. The class
-will be separately instantiated for each method registered in this way.
-
-```cpp
-class TestClass {
-    std::string s;
-
-public:
-    TestClass()
-        :s( "hello" )
-    {}
-
-    void testCase() {
-        REQUIRE( s == "hello" );
-    }
-};
-
-
-METHOD_AS_TEST_CASE( TestClass::testCase, "Use class's method as a test case", "[class]" )
-```
-
 * `REGISTER_TEST_CASE`

 `REGISTER_TEST_CASE( function, description )` let's you register
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -2,6 +2,10 @@

 # Release notes
 **Contents**<br>
+[3.8.1](#381)<br>
+[3.8.0](#380)<br>
+[3.7.1](#371)<br>
+[3.7.0](#370)<br>
 [3.6.0](#360)<br>
 [3.5.4](#354)<br>
 [3.5.3](#353)<br>
@@ -63,6 +67,78 @@
 [Even Older versions](#even-older-versions)<br>


+## 3.8.1
+
+### Fixes
+* Fixed bug where catch_discover_tests fails when no TEST_CASEs are present (#2962)
+* Fixed Clang 19 -Wc++20-extensions warning (#2968)
+
+
+## 3.8.0
+
+### Improvements
+* Added `std::initializer_list` overloads for `(Unordered)RangeEquals` matcher (#2915, #2919)
+* Added explicit casts to silence GCC's `Wconversion` (#2875)
+* Made the use of `builtin_constant_p` tricks in assertion macros configurable (#2925)
+  * It is used to prod GCC-like compilers into providing warnings for the asserted expressions, but the compilers miscompile it annoyingly often.
+* Cleaned out Clang-Tidy's `performance-enum-size` warnings
+* Added support for using `from_range` generator with iterators with `value_type = const T` (#2926)
+  * This is not correct `value_type` typedef, but it is used in the wild and the change does not make the code meaningfully worse.
+
+### Fixes
+* Fixed crash when stringifying pre-1970 (epoch) dates on Windows (#2944)
+
+### Miscellaneous
+* Fixes and improvements for `catch_discover_tests` CMake helper
+  * Removed redundant `CTEST_FILE` param when creating the indirection file for `PRE_TEST` discovery mode (#2936)
+  * Rewrote the test discovery logic to use output from the JSON reporter
+    * This means that `catch_discover_tests` now requires CMake 3.19 or newer
+  * Added `ADD_TAGS_AS_LABELS` option. If specified, each CTest test will be labeled with corresponding Catch2's test tag
+* Bumped up the minimum required CMake version to build Catch2 to 3.16
+* Meson build now provides option to avoid installing Catch2
+* Bazel build is moved to Bzlmod.
+
+
+## 3.7.1
+
+### Improvements
+* Applied the JUnit reporter's optimization from last release to the SonarQube reporter
+* Suppressed `-Wuseless-cast` in `CHECK_THROWS_MATCHES` (#2904)
+* Standardize exit codes for various failures
+  * Running no tests is now guaranteed to exit with 2 (without the `--allow-running-no-tests` flag)
+  * All tests skipped is now always 4 (...)
+  * Assertion failures are now always 42
+  * and so on
+
+### Fixes
+* Fixed out-of-bounds access when the arg parser encounters single `-` as an argument (#2905)
+
+### Miscellaneous
+* Added `catch_config_prefix_messages.hpp` to meson build (#2903)
+* `catch_discover_tests` now supports skipped tests (#2873)
+  * You can get the old behaviour by calling `catch_discover_tests` with `SKIP_IS_FAILURE` option.
+
+
+## 3.7.0
+
+### Improvements
+* Slightly improved compile times of benchmarks
+* Made the resolution estimation in benchmarks slightly more precise
+* Added new test case macro, `TEST_CASE_PERSISTENT_FIXTURE` (#2885, #1602)
+  * Unlike `TEST_CASE_METHOD`, the same underlying instance is used for all partial runs of that test case
+* **MASSIVELY** improved performance of the JUnit reporter when handling successful assertions (#2897)
+  * For 1 test case and 10M assertions, the new reporter runs 3x faster and uses up only 8 MB of memory, while the old one needs 7 GB of memory.
+* Reworked how output redirects works.
+  * Combining a reporter writing to stdout with capturing reporter no longer leads to the capturing reporter seeing all of the other reporter's output.
+  * The file based redirect no longer opens up a new temporary file for each partial test case run, so it will not run out of temporary files when running many tests in single process.
+
+### Miscellaneous
+* Better documentation for matchers on thrown exceptions (`REQUIRE_THROWS_MATCHES`)
+* Improved `catch_discover_tests`'s handling of environment paths (#2878)
+  * It won't reorder paths in `DL_PATHS` or `DYLD_FRAMEWORK_PATHS` args
+  * It won't overwrite the environment paths for test discovery
+
+
 ## 3.6.0

 ### Fixes
@@ -99,7 +175,7 @@
 ### Improvements
 * Reintroduced support for GCC 5 and 6 (#2836)
  * As with VS2017, if they start causing trouble again, they will be dropped again.
-* Added workaround for targetting newest MacOS (Sonoma) using GCC (#2837, #2839)
+* Added workaround for targeting newest MacOS (Sonoma) using GCC (#2837, #2839)
 * `CATCH_CONFIG_DEFAULT_REPORTER` can now be an arbitrary reporter spec
  * Previously it could only be a plain reporter name, so it was impossible to compile in custom arguments to the reporter.
 * Improved performance of generating 64bit random integers by 20+%
--- a/docs/test-cases-and-sections.md
+++ b/docs/test-cases-and-sections.md
@@ -48,7 +48,7 @@ For more detail on command line selection see [the command line docs](command-li
 Tag names are not case sensitive and can contain any ASCII characters.
 This means that tags `[tag with spaces]` and `[I said "good day"]`
 are both allowed tags and can be filtered on. However, escapes are not
-supported however and `[\]]` is not a valid tag.
+supported and `[\]]` is not a valid tag.

 The same tag can be specified multiple times for a single test case,
 but only one of the instances of identical tags will be kept. Which one
--- a/docs/test-fixtures.md
+++ b/docs/test-fixtures.md
@@ -1,9 +1,30 @@
 <a id="top"></a>
 # Test fixtures

-## Defining test fixtures
+**Contents**<br>
+[Non-Templated test fixtures](#non-templated-test-fixtures)<br>
+[Templated test fixtures](#templated-test-fixtures)<br>
+[Signature-based parameterised test fixtures](#signature-based-parametrised-test-fixtures)<br>
+[Template fixtures with types specified in template type lists](#template-fixtures-with-types-specified-in-template-type-lists)<br>

-Although Catch allows you to group tests together as [sections within a test case](test-cases-and-sections.md), it can still be convenient, sometimes, to group them using a more traditional test fixture. Catch fully supports this too. You define the test fixture as a simple structure:
+## Non-Templated test fixtures
+
+Although Catch2 allows you to group tests together as 
+[sections within a test case](test-cases-and-sections.md), it can still 
+be convenient, sometimes, to group them using a more traditional test. 
+Catch2 fully supports this too with 3 different macros for 
+non-templated test fixtures. They are: 
+
+| Macro    | Description |
+|----------|-------------|
+|1. `TEST_CASE_METHOD(className, ...)`| Creates a uniquely named class which inherits from the class specified by `className`. The test function will be a member of this derived class. An instance of the derived class will be created for every partial run of the test case. |
+|2. `METHOD_AS_TEST_CASE(member-function, ...)`| Uses `member-function` as the test function. An instance of the class will be created for each partial run of the test case. |
+|3. `TEST_CASE_PERSISTENT_FIXTURE(className, ...)`| Creates a uniquely named class which inherits from the class specified by `className`. The test function will be a member of this derived class. An instance of the derived class will be created at the start of the test run. That instance will be destroyed once the entire test case has ended. |
+
+### 1. `TEST_CASE_METHOD`
+
+
+You define a `TEST_CASE_METHOD` test fixture as a simple structure:

 ```c++
 class UniqueTestsFixture {
@@ -30,8 +51,116 @@ class UniqueTestsFixture {
 }
 ```

-The two test cases here will create uniquely-named derived classes of UniqueTestsFixture and thus can access the `getID()` protected method and `conn` member variables. This ensures that both the test cases are able to create a DBConnection using the same method (DRY principle) and that any ID's created are unique such that the order that tests are executed does not matter.
+The two test cases here will create uniquely-named derived classes of 
+UniqueTestsFixture and thus can access the `getID()` protected method 
+and `conn` member variables. This ensures that both the test cases 
+are able to create a DBConnection using the same method 
+(DRY principle) and that any ID's created are unique such that the 
+order that tests are executed does not matter. 

+### 2. `METHOD_AS_TEST_CASE`
+
+`METHOD_AS_TEST_CASE` lets you register a member function of a class 
+as a Catch2 test case. The class will be separately instantiated 
+for each method registered in this way.
+
+```cpp
+class TestClass {
+    std::string s;
+
+public:
+    TestClass()
+        :s( "hello" )
+    {}
+
+    void testCase() {
+        REQUIRE( s == "hello" );
+    }
+};
+
+
+METHOD_AS_TEST_CASE( TestClass::testCase, "Use class's method as a test case", "[class]" )
+```
+
+This type of fixture is similar to [TEST_CASE_METHOD](#1-test_case_method) except in this 
+case it will directly use the provided class to create an object rather than a derived 
+class.
+
+### 3. `TEST_CASE_PERSISTENT_FIXTURE`
+
+> [Introduced](https://github.com/catchorg/Catch2/pull/2885) in Catch2 3.7.0
+
+`TEST_CASE_PERSISTENT_FIXTURE` behaves in the same way as
+[TEST_CASE_METHOD](#1-test_case_method) except that there will only be
+one instance created throughout the entire run of a test case. To 
+demonstrate this have a look at the following example:
+
+```cpp
+class ClassWithExpensiveSetup {
+public:
+    ClassWithExpensiveSetup() {
+        // expensive construction
+        std::this_thread::sleep_for( std::chrono::seconds( 2 ) );
+    }
+
+    ~ClassWithExpensiveSetup() noexcept {
+        // expensive destruction
+        std::this_thread::sleep_for( std::chrono::seconds( 1 ) );
+    }
+
+    int getInt() const { return 42; }
+};
+
+struct MyFixture {
+    mutable int myInt = 0;
+    ClassWithExpensiveSetup expensive;
+};
+
+TEST_CASE_PERSISTENT_FIXTURE( MyFixture, "Tests with MyFixture" ) {
+
+    const int val = myInt++;
+
+    SECTION( "First partial run" ) {
+        const auto otherValue = expensive.getInt();
+        REQUIRE( val == 0 );
+        REQUIRE( otherValue == 42 );
+    }
+
+    SECTION( "Second partial run" ) { REQUIRE( val == 1 ); }
+}
+```
+
+This example demonstrates two possible use-cases of this fixture type:
+1. Improve test run times by reducing the amount of expensive and 
+redundant setup and tear-down required.
+2. Reusing results from the previous partial run, in the current
+partial run.
+
+This test case will be executed twice as there are two leaf sections.
+On the first run `val` will be `0` and on the second run `val` will be 
+`1`. This demonstrates that we were able to use the results of the
+previous partial run in subsequent partial runs.
+
+Additionally, we are simulating an expensive object using 
+`std::this_thread::sleep_for`, but real world use-cases could be:
+1. Creating a D3D12/Vulkan device
+2. Connecting to a database
+3. Loading a file.
+
+The fixture object (`MyFixture`) will be constructed just before the
+test case begins, and it will be destroyed just after the test case 
+ends. Therefore, this expensive object will only be created and 
+destroyed once during the execution of this test case. If we had used 
+`TEST_CASE_METHOD`, `MyFixture` would have been created and destroyed 
+twice during the execution of this test case.
+
+NOTE: The member function which runs the test case is `const`. Therefore 
+if you want to mutate any member of the fixture it must be marked as
+`mutable` as shown in this example. This is to make it clear that
+the initial state of the fixture is intended to mutate during the
+execution of the test case.
+
+## Templated test fixtures

 Catch2 also provides `TEMPLATE_TEST_CASE_METHOD` and
 `TEMPLATE_PRODUCT_TEST_CASE_METHOD` that can be used together
@@ -93,7 +222,7 @@ _While there is an upper limit on the number of types you can specify
 in single `TEMPLATE_TEST_CASE_METHOD` or `TEMPLATE_PRODUCT_TEST_CASE_METHOD`,
 the limit is very high and should not be encountered in practice._

-## Signature-based parametrised test fixtures
+## Signature-based parameterised test fixtures

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

--- a/docs/tostring.md
+++ b/docs/tostring.md
@@ -75,7 +75,7 @@ CATCH_TRANSLATE_EXCEPTION( MyType const& ex ) {

 Enums that already have a `<<` overload for `std::ostream` will convert to strings as expected.
 If you only need to convert enums to strings for test reporting purposes you can provide a `StringMaker` specialisations as any other type.
-However, as a convenience, Catch provides the `REGISTER_ENUM` helper macro that will generate the `StringMaker` specialisation for you with minimal code.
+However, as a convenience, Catch provides the `CATCH_REGISTER_ENUM` helper macro that will generate the `StringMaker` specialisation for you with minimal code.
 Simply provide it the (qualified) enum name, followed by all the enum values, and you're done!

 E.g.
--- a/examples/111-Fix-PersistentFixture.cpp
+++ b/examples/111-Fix-PersistentFixture.cpp
@@ -0,0 +1,74 @@
+
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+// Fixture.cpp
+
+// Catch2 has three ways to express fixtures:
+// - Sections
+// - Traditional class-based fixtures that are created and destroyed on every
+// partial run
+// - Traditional class-based fixtures that are created at the start of a test
+// case and destroyed at the end of a test case (this file)
+
+// main() provided by linkage to Catch2WithMain
+
+#include <catch2/catch_test_macros.hpp>
+
+#include <thread>
+
+class ClassWithExpensiveSetup {
+public:
+    ClassWithExpensiveSetup() {
+        // Imagine some really expensive set up here.
+        // e.g.
+        // setting up a D3D12/Vulkan Device,
+        // connecting to a database,
+        // loading a file
+        // etc etc etc
+        std::this_thread::sleep_for( std::chrono::seconds( 2 ) );
+    }
+
+    ~ClassWithExpensiveSetup() noexcept {
+        // We can do any clean up of the expensive class in the destructor
+        // e.g.
+        // destroy D3D12/Vulkan Device,
+        // disconnecting from a database,
+        // release file handle
+        // etc etc etc
+        std::this_thread::sleep_for( std::chrono::seconds( 1 ) );
+    }
+
+    int getInt() const { return 42; }
+};
+
+struct MyFixture {
+
+    // The test case member function is const.
+    // Therefore we need to mark any member of the fixture
+    // that needs to mutate as mutable.
+    mutable int myInt = 0;
+    ClassWithExpensiveSetup expensive;
+};
+
+// Only one object of type MyFixture will be instantiated for the run
+// of this test case even though there are two leaf sections.
+// This is useful if your test case requires an object that is
+// expensive to create and could be reused for each partial run of the
+// test case.
+TEST_CASE_PERSISTENT_FIXTURE( MyFixture, "Tests with MyFixture" ) {
+
+    const int val = myInt++;
+
+    SECTION( "First partial run" ) {
+        const auto otherValue = expensive.getInt();
+        REQUIRE( val == 0 );
+        REQUIRE( otherValue == 42 );
+    }
+
+    SECTION( "Second partial run" ) { REQUIRE( val == 1 ); }
+}
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -1,18 +1,16 @@
-cmake_minimum_required( VERSION 3.10 )
-
-project( Catch2Examples LANGUAGES CXX )
-
-message( STATUS "Examples included" )
+cmake_minimum_required(VERSION 3.16)
+project(Catch2Examples LANGUAGES CXX)

+message(STATUS "Examples included")

 # Some one-offs first:
 # 1) Tests and main in one file
-add_executable( 010-TestCase
+add_executable(010-TestCase
  010-TestCase.cpp
 )

 # 2) Tests and main across two files
-add_executable( 020-MultiFile
+add_executable(020-MultiFile
  020-TestCase-1.cpp
  020-TestCase-2.cpp
 )
@@ -24,10 +22,11 @@ target_link_libraries(231-Cfg_OutputStreams Catch2_buildall_interface)
 target_compile_definitions(231-Cfg_OutputStreams PUBLIC CATCH_CONFIG_NOSTDOUT)

 # These examples use the standard separate compilation
-set( SOURCES_IDIOMATIC_EXAMPLES
+set(SOURCES_IDIOMATIC_EXAMPLES
  030-Asn-Require-Check.cpp
  100-Fix-Section.cpp
  110-Fix-ClassFixture.cpp
+  111-Fix-PersistentFixture.cpp
  120-Bdd-ScenarioGivenWhenThen.cpp
  210-Evt-EventListeners.cpp
  232-Cfg-CustomMain.cpp
@@ -38,12 +37,11 @@ set( SOURCES_IDIOMATIC_EXAMPLES
  311-Gen-CustomCapture.cpp
 )

-string( REPLACE ".cpp" "" BASENAMES_IDIOMATIC_EXAMPLES "${SOURCES_IDIOMATIC_EXAMPLES}" )
-set( TARGETS_IDIOMATIC_EXAMPLES ${BASENAMES_IDIOMATIC_EXAMPLES} )
+string(REPLACE ".cpp" "" BASENAMES_IDIOMATIC_EXAMPLES "${SOURCES_IDIOMATIC_EXAMPLES}")
+set(TARGETS_IDIOMATIC_EXAMPLES ${BASENAMES_IDIOMATIC_EXAMPLES})

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

 set(ALL_EXAMPLE_TARGETS
@@ -52,10 +50,9 @@ set(ALL_EXAMPLE_TARGETS
  020-MultiFile
 )

-foreach( name ${ALL_EXAMPLE_TARGETS} )
-    target_link_libraries( ${name} Catch2WithMain )
+foreach(name ${ALL_EXAMPLE_TARGETS})
+  target_link_libraries(${name} Catch2WithMain)
 endforeach()

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

  ``catch_discover_tests`` sets up a post-build command on the test executable
@@ -124,7 +126,14 @@ same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
    test executable and when the tests are executed themselves. This requires
    cmake/ctest >= 3.22.

-  `DISCOVERY_MODE mode``
+  ``DL_FRAMEWORK_PATHS path...``
+    Specifies paths that need to be set for the dynamic linker to find libraries
+    packaged as frameworks on Apple platforms when running the test executable
+    (DYLD_FRAMEWORK_PATH). These paths will both be set when retrieving the list
+    of test cases from the test executable and when the tests are executed themselves.
+    This requires cmake/ctest >= 3.22.
+
+  ``DISCOVERY_MODE mode``
    Provides control over when ``catch_discover_tests`` performs test discovery.
    By default, ``POST_BUILD`` sets up a post-build command to perform test discovery
    at build time. In certain scenarios, like cross-compiling, this ``POST_BUILD``
@@ -137,6 +146,12 @@ same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
    calling ``catch_discover_tests``. This provides a mechanism for globally selecting
    a preferred test discovery behavior without having to modify each call site.

+  ``SKIP_IS_FAILURE``
+    Disables skipped test detection.
+
+  ``ADD_TAGS_AS_LABELS``
+    Adds all test tags as CTest labels.
+
 #]=======================================================================]

 #------------------------------------------------------------------------------
@@ -144,22 +159,27 @@ function(catch_discover_tests TARGET)

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

+  if(${CMAKE_VERSION} VERSION_LESS "3.19")
+    message(FATAL_ERROR "This script requires JSON support from CMake version 3.19 or greater.")
+  endif()
+
  if(NOT _WORKING_DIRECTORY)
    set(_WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
  endif()
  if(NOT _TEST_LIST)
    set(_TEST_LIST ${TARGET}_TESTS)
  endif()
-  if (_DL_PATHS)
-    if(${CMAKE_VERSION} VERSION_LESS "3.22.0")
+  if(_DL_PATHS AND ${CMAKE_VERSION} VERSION_LESS "3.22.0")
    message(FATAL_ERROR "The DL_PATHS option requires at least cmake 3.22")
  endif()
+  if(_DL_FRAMEWORK_PATHS AND ${CMAKE_VERSION} VERSION_LESS "3.22.0")
+    message(FATAL_ERROR "The DL_FRAMEWORK_PATHS option requires at least cmake 3.22")
  endif()
  if(NOT _DISCOVERY_MODE)
    if(NOT CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE)
@@ -167,7 +187,7 @@ function(catch_discover_tests TARGET)
    endif()
    set(_DISCOVERY_MODE ${CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE})
  endif()
-  if (NOT _DISCOVERY_MODE MATCHES "^(POST_BUILD|PRE_TEST)$")
+  if(NOT _DISCOVERY_MODE MATCHES "^(POST_BUILD|PRE_TEST)$")
    message(FATAL_ERROR "Unknown DISCOVERY_MODE: ${_DISCOVERY_MODE}")
  endif()

@@ -184,6 +204,9 @@ function(catch_discover_tests TARGET)
    TARGET ${TARGET}
    PROPERTY CROSSCOMPILING_EMULATOR
  )
+  if(NOT _SKIP_IS_FAILURE)
+    set(_PROPERTIES ${_PROPERTIES} SKIP_RETURN_CODE 4)
+  endif()

  if(_DISCOVERY_MODE STREQUAL "POST_BUILD")
    add_custom_command(
@@ -205,7 +228,9 @@ function(catch_discover_tests TARGET)
              -D "TEST_OUTPUT_PREFIX=${_OUTPUT_PREFIX}"
              -D "TEST_OUTPUT_SUFFIX=${_OUTPUT_SUFFIX}"
              -D "TEST_DL_PATHS=${_DL_PATHS}"
+              -D "TEST_DL_FRAMEWORK_PATHS=${_DL_FRAMEWORK_PATHS}"
              -D "CTEST_FILE=${ctest_tests_file}"
+              -D "ADD_TAGS_AS_LABELS=${_ADD_TAGS_AS_LABELS}"
              -P "${_CATCH_DISCOVER_TESTS_SCRIPT}"
      VERBATIM
    )
@@ -250,7 +275,8 @@ function(catch_discover_tests TARGET)
      "      TEST_OUTPUT_SUFFIX"     " [==[" "${_OUTPUT_SUFFIX}"          "]==]"   "\n"
      "      CTEST_FILE"             " [==[" "${ctest_tests_file}"        "]==]"   "\n"
      "      TEST_DL_PATHS"          " [==[" "${_DL_PATHS}"               "]==]"   "\n"
-      "      CTEST_FILE"             " [==[" "${CTEST_FILE}"              "]==]"   "\n"
+      "      TEST_DL_FRAMEWORK_PATHS" " [==[" "${_DL_FRAMEWORK_PATHS}"     "]==]"   "\n"
+      "      ADD_TAGS_AS_LABELS"     " [==[" "${_ADD_TAGS_AS_LABELS}"     "]==]"   "\n"
      "    )"                                                                      "\n"
      "  endif()"                                                                  "\n"
      "  include(\"${ctest_tests_file}\")"                                         "\n"
@@ -277,22 +303,10 @@ function(catch_discover_tests TARGET)
    endif()
  endif()

-  if(NOT ${CMAKE_VERSION} VERSION_LESS "3.10.0")
  # Add discovered tests to directory TEST_INCLUDE_FILES
  set_property(DIRECTORY
    APPEND PROPERTY TEST_INCLUDE_FILES "${ctest_include_file}"
  )
-  else()
-    # Add discovered tests as directory TEST_INCLUDE_FILE if possible
-    get_property(test_include_file_set DIRECTORY PROPERTY TEST_INCLUDE_FILE SET)
-    if (NOT ${test_include_file_set})
-      set_property(DIRECTORY
-        PROPERTY TEST_INCLUDE_FILE "${ctest_include_file}"
-      )
-    else()
-      message(FATAL_ERROR "Cannot set more than one TEST_INCLUDE_FILE")
-    endif()
-  endif()

 endfunction()

--- a/extras/CatchAddTests.cmake
+++ b/extras/CatchAddTests.cmake
@@ -22,10 +22,11 @@ function(catch_discover_tests_impl)
    ""
    ""
    "TEST_EXECUTABLE;TEST_WORKING_DIR;TEST_OUTPUT_DIR;TEST_OUTPUT_PREFIX;TEST_OUTPUT_SUFFIX;TEST_PREFIX;TEST_REPORTER;TEST_SPEC;TEST_SUFFIX;TEST_LIST;CTEST_FILE"
-    "TEST_EXTRA_ARGS;TEST_PROPERTIES;TEST_EXECUTOR;TEST_DL_PATHS"
+    "TEST_EXTRA_ARGS;TEST_PROPERTIES;TEST_EXECUTOR;TEST_DL_PATHS;TEST_DL_FRAMEWORK_PATHS;ADD_TAGS_AS_LABELS"
    ${ARGN}
  )

+  set(add_tags "${_ADD_TAGS_AS_LABELS}")
  set(prefix "${_TEST_PREFIX}")
  set(suffix "${_TEST_SUFFIX}")
  set(spec ${_TEST_SPEC})
@@ -36,6 +37,8 @@ function(catch_discover_tests_impl)
  set(output_prefix ${_TEST_OUTPUT_PREFIX})
  set(output_suffix ${_TEST_OUTPUT_SUFFIX})
  set(dl_paths ${_TEST_DL_PATHS})
+  set(dl_framework_paths ${_TEST_DL_FRAMEWORK_PATHS})
+  set(environment_modifications "")
  set(script)
  set(suite)
  set(tests)
@@ -56,30 +59,33 @@ function(catch_discover_tests_impl)
  endif()

  if(dl_paths)
-    cmake_path(CONVERT "${dl_paths}" TO_NATIVE_PATH_LIST paths)
+    cmake_path(CONVERT "$ENV{${dl_paths_variable_name}}" TO_NATIVE_PATH_LIST env_dl_paths)
+    list(PREPEND env_dl_paths "${dl_paths}")
+    cmake_path(CONVERT "${env_dl_paths}" TO_NATIVE_PATH_LIST paths)
    set(ENV{${dl_paths_variable_name}} "${paths}")
  endif()

+  if(APPLE AND dl_framework_paths)
+    cmake_path(CONVERT "$ENV{DYLD_FRAMEWORK_PATH}" TO_NATIVE_PATH_LIST env_dl_framework_paths)
+    list(PREPEND env_dl_framework_paths "${dl_framework_paths}")
+    cmake_path(CONVERT "${env_dl_framework_paths}" TO_NATIVE_PATH_LIST paths)
+    set(ENV{DYLD_FRAMEWORK_PATH} "${paths}")
+  endif()
+
  execute_process(
-    COMMAND ${_TEST_EXECUTOR} "${_TEST_EXECUTABLE}" ${spec} --list-tests --verbosity quiet
-    OUTPUT_VARIABLE output
+    COMMAND ${_TEST_EXECUTOR} "${_TEST_EXECUTABLE}" ${spec} --list-tests --reporter json
+    OUTPUT_VARIABLE listing_output
    RESULT_VARIABLE result
    WORKING_DIRECTORY "${_TEST_WORKING_DIR}"
  )
  if(NOT ${result} EQUAL 0)
    message(FATAL_ERROR
-      "Error running test executable '${_TEST_EXECUTABLE}':\n"
+      "Error listing tests from executable '${_TEST_EXECUTABLE}':\n"
      "  Result: ${result}\n"
-      "  Output: ${output}\n"
+      "  Output: ${listing_output}\n"
    )
  endif()

-  # Make sure to escape ; (semicolons) in test names first, because
-  # that'd break the foreach loop for "Parse output" later and create
-  # wrongly splitted and thus failing test cases (false positives)
-  string(REPLACE ";" "\;" output "${output}")
-  string(REPLACE "\n" ";" output "${output}")
-
  # Prepare reporter
  if(reporter)
    set(reporter_arg "--reporter ${reporter}")
@@ -99,7 +105,7 @@ function(catch_discover_tests_impl)
      )
    elseif(NOT ${reporter_check_result} EQUAL 0)
      message(FATAL_ERROR
-        "Error running test executable '${_TEST_EXECUTABLE}':\n"
+        "Error checking for reporter in test executable '${_TEST_EXECUTABLE}':\n"
        "  Result: ${reporter_check_result}\n"
        "  Output: ${reporter_check_output}\n"
      )
@@ -117,50 +123,103 @@ function(catch_discover_tests_impl)
  if(dl_paths)
    foreach(path ${dl_paths})
      cmake_path(NATIVE_PATH path native_path)
-      list(APPEND environment_modifications "${dl_paths_variable_name}=path_list_prepend:${native_path}")
+      list(PREPEND environment_modifications "${dl_paths_variable_name}=path_list_prepend:${native_path}")
    endforeach()
  endif()

-  # Parse output
-  foreach(line ${output})
-    set(test "${line}")
+  if(APPLE AND dl_framework_paths)
+    foreach(path ${dl_framework_paths})
+      cmake_path(NATIVE_PATH path native_path)
+      list(PREPEND environment_modifications "DYLD_FRAMEWORK_PATH=path_list_prepend:${native_path}")
+    endforeach()
+  endif()
+
+  # Parse JSON output for list of tests/class names/tags
+  string(JSON version GET "${listing_output}" "version")
+  if(NOT version STREQUAL "1")
+    message(FATAL_ERROR "Unsupported catch output version: '${version}'")
+  endif()
+
+  # Speed-up reparsing by cutting away unneeded parts of JSON.
+  string(JSON test_listing GET "${listing_output}" "listings" "tests")
+  string(JSON num_tests LENGTH "${test_listing}")
+
+  # Exit early if no tests are detected
+  if(num_tests STREQUAL "0")
+    return()
+  endif()
+
+  # CMake's foreach-RANGE is inclusive, so we have to subtract 1
+  math(EXPR num_tests "${num_tests} - 1")
+
+  foreach(idx RANGE ${num_tests})
+    string(JSON single_test GET ${test_listing} ${idx})
+    string(JSON test_tags GET "${single_test}" "tags")
+    string(JSON plain_name GET "${single_test}" "name")
+
    # Escape characters in test case names that would be parsed by Catch2
    # Note that the \ escaping must happen FIRST! Do not change the order.
-    set(test_name "${test}")
-    foreach(char \\ , [ ])
-      string(REPLACE ${char} "\\${char}" test_name "${test_name}")
+    set(escaped_name "${plain_name}")
+    foreach(char \\ , [ ] ;)
+      string(REPLACE ${char} "\\${char}" escaped_name "${escaped_name}")
    endforeach(char)
    # ...add output dir
    if(output_dir)
-      string(REGEX REPLACE "[^A-Za-z0-9_]" "_" test_name_clean "${test_name}")
-      set(output_dir_arg "--out ${output_dir}/${output_prefix}${test_name_clean}${output_suffix}")
+      string(REGEX REPLACE "[^A-Za-z0-9_]" "_" escaped_name_clean "${escaped_name}")
+      set(output_dir_arg "--out ${output_dir}/${output_prefix}${escaped_name_clean}${output_suffix}")
    endif()

    # ...and add to script
    add_command(add_test
-      "${prefix}${test}${suffix}"
+      "${prefix}${plain_name}${suffix}"
      ${_TEST_EXECUTOR}
      "${_TEST_EXECUTABLE}"
-      "${test_name}"
+      "${escaped_name}"
      ${extra_args}
      "${reporter_arg}"
      "${output_dir_arg}"
    )
    add_command(set_tests_properties
-      "${prefix}${test}${suffix}"
+      "${prefix}${plain_name}${suffix}"
      PROPERTIES
      WORKING_DIRECTORY "${_TEST_WORKING_DIR}"
      ${properties}
    )

+    if(add_tags)
+      string(JSON num_tags LENGTH "${test_tags}")
+      math(EXPR num_tags "${num_tags} - 1")
+      set(tag_list "")
+      if(num_tags GREATER_EQUAL "0")
+        foreach(tag_idx RANGE ${num_tags})
+          string(JSON a_tag GET "${test_tags}" "${tag_idx}")
+          # Catch2's tags can contain semicolons, which are list element separators
+          # in CMake, so we have to escape them. Ideally we could use the [=[...]=]
+          # syntax for this, but CTest currently keeps the square quotes in the label
+          # name. So we add 2 backslashes to escape it instead.
+          # **IMPORTANT**: The number of backslashes depends on how many layers
+          #                of CMake the tag goes. If this script is changed, the
+          #                number of backslashes to escape may change as well.
+          string(REPLACE ";" "\\;" a_tag "${a_tag}")
+          list(APPEND tag_list "${a_tag}")
+        endforeach()
+
+        add_command(set_tests_properties
+          "${prefix}${plain_name}${suffix}"
+          PROPERTIES
+          LABELS "${tag_list}"
+        )
+      endif()
+    endif(add_tags)
+
    if(environment_modifications)
      add_command(set_tests_properties
-        "${prefix}${test}${suffix}"
+        "${prefix}${plain_name}${suffix}"
        PROPERTIES
        ENVIRONMENT_MODIFICATION "${environment_modifications}")
    endif()

-    list(APPEND tests "${prefix}${test}${suffix}")
+    list(APPEND tests "${prefix}${plain_name}${suffix}")
  endforeach()

  # Create a list of all discovered tests, which users may use to e.g. set
@@ -187,6 +246,8 @@ if(CMAKE_SCRIPT_MODE_FILE)
    TEST_OUTPUT_PREFIX ${TEST_OUTPUT_PREFIX}
    TEST_OUTPUT_SUFFIX ${TEST_OUTPUT_SUFFIX}
    TEST_DL_PATHS ${TEST_DL_PATHS}
+    TEST_DL_FRAMEWORK_PATHS ${TEST_DL_FRAMEWORK_PATHS}
    CTEST_FILE ${CTEST_FILE}
+    ADD_TAGS_AS_LABELS ${ADD_TAGS_AS_LABELS}
  )
 endif()
--- a/extras/CatchShardTests.cmake
+++ b/extras/CatchShardTests.cmake
@@ -11,7 +11,7 @@
 #  * REPORTER    - reporter spec to use for tests
 #  * TEST_SPEC   - test spec used for filtering tests
 function(catch_add_sharded_tests TARGET)
-  if (${CMAKE_VERSION} VERSION_LESS "3.10.0")
+  if(${CMAKE_VERSION} VERSION_LESS "3.10.0")
    message(FATAL_ERROR "add_sharded_catch_tests only supports CMake versions 3.10.0 and up")
  endif()

@@ -23,7 +23,7 @@ function(catch_add_sharded_tests TARGET)
    ${ARGN}
  )
  
-  if (NOT DEFINED _SHARD_COUNT)
+  if(NOT DEFINED _SHARD_COUNT)
    set(_SHARD_COUNT 2)
  endif()

@@ -61,8 +61,6 @@ function(catch_add_sharded_tests TARGET)
            -P "${shard_impl_script_file}"
    VERBATIM
  )
-
-
 endfunction()


--- a/extras/CatchShardTestsImpl.cmake
+++ b/extras/CatchShardTestsImpl.cmake
@@ -25,10 +25,10 @@ if(NOT EXISTS "${TEST_BINARY}")
 endif()

 set(other_args "")
-if (TEST_SPEC)
+if(TEST_SPEC)
  set(other_args "${other_args} ${TEST_SPEC}")
 endif()
-if (REPORTER_SPEC)
+if(REPORTER_SPEC)
  set(other_args "${other_args} --reporter ${REPORTER_SPEC}")
 endif()

--- a/extras/ParseAndAddCatchTests.cmake
+++ b/extras/ParseAndAddCatchTests.cmake
@@ -56,7 +56,7 @@
 #                                                                                                  #
 #==================================================================================================#

-if (CMAKE_MINIMUM_REQUIRED_VERSION VERSION_LESS 2.8.8)
+if(CMAKE_MINIMUM_REQUIRED_VERSION VERSION_LESS 2.8.8)
  message(FATAL_ERROR "ParseAndAddCatchTests requires CMake 2.8.8 or newer")
 endif()

@@ -155,7 +155,7 @@ function(ParseAndAddCatchTests_ParseFile SourceFile TestTarget)
    if("${TestType}" STREQUAL "SCENARIO")
      set(Name "Scenario: ${Name}")
    endif()
-        if(PARSE_CATCH_TESTS_ADD_FIXTURE_IN_TEST_NAME AND "${TestType}" MATCHES "(CATCH_)?TEST_CASE_METHOD" AND TestFixture )
+    if(PARSE_CATCH_TESTS_ADD_FIXTURE_IN_TEST_NAME AND "${TestType}" MATCHES "(CATCH_)?TEST_CASE_METHOD" AND TestFixture)
      set(CTestName "${TestFixture}:${Name}")
    else()
      set(CTestName "${Name}")
@@ -234,8 +234,6 @@ function(ParseAndAddCatchTests_ParseFile SourceFile TestTarget)
        APPEND
        PROPERTY ParseAndAddCatchTests_TESTS "${CTestName}")
    endif()
-
-
  endforeach()
 endfunction()

--- a/extras/catch_amalgamated.cpp
+++ b/extras/catch_amalgamated.cpp
--- a/extras/catch_amalgamated.hpp
+++ b/extras/catch_amalgamated.hpp
--- a/fuzzing/CMakeLists.txt
+++ b/fuzzing/CMakeLists.txt
@@ -15,6 +15,6 @@ target_compile_features(fuzzhelper PUBLIC cxx_std_17)
 target_link_options(fuzzhelper PUBLIC "-fsanitize=fuzzer")

 foreach(fuzzer TestSpecParser XmlWriter textflow)
-add_executable(fuzz_${fuzzer} fuzz_${fuzzer}.cpp)
-target_link_libraries(fuzz_${fuzzer} PRIVATE fuzzhelper)
+  add_executable(fuzz_${fuzzer} fuzz_${fuzzer}.cpp)
+  target_link_libraries(fuzz_${fuzzer} PRIVATE fuzzhelper)
 endforeach()
--- a/meson.build
+++ b/meson.build
@@ -8,7 +8,7 @@
 project(
  'catch2',
  'cpp',
-  version: '3.6.0', # CML version placeholder, don't delete
+  version: '3.8.1', # CML version placeholder, don't delete
  license: 'BSL-1.0',
  meson_version: '>=0.54.1',
 )
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -1 +1,2 @@
 option('tests', type: 'boolean', value: true, description: 'Build the unit tests')
+option('install', type: 'boolean', value: true, description: 'Install the library')
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -40,7 +40,6 @@ set(BENCHMARK_SOURCES
 )
 set(BENCHMARK_FILES ${BENCHMARK_HEADERS} ${BENCHMARK_SOURCES})

-
 set(IMPL_HEADERS
 "${PROJECT_BINARY_DIR}/generated-includes/catch2/catch_user_config.hpp"
  ${SOURCES_DIR}/catch_user_config.hpp.in
@@ -48,6 +47,7 @@ set(IMPL_HEADERS
  ${SOURCES_DIR}/catch_approx.hpp
  ${SOURCES_DIR}/catch_assertion_info.hpp
  ${SOURCES_DIR}/catch_assertion_result.hpp
+  ${SOURCES_DIR}/catch_case_sensitive.hpp
  ${SOURCES_DIR}/catch_config.hpp
  ${SOURCES_DIR}/catch_get_random_seed.hpp
  ${SOURCES_DIR}/catch_message.hpp
@@ -67,13 +67,13 @@ set(IMPL_HEADERS
  ${SOURCES_DIR}/catch_version_macros.hpp
  ${SOURCES_DIR}/internal/catch_assertion_handler.hpp
  ${SOURCES_DIR}/internal/catch_case_insensitive_comparisons.hpp
-  ${SOURCES_DIR}/internal/catch_case_sensitive.hpp
  ${SOURCES_DIR}/internal/catch_clara.hpp
  ${SOURCES_DIR}/internal/catch_commandline.hpp
  ${SOURCES_DIR}/internal/catch_compare_traits.hpp
  ${SOURCES_DIR}/internal/catch_compiler_capabilities.hpp
  ${SOURCES_DIR}/internal/catch_config_android_logwrite.hpp
  ${SOURCES_DIR}/internal/catch_config_counter.hpp
+  ${SOURCES_DIR}/internal/catch_config_prefix_messages.hpp
  ${SOURCES_DIR}/internal/catch_config_static_analysis_support.hpp
  ${SOURCES_DIR}/internal/catch_config_uncaught_exceptions.hpp
  ${SOURCES_DIR}/internal/catch_config_wchar.hpp
@@ -194,7 +194,6 @@ set(IMPL_SOURCES
  ${SOURCES_DIR}/internal/catch_random_seed_generation.cpp
  ${SOURCES_DIR}/internal/catch_reporter_registry.cpp
  ${SOURCES_DIR}/internal/catch_reporter_spec_parser.cpp
-  ${SOURCES_DIR}/internal/catch_result_type.cpp
  ${SOURCES_DIR}/internal/catch_reusable_string_stream.cpp
  ${SOURCES_DIR}/internal/catch_run_context.cpp
  ${SOURCES_DIR}/internal/catch_section.cpp
@@ -348,25 +347,23 @@ source_group("generated headers"
 )

 add_library(Catch2 ${ALL_FILES})
-if (CATCH_ENABLE_REPRODUCIBLE_BUILD)
+if(CATCH_ENABLE_REPRODUCIBLE_BUILD)
  add_build_reproducibility_settings(Catch2)
 endif()
 add_library(Catch2::Catch2 ALIAS Catch2)

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

 set_target_properties(Catch2 PROPERTIES
  DEBUG_POSTFIX "d"
  VERSION ${PROJECT_VERSION}
-                              SOVERSION ${PROJECT_VERSION})
+  SOVERSION ${PROJECT_VERSION}
+)

 # require C++14
-target_compile_features(Catch2
-  PUBLIC
-    cxx_std_14
-)
+target_compile_features(Catch2 PUBLIC cxx_std_14)

 configure_file(
  "${SOURCES_DIR}/catch_user_config.hpp.in"
@@ -384,7 +381,7 @@ target_include_directories(Catch2
 add_library(Catch2WithMain
  ${SOURCES_DIR}/internal/catch_main.cpp
 )
-if (CATCH_ENABLE_REPRODUCIBLE_BUILD)
+if(CATCH_ENABLE_REPRODUCIBLE_BUILD)
  add_build_reproducibility_settings(Catch2WithMain)
 endif()
 add_library(Catch2::Catch2WithMain ALIAS Catch2WithMain)
@@ -397,7 +394,7 @@ set_target_properties(Catch2WithMain
 )
 set_target_properties(Catch2WithMain PROPERTIES DEBUG_POSTFIX "d")

-if (NOT_SUBPROJECT)
+if(NOT_SUBPROJECT)
  # create and install an export set for catch target as Catch2::Catch
  install(
    TARGETS
@@ -413,7 +410,6 @@ if (NOT_SUBPROJECT)
      ${CMAKE_INSTALL_BINDIR}
  )

-
  install(
    EXPORT
      Catch2Targets
@@ -437,7 +433,7 @@ endif()
 # Some tests require a full recompilation of Catch2 lib with different
 # compilation flags. They can link against this target to recompile all
 # the sources into the binary.
-if (CATCH_BUILD_EXAMPLES OR CATCH_BUILD_EXTRA_TESTS)
+if(CATCH_BUILD_EXAMPLES OR CATCH_BUILD_EXTRA_TESTS)
  add_library(Catch2_buildall_interface INTERFACE)
  target_sources(Catch2_buildall_interface INTERFACE
    ${ALL_FILES}
@@ -450,31 +446,24 @@ if (CATCH_BUILD_EXAMPLES OR CATCH_BUILD_EXTRA_TESTS)
      $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/generated-includes>
      $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
  )
-    target_compile_definitions(Catch2_buildall_interface
-      INTERFACE
-        CATCH_CONFIG_STATIC
-    )
-    target_compile_features(Catch2_buildall_interface
-      INTERFACE
-        cxx_std_14
-    )
+  target_compile_definitions(Catch2_buildall_interface INTERFACE CATCH_CONFIG_STATIC)
+  target_compile_features(Catch2_buildall_interface INTERFACE cxx_std_14)
 endif()

 list(APPEND CATCH_WARNING_TARGETS Catch2 Catch2WithMain)
 set(CATCH_WARNING_TARGETS ${CATCH_WARNING_TARGETS} PARENT_SCOPE)

-
 # We still do not support building dynamic library with hidden visibility
 # 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(BUILD_SHARED_LIBS)
  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")
+  if(NOT MSVC AND _VisPreset STREQUAL "hidden")
    set_target_properties(Catch2 Catch2WithMain
      PROPERTIES
        CXX_VISIBILITY_PRESET "default"
--- a/src/catch2/benchmark/catch_benchmark.hpp
+++ b/src/catch2/benchmark/catch_benchmark.hpp
@@ -45,12 +45,12 @@ namespace Catch {
                : fun(CATCH_MOVE(func)), name(CATCH_MOVE(benchmarkName)) {}

            template <typename Clock>
-            ExecutionPlan prepare(const IConfig &cfg, Environment env) const {
+            ExecutionPlan prepare(const IConfig &cfg, Environment env) {
                auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
                auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<IDuration>(run_time), 1, fun);
                int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
-                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FDuration>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
+                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), CATCH_MOVE(fun), std::chrono::duration_cast<FDuration>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
            }

            template <typename Clock = default_clock>
@@ -97,7 +97,7 @@ namespace Catch {
            }

            // sets lambda to be used in fun *and* executes benchmark!
-            template <typename Fun, std::enable_if_t<!Detail::is_related<Fun, Benchmark>::value, int> = 0>
+            template <typename Fun, std::enable_if_t<!Detail::is_related_v<Fun, Benchmark>, int> = 0>
                Benchmark & operator=(Fun func) {
                auto const* cfg = getCurrentContext().getConfig();
                if (!cfg->skipBenchmarks()) {
--- a/src/catch2/benchmark/catch_outlier_classification.hpp
+++ b/src/catch2/benchmark/catch_outlier_classification.hpp
@@ -19,7 +19,7 @@ namespace Catch {
            int high_mild = 0;      // 1.5 to 3 times IQR above Q3
            int high_severe = 0;    // more than 3 times IQR above Q3

-            int total() const {
+            constexpr int total() const {
                return low_severe + low_mild + high_mild + high_severe;
            }
        };
--- a/src/catch2/benchmark/detail/catch_benchmark_function.cpp
+++ b/src/catch2/benchmark/detail/catch_benchmark_function.cpp
@@ -11,7 +11,13 @@
 namespace Catch {
    namespace Benchmark {
        namespace Detail {
+            struct do_nothing {
+                void operator()() const {}
+            };
+
            BenchmarkFunction::callable::~callable() = default;
+            BenchmarkFunction::BenchmarkFunction():
+                f( new model<do_nothing>{ {} } ){}
        } // namespace Detail
    } // namespace Benchmark
 } // namespace Catch
--- a/src/catch2/benchmark/detail/catch_benchmark_function.hpp
+++ b/src/catch2/benchmark/detail/catch_benchmark_function.hpp
@@ -21,8 +21,7 @@ namespace Catch {
    namespace Benchmark {
        namespace Detail {
            template <typename T, typename U>
-            struct is_related
-                : std::is_same<std::decay_t<T>, std::decay_t<U>> {};
+            static constexpr bool is_related_v = std::is_same<std::decay_t<T>, std::decay_t<U>>::value;

            /// We need to reinvent std::function because every piece of code that might add overhead
            /// in a measurement context needs to have consistent performance characteristics so that we
@@ -35,22 +34,17 @@ namespace Catch {
            private:
                struct callable {
                    virtual void call(Chronometer meter) const = 0;
-                    virtual Catch::Detail::unique_ptr<callable> clone() const = 0;
                    virtual ~callable(); // = default;

                    callable() = default;
-                    callable(callable const&) = default;
-                    callable& operator=(callable const&) = default;
+                    callable(callable&&) = default;
+                    callable& operator=(callable&&) = default;
                };
                template <typename Fun>
                struct model : public callable {
                    model(Fun&& fun_) : fun(CATCH_MOVE(fun_)) {}
                    model(Fun const& fun_) : fun(fun_) {}

-                    Catch::Detail::unique_ptr<callable> clone() const override {
-                        return Catch::Detail::make_unique<model<Fun>>( *this );
-                    }
-
                    void call(Chronometer meter) const override {
                        call(meter, is_callable<Fun(Chronometer)>());
                    }
@@ -64,37 +58,23 @@ namespace Catch {
                    Fun fun;
                };

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

                template <typename Fun,
-                    std::enable_if_t<!is_related<Fun, BenchmarkFunction>::value, int> = 0>
+                    std::enable_if_t<!is_related_v<Fun, BenchmarkFunction>, int> = 0>
                    BenchmarkFunction(Fun&& fun)
                    : f(new model<std::decay_t<Fun>>(CATCH_FORWARD(fun))) {}

                BenchmarkFunction( BenchmarkFunction&& that ) noexcept:
                    f( CATCH_MOVE( that.f ) ) {}

-                BenchmarkFunction(BenchmarkFunction const& that)
-                    : f(that.f->clone()) {}
-
                BenchmarkFunction&
                operator=( BenchmarkFunction&& that ) noexcept {
                    f = CATCH_MOVE( that.f );
                    return *this;
                }

-                BenchmarkFunction& operator=(BenchmarkFunction const& that) {
-                    f = that.f->clone();
-                    return *this;
-                }
-
                void operator()(Chronometer meter) const { f->call(meter); }

            private:
--- a/src/catch2/benchmark/detail/catch_estimate_clock.hpp
+++ b/src/catch2/benchmark/detail/catch_estimate_clock.hpp
@@ -15,7 +15,6 @@
 #include <catch2/benchmark/detail/catch_stats.hpp>
 #include <catch2/benchmark/detail/catch_measure.hpp>
 #include <catch2/benchmark/detail/catch_run_for_at_least.hpp>
-#include <catch2/benchmark/catch_clock.hpp>
 #include <catch2/internal/catch_unique_ptr.hpp>

 #include <algorithm>
@@ -27,15 +26,17 @@ namespace Catch {
        namespace Detail {
            template <typename Clock>
            std::vector<double> resolution(int k) {
-                std::vector<TimePoint<Clock>> times;
-                times.reserve(static_cast<size_t>(k + 1));
-                for ( int i = 0; i < k + 1; ++i ) {
-                    times.push_back( Clock::now() );
+                const size_t points = static_cast<size_t>( k + 1 );
+                // To avoid overhead from the branch inside vector::push_back,
+                // we allocate them all and then overwrite.
+                std::vector<TimePoint<Clock>> times(points);
+                for ( auto& time : times ) {
+                    time = Clock::now();
                }

                std::vector<double> deltas;
                deltas.reserve(static_cast<size_t>(k));
-                for ( size_t idx = 1; idx < times.size(); ++idx ) {
+                for ( size_t idx = 1; idx < points; ++idx ) {
                    deltas.push_back( static_cast<double>(
                        ( times[idx] - times[idx - 1] ).count() ) );
                }
--- a/src/catch2/benchmark/detail/catch_measure.hpp
+++ b/src/catch2/benchmark/detail/catch_measure.hpp
@@ -20,7 +20,7 @@ namespace Catch {
            template <typename Clock, typename Fun, typename... Args>
            TimingOf<Fun, Args...> measure(Fun&& fun, Args&&... args) {
                auto start = Clock::now();
-                auto&& r = Detail::complete_invoke(fun, CATCH_FORWARD(args)...);
+                auto&& r = Detail::complete_invoke(CATCH_FORWARD(fun), CATCH_FORWARD(args)...);
                auto end = Clock::now();
                auto delta = end - start;
                return { delta, CATCH_FORWARD(r), 1 };
--- a/src/catch2/benchmark/detail/catch_stats.cpp
+++ b/src/catch2/benchmark/detail/catch_stats.cpp
@@ -178,7 +178,7 @@ namespace Catch {
                                             double diff = b - m;
                                             return a + diff * diff;
                                         } ) /
-                        ( last - first );
+                        static_cast<double>( last - first );
                    return std::sqrt( variance );
                }

@@ -213,7 +213,7 @@ namespace Catch {
                                              double* first,
                                              double* last ) {
                auto count = last - first;
-                double idx = (count - 1) * k / static_cast<double>(q);
+                double idx = static_cast<double>((count - 1) * k) / static_cast<double>(q);
                int j = static_cast<int>(idx);
                double g = idx - j;
                std::nth_element(first, first + j, last);
@@ -316,10 +316,10 @@ namespace Catch {

                double accel = sum_cubes / ( 6 * std::pow( sum_squares, 1.5 ) );
                long n = static_cast<long>( resample.size() );
-                double prob_n =
+                double prob_n = static_cast<double>(
                    std::count_if( resample.begin(),
                                   resample.end(),
-                                   [point]( double x ) { return x < point; } ) /
+                                   [point]( double x ) { return x < point; } )) /
                    static_cast<double>( n );
                // degenerate case with uniform samples
                if ( Catch::Detail::directCompare( prob_n, 0. ) ) {
--- a/src/catch2/benchmark/detail/catch_timing.hpp
+++ b/src/catch2/benchmark/detail/catch_timing.hpp
@@ -13,8 +13,6 @@
 #include <catch2/benchmark/catch_clock.hpp>
 #include <catch2/benchmark/detail/catch_complete_invoke.hpp>

-#include <type_traits>
-
 namespace Catch {
    namespace Benchmark {
        template <typename Result>
--- a/src/catch2/catch_all.hpp
+++ b/src/catch2/catch_all.hpp
@@ -26,6 +26,7 @@
 #include <catch2/catch_approx.hpp>
 #include <catch2/catch_assertion_info.hpp>
 #include <catch2/catch_assertion_result.hpp>
+#include <catch2/catch_case_sensitive.hpp>
 #include <catch2/catch_config.hpp>
 #include <catch2/catch_get_random_seed.hpp>
 #include <catch2/catch_message.hpp>
@@ -47,7 +48,6 @@
 #include <catch2/interfaces/catch_interfaces_all.hpp>
 #include <catch2/internal/catch_assertion_handler.hpp>
 #include <catch2/internal/catch_case_insensitive_comparisons.hpp>
-#include <catch2/internal/catch_case_sensitive.hpp>
 #include <catch2/internal/catch_clara.hpp>
 #include <catch2/internal/catch_commandline.hpp>
 #include <catch2/internal/catch_compare_traits.hpp>
--- a/src/catch2/catch_approx.cpp
+++ b/src/catch2/catch_approx.cpp
@@ -10,14 +10,73 @@
 #include <catch2/internal/catch_reusable_string_stream.hpp>

 #include <cmath>
+#include <limits>
+
+namespace {
+
+// Performs equivalent check of std::fabs(lhs - rhs) <= margin
+// But without the subtraction to allow for INFINITY in comparison
+bool marginComparison(double lhs, double rhs, double margin) {
+    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
+}
+
+}

 namespace Catch {

-std::string Approx::toString() const {
+    Approx::Approx ( double value )
+    :   m_epsilon( static_cast<double>(std::numeric_limits<float>::epsilon())*100. ),
+        m_margin( 0.0 ),
+        m_scale( 0.0 ),
+        m_value( value )
+    {}
+
+    Approx Approx::custom() {
+        return Approx( 0 );
+    }
+
+    Approx Approx::operator-() const {
+        auto temp(*this);
+        temp.m_value = -temp.m_value;
+        return temp;
+    }
+
+
+    std::string Approx::toString() const {
        ReusableStringStream rss;
        rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
        return rss.str();
-}
+    }
+
+    bool Approx::equalityComparisonImpl(const double other) const {
+        // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
+        // Thanks to Richard Harris for his help refining the scaled margin value
+        return marginComparison(m_value, other, m_margin)
+            || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
+    }
+
+    void Approx::setMargin(double newMargin) {
+        CATCH_ENFORCE(newMargin >= 0,
+            "Invalid Approx::margin: " << newMargin << '.'
+            << " Approx::Margin has to be non-negative.");
+        m_margin = newMargin;
+    }
+
+    void Approx::setEpsilon(double newEpsilon) {
+        CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
+            "Invalid Approx::epsilon: " << newEpsilon << '.'
+            << " Approx::epsilon has to be in [0, 1]");
+        m_epsilon = newEpsilon;
+    }
+
+namespace literals {
+    Approx operator ""_a(long double val) {
+        return Approx(val);
+    }
+    Approx operator ""_a(unsigned long long val) {
+        return Approx(val);
+    }
+} // end namespace literals

 std::string StringMaker<Catch::Approx>::convert(Catch::Approx const& value) {
    return value.toString();
--- a/src/catch2/catch_approx.hpp
+++ b/src/catch2/catch_approx.hpp
@@ -11,67 +11,26 @@
 #include <catch2/catch_tostring.hpp>

 #include <type_traits>
-#include <limits>

 namespace Catch {

    class Approx {
    private:
-        // Performs equivalent check of std::fabs(lhs - rhs) <= margin
-        // But without the subtraction to allow for INFINITY in comparison
-        constexpr bool marginComparison (double lhs, double rhs, double margin) const {
-            return (lhs + margin >= rhs) && (rhs + margin >= lhs);
-        }
-
-        constexpr double fabs(double value) const {
-            return (value < 0.0) ? -value : value;
-        }
-
-        constexpr bool isinf(double value) const {
-            return value == std::numeric_limits<double>::infinity() || value == -std::numeric_limits<double>::infinity();
-        }
-
-        constexpr bool equalityComparisonImpl(double other) const {
-            // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
-            // Thanks to Richard Harris for his help refining the scaled margin value
-            return marginComparison(m_value, other, m_margin)
-                || marginComparison(m_value, other, m_epsilon * (m_scale + fabs(isinf(m_value)? 0 : m_value)));
-        }
-
-        // Sets and validates the new epsilon (0 < epsilon < 1)
-        constexpr void setEpsilon(double epsilon) {
-            if(epsilon < 0)
-                throw std::domain_error("Invalid Approx::epsilon. Approx::epsilon has to be in [0, 1]");
-            m_epsilon = epsilon;
-        }
-
+        bool equalityComparisonImpl(double other) const;
        // Sets and validates the new margin (margin >= 0)
-        constexpr void setMargin(double margin) {
-            if(margin < 0)
-                throw std::domain_error("Invalid Approx::margin. Approx::Margin has to be non-negative.");
-            m_margin = margin;
-        }
+        void setMargin(double margin);
+        // Sets and validates the new epsilon (0 < epsilon < 1)
+        void setEpsilon(double epsilon);

    public:
-        constexpr inline explicit Approx ( double value )
-        :   m_epsilon( static_cast<double>(std::numeric_limits<float>::epsilon())*100. ),
-            m_margin( 0.0 ),
-            m_scale( 0.0 ),
-            m_value( value )
-        {}
+        explicit Approx ( double value );

-        static constexpr Approx custom() {
-            return Approx( 0.0 );
-        }
+        static Approx custom();

-        constexpr Approx operator-() const {
-            auto temp(*this);
-            temp.m_value = -temp.m_value;
-            return temp;
-        }
+        Approx operator-() const;

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        constexpr Approx operator()( T const& value ) const {
+        Approx operator()( T const& value ) const {
            Approx approx( static_cast<double>(value) );
            approx.m_epsilon = m_epsilon;
            approx.m_margin = m_margin;
@@ -80,67 +39,67 @@ namespace Catch {
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        constexpr inline explicit Approx( T const& value ): Approx(static_cast<double>(value))
+        explicit Approx( T const& value ): Approx(static_cast<double>(value))
        {}


        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        friend constexpr bool operator == ( const T& lhs, Approx const& rhs ) {
+        friend bool operator == ( const T& lhs, Approx const& rhs ) {
            auto lhs_v = static_cast<double>(lhs);
            return rhs.equalityComparisonImpl(lhs_v);
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        friend constexpr bool operator == ( Approx const& lhs, const T& rhs ) {
+        friend bool operator == ( Approx const& lhs, const T& rhs ) {
            return operator==( rhs, lhs );
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        friend constexpr bool operator != ( T const& lhs, Approx const& rhs ) {
+        friend bool operator != ( T const& lhs, Approx const& rhs ) {
            return !operator==( lhs, rhs );
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        friend constexpr bool operator != ( Approx const& lhs, T const& rhs ) {
+        friend bool operator != ( Approx const& lhs, T const& rhs ) {
            return !operator==( rhs, lhs );
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        friend constexpr bool operator <= ( T const& lhs, Approx const& rhs ) {
+        friend bool operator <= ( T const& lhs, Approx const& rhs ) {
            return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        friend constexpr bool operator <= ( Approx const& lhs, T const& rhs ) {
+        friend bool operator <= ( Approx const& lhs, T const& rhs ) {
            return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        friend constexpr bool operator >= ( T const& lhs, Approx const& rhs ) {
+        friend bool operator >= ( T const& lhs, Approx const& rhs ) {
            return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        friend constexpr bool operator >= ( Approx const& lhs, T const& rhs ) {
+        friend bool operator >= ( Approx const& lhs, T const& rhs ) {
            return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        constexpr Approx& epsilon( T const& newEpsilon ) {
+        Approx& epsilon( T const& newEpsilon ) {
            const auto epsilonAsDouble = static_cast<double>(newEpsilon);
            setEpsilon(epsilonAsDouble);
            return *this;
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        constexpr Approx& margin( T const& newMargin ) {
+        Approx& margin( T const& newMargin ) {
            const auto marginAsDouble = static_cast<double>(newMargin);
            setMargin(marginAsDouble);
            return *this;
        }

        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
-        constexpr Approx& scale( T const& newScale ) {
+        Approx& scale( T const& newScale ) {
            m_scale = static_cast<double>(newScale);
            return *this;
        }
@@ -155,12 +114,8 @@ namespace Catch {
    };

 namespace literals {
-    constexpr Approx operator ""_a(long double val) {
-        return Approx(val);
-    }
-    constexpr Approx operator ""_a(unsigned long long val) {
-        return Approx(val);
-    }
+    Approx operator ""_a(long double val);
+    Approx operator ""_a(unsigned long long val);
 } // end namespace literals

 template<>
--- a/src/catch2/catch_assertion_result.cpp
+++ b/src/catch2/catch_assertion_result.cpp
@@ -11,7 +11,7 @@

 namespace Catch {

-    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
+    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const& _lazyExpression):
        lazyExpression(_lazyExpression),
        resultType(_resultType) {}

--- a/src/catch2/internal/catch_case_sensitive.hpp
+++ b/src/catch2/internal/catch_case_sensitive.hpp
--- a/src/catch2/catch_config.hpp
+++ b/src/catch2/catch_config.hpp
@@ -76,7 +76,7 @@ namespace Catch {
        WarnAbout::What warnings = WarnAbout::Nothing;
        ShowDurations showDurations = ShowDurations::DefaultForReporter;
        double minDuration = -1;
-        TestRunOrder runOrder = TestRunOrder::Declared;
+        TestRunOrder runOrder = TestRunOrder::Randomized;
        ColourMode defaultColourMode = ColourMode::PlatformDefault;
        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;

--- a/src/catch2/catch_message.cpp
+++ b/src/catch2/catch_message.cpp
@@ -91,6 +91,7 @@ namespace Catch {
                    m_messages.back().message += " := ";
                    start = pos;
                }
+                break;
            default:; // noop
            }
        }
--- a/src/catch2/catch_message.hpp
+++ b/src/catch2/catch_message.hpp
@@ -94,7 +94,7 @@ namespace Catch {
    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
-        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+        catchAssertionHandler.complete(); \
    } while( false )

 ///////////////////////////////////////////////////////////////////////////////
--- a/src/catch2/catch_session.cpp
+++ b/src/catch2/catch_session.cpp
@@ -25,7 +25,6 @@
 #include <catch2/internal/catch_stdstreams.hpp>
 #include <catch2/internal/catch_istream.hpp>

-#include <algorithm>
 #include <cassert>
 #include <exception>
 #include <iomanip>
@@ -34,7 +33,13 @@
 namespace Catch {

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

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

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

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

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

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

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

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

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


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

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

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

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

-            // Note that on unices only the lower 8 bits are usually used, clamping
-            // the return value to 255 prevents false negative when some multiple
-            // of 256 tests has failed
-            return (std::min) (MaxExitCode, static_cast<int>(totals.assertions.failed));
+            if ( totals.assertions.failed ) { return TestFailureExitCode; }
+            return 0;
+
        }
 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
        catch( std::exception& ex ) {
            Catch::cerr() << ex.what() << '\n' << std::flush;
-            return MaxExitCode;
+            return UnspecifiedErrorExitCode;
        }
 #endif
    }
--- a/src/catch2/catch_test_case_info.cpp
+++ b/src/catch2/catch_test_case_info.cpp
@@ -22,26 +22,26 @@ namespace Catch {
        static_assert(sizeof(TestCaseProperties) == sizeof(TCP_underlying_type),
                      "The size of the TestCaseProperties is different from the assumed size");

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

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

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

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

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

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

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

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

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

    Detail::unique_ptr<TestCaseInfo>
--- a/src/catch2/catch_test_macros.hpp
+++ b/src/catch2/catch_test_macros.hpp
@@ -43,6 +43,7 @@
  #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
  #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
  #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+  #define CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, __VA_ARGS__ )
  #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
  #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
  #define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
@@ -97,6 +98,7 @@
  #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
  #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
  #define CATCH_METHOD_AS_TEST_CASE( method, ... )
+  #define CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
  #define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
  #define CATCH_SECTION( ... )
  #define CATCH_DYNAMIC_SECTION( ... )
@@ -142,6 +144,7 @@
  #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
  #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
  #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+  #define TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, __VA_ARGS__ )
  #define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
  #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
  #define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
@@ -195,6 +198,7 @@
  #define TEST_CASE( ... )  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__)
  #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
  #define METHOD_AS_TEST_CASE( method, ... )
+  #define TEST_CASE_PERSISTENT_FIXTURE( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__)
  #define REGISTER_TEST_CASE( Function, ... ) (void)(0)
  #define SECTION( ... )
  #define DYNAMIC_SECTION( ... )
--- a/src/catch2/catch_timer.cpp
+++ b/src/catch2/catch_timer.cpp
@@ -13,7 +13,7 @@ namespace Catch {

    namespace {
        static auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
-            return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
+            return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now().time_since_epoch()).count();
        }
    } // end unnamed namespace

@@ -30,7 +30,7 @@ namespace Catch {
        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
    }
    auto Timer::getElapsedSeconds() const -> double {
-        return getElapsedMicroseconds()/1000000.0;
+        return static_cast<double>(getElapsedMicroseconds())/1000000.0;
    }


--- a/src/catch2/catch_tostring.cpp
+++ b/src/catch2/catch_tostring.cpp
@@ -11,7 +11,6 @@
 #include <catch2/internal/catch_context.hpp>
 #include <catch2/internal/catch_polyfills.hpp>

-#include <cmath>
 #include <iomanip>

 namespace Catch {
@@ -22,7 +21,10 @@ namespace Detail {
        const int hexThreshold = 255;

        struct Endianness {
-            enum Arch { Big, Little };
+            enum Arch : uint8_t {
+                Big,
+                Little
+            };

            static Arch which() {
                int one = 1;
--- a/src/catch2/catch_tostring.hpp
+++ b/src/catch2/catch_tostring.hpp
@@ -64,18 +64,14 @@ namespace Catch {
          return rawMemoryToString( &object, sizeof(object) );
        }

-        template<typename T>
-        class IsStreamInsertable {
-            template<typename Stream, typename U>
-            static auto test(int)
-                -> decltype(std::declval<Stream&>() << std::declval<U>(), std::true_type());
+        template<typename T,typename = void>
+        static constexpr bool IsStreamInsertable_v = false;

-            template<typename, typename>
-            static auto test(...)->std::false_type;
-
-        public:
-            static const bool value = decltype(test<std::ostream, const T&>(0))::value;
-        };
+        template <typename T>
+        static constexpr bool IsStreamInsertable_v<
+            T,
+            decltype( void( std::declval<std::ostream&>() << std::declval<T>() ) )> =
+            true;

        template<typename E>
        std::string convertUnknownEnumToString( E e );
@@ -120,7 +116,7 @@ namespace Catch {
    struct StringMaker {
        template <typename Fake = T>
        static
-        std::enable_if_t<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>
+        std::enable_if_t<::Catch::Detail::IsStreamInsertable_v<Fake>, std::string>
            convert(const Fake& value) {
                ReusableStringStream rss;
                // NB: call using the function-like syntax to avoid ambiguity with
@@ -131,7 +127,7 @@ namespace Catch {

        template <typename Fake = T>
        static
-        std::enable_if_t<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>
+        std::enable_if_t<!::Catch::Detail::IsStreamInsertable_v<Fake>, std::string>
            convert( const Fake& value ) {
 #if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
            return Detail::convertUnstreamable(value);
@@ -523,7 +519,7 @@ namespace Catch {
    }

    template<typename R>
-    struct StringMaker<R, std::enable_if_t<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>> {
+    struct StringMaker<R, std::enable_if_t<is_range<R>::value && !::Catch::Detail::IsStreamInsertable_v<R>>> {
        static std::string convert( R const& range ) {
            return rangeToString( range );
        }
@@ -634,7 +630,11 @@ struct ratio_string<std::milli> {

 #ifdef _MSC_VER
            std::tm timeInfo = {};
-            gmtime_s(&timeInfo, &converted);
+            const auto err = gmtime_s(&timeInfo, &converted);
+            if ( err ) {
+                return "gmtime from provided timepoint has failed. This "
+                       "happens e.g. with pre-1970 dates using Microsoft libc";
+            }
 #else
            std::tm* timeInfo = std::gmtime(&converted);
 #endif
--- a/src/catch2/catch_translate_exception.hpp
+++ b/src/catch2/catch_translate_exception.hpp
@@ -25,7 +25,7 @@ namespace Catch {
        class ExceptionTranslator : public IExceptionTranslator {
        public:

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

--- a/src/catch2/catch_user_config.hpp.in
+++ b/src/catch2/catch_user_config.hpp.in
@@ -178,6 +178,15 @@
 #endif


+#cmakedefine CATCH_CONFIG_USE_BUILTIN_CONSTANT_P
+#cmakedefine CATCH_CONFIG_NO_USE_BUILTIN_CONSTANT_P
+
+#if defined( CATCH_CONFIG_USE_BUILTIN_CONSTANT_P ) && \
+    defined( CATCH_CONFIG_NO_USE_BUILTIN_CONSTANT_P )
+#    error Cannot force USE_BUILTIN_CONSTANT_P to both ON and OFF
+#endif
+
+
 // ------
 // Simple toggle defines
 // their value is never used and they cannot be overridden
--- a/src/catch2/catch_version.cpp
+++ b/src/catch2/catch_version.cpp
@@ -36,7 +36,7 @@ namespace Catch {
    }

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

--- a/src/catch2/catch_version_macros.hpp
+++ b/src/catch2/catch_version_macros.hpp
@@ -9,7 +9,7 @@
 #define CATCH_VERSION_MACROS_HPP_INCLUDED

 #define CATCH_VERSION_MAJOR 3
-#define CATCH_VERSION_MINOR 6
-#define CATCH_VERSION_PATCH 0
+#define CATCH_VERSION_MINOR 8
+#define CATCH_VERSION_PATCH 1

 #endif // CATCH_VERSION_MACROS_HPP_INCLUDED
--- a/src/catch2/generators/catch_generators_range.hpp
+++ b/src/catch2/generators/catch_generators_range.hpp
@@ -91,7 +91,7 @@ public:

 template <typename InputIterator,
          typename InputSentinel,
-          typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
+          typename ResultType = std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type>>
 GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
    return GeneratorWrapper<ResultType>(Catch::Detail::make_unique<IteratorGenerator<ResultType>>(from, to));
 }
--- a/src/catch2/interfaces/catch_interfaces_capture.hpp
+++ b/src/catch2/interfaces/catch_interfaces_capture.hpp
@@ -9,7 +9,6 @@
 #define CATCH_INTERFACES_CAPTURE_HPP_INCLUDED

 #include <string>
-#include <chrono>

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

 #include <chrono>
-#include <iosfwd>
 #include <string>
 #include <vector>

--- a/src/catch2/interfaces/catch_interfaces_reporter.hpp
+++ b/src/catch2/interfaces/catch_interfaces_reporter.hpp
@@ -20,7 +20,6 @@
 #include <map>
 #include <string>
 #include <vector>
-#include <iosfwd>

 namespace Catch {

--- a/src/catch2/interfaces/catch_interfaces_test_invoker.hpp
+++ b/src/catch2/interfaces/catch_interfaces_test_invoker.hpp
@@ -12,6 +12,8 @@ namespace Catch {

    class ITestInvoker {
    public:
+        virtual void prepareTestCase();
+        virtual void tearDownTestCase();
        virtual void invoke() const = 0;
        virtual ~ITestInvoker(); // = default
    };
--- a/src/catch2/internal/catch_assertion_handler.cpp
+++ b/src/catch2/internal/catch_assertion_handler.cpp
@@ -28,8 +28,8 @@ namespace Catch {
    void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
        m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
    }
-    void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef message) {
-        m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
+    void AssertionHandler::handleMessage(ResultWas::OfType resultType, std::string&& message) {
+        m_resultCapture.handleMessage( m_assertionInfo, resultType, CATCH_MOVE(message), m_reaction );
    }

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


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

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

        void handleExceptionThrownAsExpected();
        void handleUnexpectedExceptionNotThrown();
--- a/src/catch2/internal/catch_clara.cpp
+++ b/src/catch2/internal/catch_clara.cpp
@@ -76,7 +76,7 @@ namespace Catch {
                                { TokenType::Argument,
                                  next.substr( delimiterPos + 1, next.size() ) } );
                        } else {
-                            if ( next[1] != '-' && next.size() > 2 ) {
+                            if ( next.size() > 1 && next[1] != '-' && next.size() > 2 ) {
                                // Combined short args, e.g. "-ab" for "-a -b"
                                for ( size_t i = 1; i < next.size(); ++i ) {
                                    m_tokenBuffer.push_back(
--- a/src/catch2/internal/catch_compiler_capabilities.hpp
+++ b/src/catch2/internal/catch_compiler_capabilities.hpp
@@ -62,7 +62,7 @@
 #    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
         _Pragma( "GCC diagnostic ignored \"-Wshadow\"" )

-#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
+#    define CATCH_INTERNAL_CONFIG_USE_BUILTIN_CONSTANT_P

 #endif

@@ -86,14 +86,45 @@
 // clang-cl defines _MSC_VER as well as __clang__, which could cause the
 // start/stop internal suppression macros to be double defined.
 #if defined(__clang__) && !defined(_MSC_VER)
-
+#    define CATCH_INTERNAL_CONFIG_USE_BUILTIN_CONSTANT_P
 #    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
 #    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )
-
 #endif // __clang__ && !_MSC_VER

 #if defined(__clang__)

+#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
+         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
+
+#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
+
+#    if (__clang_major__ >= 20)
+#        define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+             _Pragma( "clang diagnostic ignored \"-Wvariadic-macro-arguments-omitted\"" )
+#    elif (__clang_major__ == 19)
+#        define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+	         _Pragma( "clang diagnostic ignored \"-Wc++20-extensions\"" )
+#    else
+#        define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
+             _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
+#    endif
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
+        _Pragma( "clang diagnostic ignored \"-Wcomma\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
+        _Pragma( "clang diagnostic ignored \"-Wshadow\"" )
+
+#endif // __clang__
+
 // As of this writing, IBM XL's implementation of __builtin_constant_p has a bug
 // which results in calls to destructors being emitted for each temporary,
 // without a matching initialization. In practice, this can result in something
@@ -110,35 +141,11 @@
 // https://developer.nvidia.com/nvidia_bug/3321845.
 //
 // Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented.
-#  if !defined(__ibmxl__) && !defined(__CUDACC__) && !defined( __NVCOMPILER )
-#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */
-#  endif
+#if defined( __ibmxl__ ) || defined( __CUDACC__ ) || defined( __NVCOMPILER )
+#    define CATCH_INTERNAL_CONFIG_NO_USE_BUILTIN_CONSTANT_P
+#endif


-#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
-         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
-
-#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
-        _Pragma( "clang diagnostic ignored \"-Wcomma\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
-        _Pragma( "clang diagnostic ignored \"-Wshadow\"" )
-
-#endif // __clang__
-

 ////////////////////////////////////////////////////////////////////////////////
 // We know some environments not to support full POSIX signals
@@ -362,6 +369,22 @@
 #endif


+// The goal of this macro is to avoid evaluation of the arguments, but
+// still have the compiler warn on problems inside...
+#if defined( CATCH_INTERNAL_CONFIG_USE_BUILTIN_CONSTANT_P ) && \
+    !defined( CATCH_INTERNAL_CONFIG_NO_USE_BUILTIN_CONSTANT_P ) && !defined(CATCH_CONFIG_USE_BUILTIN_CONSTANT_P)
+#define CATCH_CONFIG_USE_BUILTIN_CONSTANT_P
+#endif
+
+#if defined( CATCH_CONFIG_USE_BUILTIN_CONSTANT_P ) && \
+    !defined( CATCH_CONFIG_NO_USE_BUILTIN_CONSTANT_P )
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN( ... )                                              \
+        (void)__builtin_constant_p( __VA_ARGS__ ) /* NOLINT(cppcoreguidelines-pro-type-vararg, \
+                                                     hicpp-vararg) */
+#else
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN( ... )
+#endif
+
 // Even if we do not think the compiler has that warning, we still have
 // to provide a macro that can be used by the code.
 #if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
@@ -398,13 +421,6 @@
 #    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS
 #endif

-
-// The goal of this macro is to avoid evaluation of the arguments, but
-// still have the compiler warn on problems inside...
-#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
-#   define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
-#endif
-
 #if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
 #   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
 #elif defined(__clang__) && (__clang_major__ < 5)
--- a/src/catch2/internal/catch_console_colour.cpp
+++ b/src/catch2/internal/catch_console_colour.cpp
@@ -161,7 +161,7 @@ namespace {
 #endif // Windows/ ANSI/ None


-#if defined( CATCH_PLATFORM_LINUX ) || defined( CATCH_PLATFORM_MAC )
+#if defined( CATCH_PLATFORM_LINUX ) || defined( CATCH_PLATFORM_MAC ) || defined( __GLIBC__ )
 #    define CATCH_INTERNAL_HAS_ISATTY
 #    include <unistd.h>
 #endif
--- a/src/catch2/internal/catch_context.cpp
+++ b/src/catch2/internal/catch_context.cpp
@@ -27,12 +27,6 @@ namespace Catch {
        return *Context::currentContext;
    }

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

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

    Context& getCurrentMutableContext();
--- a/src/catch2/internal/catch_decomposer.hpp
+++ b/src/catch2/internal/catch_decomposer.hpp
@@ -45,7 +45,7 @@
 *    when the compiler handles `ExprLhs<T> == b`, it also tries to resolve
 *    the overload set for `b == ExprLhs<T>`.
 *
- * To accomodate these use cases, decomposer ended up rather complex.
+ * To accommodate these use cases, decomposer ended up rather complex.
 *
 * 1) These types are handled by adding SFINAE overloads to our comparison
 *    operators, checking whether `T == U` are comparable with the given
@@ -157,10 +157,13 @@ namespace Catch {
        bool m_isBinaryExpression;
        bool m_result;

+    protected:
+        ~ITransientExpression() = default;
+
    public:
        constexpr auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
        constexpr auto getResult() const -> bool { return m_result; }
-        //! This function **has** to be overriden by the derived class.
+        //! This function **has** to be overridden by the derived class.
        virtual void streamReconstructedExpression( std::ostream& os ) const;

        constexpr ITransientExpression( bool isBinaryExpression, bool result )
@@ -168,17 +171,13 @@ namespace Catch {
            m_result( result )
        {}

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

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

    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
--- a/src/catch2/internal/catch_enforce.hpp
+++ b/src/catch2/internal/catch_enforce.hpp
@@ -12,7 +12,7 @@
 #include <catch2/internal/catch_compiler_capabilities.hpp>
 #include <catch2/internal/catch_reusable_string_stream.hpp>

-#include <exception>
+#include <exception> // for `std::exception` in no-exception configuration

 namespace Catch {
 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
--- a/src/catch2/internal/catch_exception_translator_registry.hpp
+++ b/src/catch2/internal/catch_exception_translator_registry.hpp
@@ -11,7 +11,6 @@
 #include <catch2/interfaces/catch_interfaces_exception.hpp>
 #include <catch2/internal/catch_unique_ptr.hpp>

-#include <vector>
 #include <string>

 namespace Catch {
--- a/src/catch2/internal/catch_is_permutation.hpp
+++ b/src/catch2/internal/catch_is_permutation.hpp
@@ -8,8 +8,8 @@
 #ifndef CATCH_IS_PERMUTATION_HPP_INCLUDED
 #define CATCH_IS_PERMUTATION_HPP_INCLUDED

-#include <algorithm>
 #include <iterator>
+#include <type_traits>

 namespace Catch {
    namespace Detail {
@@ -18,6 +18,7 @@ namespace Catch {
                  typename Sentinel,
                  typename T,
                  typename Comparator>
+        constexpr
        ForwardIter find_sentinel( ForwardIter start,
                                   Sentinel sentinel,
                                   T const& value,
@@ -33,6 +34,7 @@ namespace Catch {
                  typename Sentinel,
                  typename T,
                  typename Comparator>
+        constexpr
        std::ptrdiff_t count_sentinel( ForwardIter start,
                                       Sentinel sentinel,
                                       T const& value,
@@ -46,6 +48,7 @@ namespace Catch {
        }

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

        template <typename ForwardIter>
-        std::ptrdiff_t sentinel_distance( ForwardIter first,
+        constexpr std::ptrdiff_t sentinel_distance( ForwardIter first,
                                                    ForwardIter last ) {
            return std::distance( first, last );
        }
@@ -68,7 +71,7 @@ namespace Catch {
                  typename ForwardIter2,
                  typename Sentinel2,
                  typename Comparator>
-        bool check_element_counts( ForwardIter1 first_1,
+        constexpr bool check_element_counts( ForwardIter1 first_1,
                                             const Sentinel1 end_1,
                                             ForwardIter2 first_2,
                                             const Sentinel2 end_2,
@@ -102,7 +105,7 @@ namespace Catch {
                  typename ForwardIter2,
                  typename Sentinel2,
                  typename Comparator>
-        bool is_permutation( ForwardIter1 first_1,
+        constexpr bool is_permutation( ForwardIter1 first_1,
                                       const Sentinel1 end_1,
                                       ForwardIter2 first_2,
                                       const Sentinel2 end_2,
--- a/src/catch2/internal/catch_istream.cpp
+++ b/src/catch2/internal/catch_istream.cpp
@@ -14,8 +14,6 @@

 #include <cstdio>
 #include <fstream>
-#include <sstream>
-#include <vector>

 namespace Catch {

--- a/src/catch2/internal/catch_istream.hpp
+++ b/src/catch2/internal/catch_istream.hpp
@@ -12,8 +12,6 @@
 #include <catch2/internal/catch_unique_ptr.hpp>

 #include <iosfwd>
-#include <cstddef>
-#include <ostream>
 #include <string>

 namespace Catch {
--- a/src/catch2/internal/catch_lazy_expr.hpp
+++ b/src/catch2/internal/catch_lazy_expr.hpp
@@ -22,13 +22,13 @@ namespace Catch {
        ITransientExpression const* m_transientExpression = nullptr;
        bool m_isNegated;
    public:
-        LazyExpression( bool isNegated ):
+        constexpr LazyExpression( bool isNegated ):
            m_isNegated(isNegated)
        {}
-        LazyExpression(LazyExpression const& other) = default;
+        constexpr LazyExpression(LazyExpression const& other) = default;
        LazyExpression& operator = ( LazyExpression const& ) = delete;

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

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

 // SPDX-License-Identifier: BSL-1.0
-#include <catch2/internal/catch_output_redirect.hpp>
+#include <catch2/internal/catch_compiler_capabilities.hpp>
 #include <catch2/internal/catch_enforce.hpp>
+#include <catch2/internal/catch_output_redirect.hpp>
+#include <catch2/internal/catch_platform.hpp>
+#include <catch2/internal/catch_reusable_string_stream.hpp>
 #include <catch2/internal/catch_stdstreams.hpp>

 #include <cstdio>
 #include <cstring>
+#include <iosfwd>
 #include <sstream>

-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-    #if defined(_MSC_VER)
-    #include <io.h>      //_dup and _dup2
-    #define dup _dup
-    #define dup2 _dup2
-    #define fileno _fileno
-    #else
-    #include <unistd.h>  // dup and dup2
-    #endif
+#if defined( CATCH_CONFIG_NEW_CAPTURE )
+#    if defined( _MSC_VER )
+#        include <io.h> //_dup and _dup2
+#        define dup _dup
+#        define dup2 _dup2
+#        define fileno _fileno
+#    else
+#        include <unistd.h> // dup and dup2
+#    endif
 #endif

-
 namespace Catch {

-    RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
-    :   m_originalStream( originalStream ),
+    namespace {
+        //! A no-op implementation, used if no reporter wants output
+        //! redirection.
+        class NoopRedirect : public OutputRedirect {
+            void activateImpl() override {}
+            void deactivateImpl() override {}
+            std::string getStdout() override { return {}; }
+            std::string getStderr() override { return {}; }
+            void clearBuffers() override {}
+        };
+
+        /**
+         * Redirects specific stream's rdbuf with another's.
+         *
+         * Redirection can be stopped and started on-demand, assumes
+         * that the underlying stream's rdbuf aren't changed by other
+         * users.
+         */
+        class RedirectedStreamNew {
+            std::ostream& m_originalStream;
+            std::ostream& m_redirectionStream;
+            std::streambuf* m_prevBuf;
+
+        public:
+            RedirectedStreamNew( std::ostream& originalStream,
+                                 std::ostream& redirectionStream ):
+                m_originalStream( originalStream ),
                m_redirectionStream( redirectionStream ),
-        m_prevBuf( m_originalStream.rdbuf() )
-    {
+                m_prevBuf( m_originalStream.rdbuf() ) {}
+
+            void startRedirect() {
                m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
            }
+            void stopRedirect() { m_originalStream.rdbuf( m_prevBuf ); }
+        };

-    RedirectedStream::~RedirectedStream() {
-        m_originalStream.rdbuf( m_prevBuf );
+        /**
+         * Redirects the `std::cout`, `std::cerr`, `std::clog` streams,
+         * but does not touch the actual `stdout`/`stderr` file descriptors.
+         */
+        class StreamRedirect : public OutputRedirect {
+            ReusableStringStream m_redirectedOut, m_redirectedErr;
+            RedirectedStreamNew m_cout, m_cerr, m_clog;
+
+        public:
+            StreamRedirect():
+                m_cout( Catch::cout(), m_redirectedOut.get() ),
+                m_cerr( Catch::cerr(), m_redirectedErr.get() ),
+                m_clog( Catch::clog(), m_redirectedErr.get() ) {}
+
+            void activateImpl() override {
+                m_cout.startRedirect();
+                m_cerr.startRedirect();
+                m_clog.startRedirect();
            }
-
-    RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {}
-    auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
-
-    RedirectedStdErr::RedirectedStdErr()
-    :   m_cerr( Catch::cerr(), m_rss.get() ),
-        m_clog( Catch::clog(), m_rss.get() )
-    {}
-    auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
-
-    RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
-    :   m_redirectedCout(redirectedCout),
-        m_redirectedCerr(redirectedCerr)
-    {}
-
-    RedirectedStreams::~RedirectedStreams() {
-        m_redirectedCout += m_redirectedStdOut.str();
-        m_redirectedCerr += m_redirectedStdErr.str();
+            void deactivateImpl() override {
+                m_cout.stopRedirect();
+                m_cerr.stopRedirect();
+                m_clog.stopRedirect();
            }
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-
-#if defined(_MSC_VER)
-    TempFile::TempFile() {
-        if (tmpnam_s(m_buffer)) {
-            CATCH_RUNTIME_ERROR("Could not get a temp filename");
+            std::string getStdout() override { return m_redirectedOut.str(); }
+            std::string getStderr() override { return m_redirectedErr.str(); }
+            void clearBuffers() override {
+                m_redirectedOut.str( "" );
+                m_redirectedErr.str( "" );
            }
-        if (fopen_s(&m_file, m_buffer, "w+")) {
+        };
+
+#if defined( CATCH_CONFIG_NEW_CAPTURE )
+
+        // Windows's implementation of std::tmpfile is terrible (it tries
+        // to create a file inside system folder, thus requiring elevated
+        // privileges for the binary), so we have to use tmpnam(_s) and
+        // create the file ourselves there.
+        class TempFile {
+        public:
+            TempFile( TempFile const& ) = delete;
+            TempFile& operator=( TempFile const& ) = delete;
+            TempFile( TempFile&& ) = delete;
+            TempFile& operator=( TempFile&& ) = delete;
+
+#    if defined( _MSC_VER )
+            TempFile() {
+                if ( tmpnam_s( m_buffer ) ) {
+                    CATCH_RUNTIME_ERROR( "Could not get a temp filename" );
+                }
+                if ( fopen_s( &m_file, m_buffer, "wb+" ) ) {
                    char buffer[100];
-            if (strerror_s(buffer, errno)) {
-                CATCH_RUNTIME_ERROR("Could not translate errno to a string");
+                    if ( strerror_s( buffer, errno ) ) {
+                        CATCH_RUNTIME_ERROR(
+                            "Could not translate errno to a string" );
                    }
-            CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
+                    CATCH_RUNTIME_ERROR( "Could not open the temp file: '"
+                                         << m_buffer
+                                         << "' because: " << buffer );
                }
            }
-#else
-    TempFile::TempFile() {
+#    else
+            TempFile() {
                m_file = std::tmpfile();
-        if (!m_file) {
-            CATCH_RUNTIME_ERROR("Could not create a temp file.");
+                if ( !m_file ) {
+                    CATCH_RUNTIME_ERROR( "Could not create a temp file." );
                }
            }
+#    endif

-#endif
-
-    TempFile::~TempFile() {
+            ~TempFile() {
                // TBD: What to do about errors here?
-         std::fclose(m_file);
+                std::fclose( m_file );
                // We manually create the file on Windows only, on Linux
                // it will be autodeleted
-#if defined(_MSC_VER)
-         std::remove(m_buffer);
-#endif
+#    if defined( _MSC_VER )
+                std::remove( m_buffer );
+#    endif
            }

-
-    FILE* TempFile::getFile() {
-        return m_file;
-    }
-
-    std::string TempFile::getContents() {
-        std::stringstream sstr;
-        char buffer[100] = {};
-        std::rewind(m_file);
-        while (std::fgets(buffer, sizeof(buffer), m_file)) {
+            std::FILE* getFile() { return m_file; }
+            std::string getContents() {
+                ReusableStringStream sstr;
+                constexpr long buffer_size = 100;
+                char buffer[buffer_size + 1] = {};
+                long current_pos = ftell( m_file );
+                CATCH_ENFORCE( current_pos >= 0,
+                               "ftell failed, errno: " << errno );
+                std::rewind( m_file );
+                while ( current_pos > 0 ) {
+                    auto read_characters =
+                        std::fread( buffer,
+                                    1,
+                                    std::min( buffer_size, current_pos ),
+                                    m_file );
+                    buffer[read_characters] = '\0';
                    sstr << buffer;
+                    current_pos -= static_cast<long>( read_characters );
                }
                return sstr.str();
            }

-    OutputRedirect::OutputRedirect(std::string& stdout_dest, std::string& stderr_dest) :
-        m_originalStdout(dup(1)),
-        m_originalStderr(dup(2)),
-        m_stdoutDest(stdout_dest),
-        m_stderrDest(stderr_dest) {
-        dup2(fileno(m_stdoutFile.getFile()), 1);
-        dup2(fileno(m_stderrFile.getFile()), 2);
-    }
+            void clear() { std::rewind( m_file ); }

-    OutputRedirect::~OutputRedirect() {
+        private:
+            std::FILE* m_file = nullptr;
+            char m_buffer[L_tmpnam] = { 0 };
+        };
+
+        /**
+         * Redirects the actual `stdout`/`stderr` file descriptors.
+         *
+         * Works by replacing the file descriptors numbered 1 and 2
+         * with an open temporary file.
+         */
+        class FileRedirect : public OutputRedirect {
+            TempFile m_outFile, m_errFile;
+            int m_originalOut = -1;
+            int m_originalErr = -1;
+
+            // Flushes cout/cerr/clog streams and stdout/stderr FDs
+            void flushEverything() {
                Catch::cout() << std::flush;
-        fflush(stdout);
+                fflush( stdout );
                // Since we support overriding these streams, we flush cerr
                // even though std::cerr is unbuffered
                Catch::cerr() << std::flush;
                Catch::clog() << std::flush;
-        fflush(stderr);
-
-        dup2(m_originalStdout, 1);
-        dup2(m_originalStderr, 2);
-
-        m_stdoutDest += m_stdoutFile.getContents();
-        m_stderrDest += m_stderrFile.getContents();
+                fflush( stderr );
            }

+        public:
+            FileRedirect():
+                m_originalOut( dup( fileno( stdout ) ) ),
+                m_originalErr( dup( fileno( stderr ) ) ) {
+                CATCH_ENFORCE( m_originalOut >= 0, "Could not dup stdout" );
+                CATCH_ENFORCE( m_originalErr >= 0, "Could not dup stderr" );
+            }
+
+            std::string getStdout() override { return m_outFile.getContents(); }
+            std::string getStderr() override { return m_errFile.getContents(); }
+            void clearBuffers() override {
+                m_outFile.clear();
+                m_errFile.clear();
+            }
+
+            void activateImpl() override {
+                // We flush before starting redirect, to ensure that we do
+                // not capture the end of message sent before activation.
+                flushEverything();
+
+                int ret;
+                ret = dup2( fileno( m_outFile.getFile() ), fileno( stdout ) );
+                CATCH_ENFORCE( ret >= 0,
+                               "dup2 to stdout has failed, errno: " << errno );
+                ret = dup2( fileno( m_errFile.getFile() ), fileno( stderr ) );
+                CATCH_ENFORCE( ret >= 0,
+                               "dup2 to stderr has failed, errno: " << errno );
+            }
+            void deactivateImpl() override {
+                // We flush before ending redirect, to ensure that we
+                // capture all messages sent while the redirect was active.
+                flushEverything();
+
+                int ret;
+                ret = dup2( m_originalOut, fileno( stdout ) );
+                CATCH_ENFORCE(
+                    ret >= 0,
+                    "dup2 of original stdout has failed, errno: " << errno );
+                ret = dup2( m_originalErr, fileno( stderr ) );
+                CATCH_ENFORCE(
+                    ret >= 0,
+                    "dup2 of original stderr has failed, errno: " << errno );
+            }
+        };
+
 #endif // CATCH_CONFIG_NEW_CAPTURE

+    } // end namespace
+
+    bool isRedirectAvailable( OutputRedirect::Kind kind ) {
+        switch ( kind ) {
+        // These two are always available
+        case OutputRedirect::None:
+        case OutputRedirect::Streams:
+            return true;
+#if defined( CATCH_CONFIG_NEW_CAPTURE )
+        case OutputRedirect::FileDescriptors:
+            return true;
+#endif
+        default:
+            return false;
+        }
+    }
+
+    Detail::unique_ptr<OutputRedirect> makeOutputRedirect( bool actual ) {
+        if ( actual ) {
+            // TODO: Clean this up later
+#if defined( CATCH_CONFIG_NEW_CAPTURE )
+            return Detail::make_unique<FileRedirect>();
+#else
+            return Detail::make_unique<StreamRedirect>();
+#endif
+        } else {
+            return Detail::make_unique<NoopRedirect>();
+        }
+    }
+
+    RedirectGuard scopedActivate( OutputRedirect& redirectImpl ) {
+        return RedirectGuard( true, redirectImpl );
+    }
+
+    RedirectGuard scopedDeactivate( OutputRedirect& redirectImpl ) {
+        return RedirectGuard( false, redirectImpl );
+    }
+
+    OutputRedirect::~OutputRedirect() = default;
+
+    RedirectGuard::RedirectGuard( bool activate, OutputRedirect& redirectImpl ):
+        m_redirect( &redirectImpl ),
+        m_activate( activate ),
+        m_previouslyActive( redirectImpl.isActive() ) {
+
+        // Skip cases where there is no actual state change.
+        if ( m_activate == m_previouslyActive ) { return; }
+
+        if ( m_activate ) {
+            m_redirect->activate();
+        } else {
+            m_redirect->deactivate();
+        }
+    }
+
+    RedirectGuard::~RedirectGuard() noexcept( false ) {
+        if ( m_moved ) { return; }
+        // Skip cases where there is no actual state change.
+        if ( m_activate == m_previouslyActive ) { return; }
+
+        if ( m_activate ) {
+            m_redirect->deactivate();
+        } else {
+            m_redirect->activate();
+        }
+    }
+
+    RedirectGuard::RedirectGuard( RedirectGuard&& rhs ) noexcept:
+        m_redirect( rhs.m_redirect ),
+        m_activate( rhs.m_activate ),
+        m_previouslyActive( rhs.m_previouslyActive ),
+        m_moved( false ) {
+        rhs.m_moved = true;
+    }
+
+    RedirectGuard& RedirectGuard::operator=( RedirectGuard&& rhs ) noexcept {
+        m_redirect = rhs.m_redirect;
+        m_activate = rhs.m_activate;
+        m_previouslyActive = rhs.m_previouslyActive;
+        m_moved = false;
+        rhs.m_moved = true;
+        return *this;
+    }
+
 } // namespace Catch

-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-    #if defined(_MSC_VER)
-    #undef dup
-    #undef dup2
-    #undef fileno
-    #endif
+#if defined( CATCH_CONFIG_NEW_CAPTURE )
+#    if defined( _MSC_VER )
+#        undef dup
+#        undef dup2
+#        undef fileno
+#    endif
 #endif
--- a/src/catch2/internal/catch_output_redirect.hpp
+++ b/src/catch2/internal/catch_output_redirect.hpp
@@ -8,110 +8,69 @@
 #ifndef CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
 #define CATCH_OUTPUT_REDIRECT_HPP_INCLUDED

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

-#include <cstdio>
-#include <iosfwd>
+#include <cassert>
 #include <string>

 namespace Catch {

-    class RedirectedStream {
-        std::ostream& m_originalStream;
-        std::ostream& m_redirectionStream;
-        std::streambuf* m_prevBuf;
-
-    public:
-        RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream );
-        ~RedirectedStream();
-    };
-
-    class RedirectedStdOut {
-        ReusableStringStream m_rss;
-        RedirectedStream m_cout;
-    public:
-        RedirectedStdOut();
-        auto str() const -> std::string;
-    };
-
-    // StdErr has two constituent streams in C++, std::cerr and std::clog
-    // This means that we need to redirect 2 streams into 1 to keep proper
-    // order of writes
-    class RedirectedStdErr {
-        ReusableStringStream m_rss;
-        RedirectedStream m_cerr;
-        RedirectedStream m_clog;
-    public:
-        RedirectedStdErr();
-        auto str() const -> std::string;
-    };
-
-    class RedirectedStreams {
-    public:
-        RedirectedStreams(RedirectedStreams const&) = delete;
-        RedirectedStreams& operator=(RedirectedStreams const&) = delete;
-        RedirectedStreams(RedirectedStreams&&) = delete;
-        RedirectedStreams& operator=(RedirectedStreams&&) = delete;
-
-        RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
-        ~RedirectedStreams();
-    private:
-        std::string& m_redirectedCout;
-        std::string& m_redirectedCerr;
-        RedirectedStdOut m_redirectedStdOut;
-        RedirectedStdErr m_redirectedStdErr;
-    };
-
-#if defined(CATCH_CONFIG_NEW_CAPTURE)
-
-    // Windows's implementation of std::tmpfile is terrible (it tries
-    // to create a file inside system folder, thus requiring elevated
-    // privileges for the binary), so we have to use tmpnam(_s) and
-    // create the file ourselves there.
-    class TempFile {
-    public:
-        TempFile(TempFile const&) = delete;
-        TempFile& operator=(TempFile const&) = delete;
-        TempFile(TempFile&&) = delete;
-        TempFile& operator=(TempFile&&) = delete;
-
-        TempFile();
-        ~TempFile();
-
-        std::FILE* getFile();
-        std::string getContents();
-
-    private:
-        std::FILE* m_file = nullptr;
-    #if defined(_MSC_VER)
-        char m_buffer[L_tmpnam] = { 0 };
-    #endif
-    };
-
-
    class OutputRedirect {
+        bool m_redirectActive = false;
+        virtual void activateImpl() = 0;
+        virtual void deactivateImpl() = 0;
    public:
-        OutputRedirect(OutputRedirect const&) = delete;
-        OutputRedirect& operator=(OutputRedirect const&) = delete;
-        OutputRedirect(OutputRedirect&&) = delete;
-        OutputRedirect& operator=(OutputRedirect&&) = delete;
-
-
-        OutputRedirect(std::string& stdout_dest, std::string& stderr_dest);
-        ~OutputRedirect();
-
-    private:
-        int m_originalStdout = -1;
-        int m_originalStderr = -1;
-        TempFile m_stdoutFile;
-        TempFile m_stderrFile;
-        std::string& m_stdoutDest;
-        std::string& m_stderrDest;
+        enum Kind {
+            //! No redirect (noop implementation)
+            None,
+            //! Redirect std::cout/std::cerr/std::clog streams internally
+            Streams,
+            //! Redirect the stdout/stderr file descriptors into files
+            FileDescriptors,
        };

-#endif
+        virtual ~OutputRedirect(); // = default;
+
+        // TODO: Do we want to check that redirect is not active before retrieving the output?
+        virtual std::string getStdout() = 0;
+        virtual std::string getStderr() = 0;
+        virtual void clearBuffers() = 0;
+        bool isActive() const { return m_redirectActive; }
+        void activate() {
+            assert( !m_redirectActive && "redirect is already active" );
+            activateImpl();
+            m_redirectActive = true;
+        }
+        void deactivate() {
+            assert( m_redirectActive && "redirect is not active" );
+            deactivateImpl();
+            m_redirectActive = false;
+        }
+    };
+
+    bool isRedirectAvailable( OutputRedirect::Kind kind);
+    Detail::unique_ptr<OutputRedirect> makeOutputRedirect( bool actual );
+
+    class RedirectGuard {
+        OutputRedirect* m_redirect;
+        bool m_activate;
+        bool m_previouslyActive;
+        bool m_moved = false;
+
+    public:
+        RedirectGuard( bool activate, OutputRedirect& redirectImpl );
+        ~RedirectGuard() noexcept( false );
+
+        RedirectGuard( RedirectGuard const& ) = delete;
+        RedirectGuard& operator=( RedirectGuard const& ) = delete;
+
+        // C++14 needs move-able guards to return them from functions
+        RedirectGuard( RedirectGuard&& rhs ) noexcept;
+        RedirectGuard& operator=( RedirectGuard&& rhs ) noexcept;
+    };
+
+    RedirectGuard scopedActivate( OutputRedirect& redirectImpl );
+    RedirectGuard scopedDeactivate( OutputRedirect& redirectImpl );

 } // end namespace Catch

--- a/src/catch2/internal/catch_random_integer_helpers.hpp
+++ b/src/catch2/internal/catch_random_integer_helpers.hpp
@@ -69,7 +69,7 @@ namespace Catch {
        struct ExtendedMultResult {
            T upper;
            T lower;
-            bool operator==( ExtendedMultResult const& rhs ) const {
+            constexpr bool operator==( ExtendedMultResult const& rhs ) const {
                return upper == rhs.upper && lower == rhs.lower;
            }
        };
@@ -187,6 +187,7 @@ namespace Catch {
         * get by simple casting ([0, ..., INT_MAX, INT_MIN, ..., -1])
         */
        template <typename OriginalType, typename UnsignedType>
+        constexpr
        std::enable_if_t<std::is_signed<OriginalType>::value, UnsignedType>
        transposeToNaturalOrder( UnsignedType in ) {
            static_assert(
@@ -207,6 +208,7 @@ namespace Catch {

        template <typename OriginalType,
                  typename UnsignedType>
+        constexpr
        std::enable_if_t<std::is_unsigned<OriginalType>::value, UnsignedType>
            transposeToNaturalOrder(UnsignedType in) {
            static_assert(
--- a/src/catch2/internal/catch_random_number_generator.cpp
+++ b/src/catch2/internal/catch_random_number_generator.cpp
@@ -52,7 +52,7 @@ namespace {
    SimplePcg32::result_type SimplePcg32::operator()() {
        // prepare the output value
        const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
-        const auto output = rotate_right(xorshifted, m_state >> 59u);
+        const auto output = rotate_right(xorshifted, static_cast<uint32_t>(m_state >> 59u));

        // advance state
        m_state = m_state * 6364136223846793005ULL + s_inc;
--- a/src/catch2/internal/catch_result_type.cpp
+++ b/src/catch2/internal/catch_result_type.cpp
@@ -1,26 +0,0 @@
-
-//              Copyright Catch2 Authors
-// Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE.txt or copy at
-//        https://www.boost.org/LICENSE_1_0.txt)
-
-// SPDX-License-Identifier: BSL-1.0
-#include <catch2/internal/catch_result_type.hpp>
-
-namespace Catch {
-
-    bool isOk( ResultWas::OfType resultType ) {
-        return ( resultType & ResultWas::FailureBit ) == 0;
-    }
-    bool isJustInfo( int flags ) {
-        return flags == ResultWas::Info;
-    }
-
-    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
-        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
-    }
-
-    bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
-    bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
-
-} // end namespace Catch
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Martin Hořeňovský	71a3db4815	Fix Bazel sharding test that relied on tests being run in declaration order	2025-04-29 17:15:15 +02:00
Martin Hořeňovský	dba0b3fa82	Default to randomized test case order	2025-04-29 17:00:09 +02:00
Martin Hořeňovský	1e7b879fae	Small include cleanup	2025-04-29 13:15:34 +02:00
ZXShady	4ff57aba42	Use variable templates	2025-04-27 21:14:04 -06:00
Chris Thrasher	dde8220613	Add VS 2025 CI jobs	2025-04-27 11:08:50 -06:00
Chris Thrasher	cecb02e68f	Use presets in CI	2025-04-27 11:08:48 -06:00
Chris Thrasher	66085dac55	Simplify Windows CI jobs	2025-04-27 11:08:45 -06:00
Chris Thrasher	5a6d70eebb	Remove unused headers	2025-04-27 11:08:41 -06:00
Chris Thrasher	10d1a2750c	Simplify Linux CI jobs	2025-04-26 22:46:48 -06:00
Chris Thrasher	c17d69f813	Simplify macOS CI jobs	2025-04-26 22:46:45 -06:00
Chris Thrasher	4c93a595a1	Fix typos	2025-04-26 22:46:42 -06:00
Chris Thrasher	e8f4b60e62	Add more useful preset settings	2025-04-26 22:46:21 -06:00
Chris Thrasher	371b11b5a8	Modernize tools/misc/CMakeLists.txt	2025-04-26 22:46:13 -06:00
Chris Thrasher	8039e3ea1e	Prevent unnecessarily finding C compiler	2025-04-26 12:05:22 -06:00
Chris Thrasher	1d3bfb324d	Inherit C++14 requirement from upstream target	2025-04-26 11:00:03 -06:00
Chris Thrasher	5c97a8583d	Use more modern `-S` for specifying CMake source dir	2025-04-26 10:59:42 -06:00
Chris Thrasher	8cfca70ae8	Fix formatting of CMake files 2 spaces seems to be the more common indentation level so that's what I unified around.	2025-04-26 10:38:36 -06:00
Chris Thrasher	6aac11e17d	Use CTest `--output-on-failure` flag	2025-04-26 10:37:44 -06:00
Chris Thrasher	ec571515c8	Don't fail CI fast	2025-04-26 10:37:36 -06:00
Chris Thrasher	edb6f80867	Export compile commands	2025-04-26 10:37:30 -06:00
Chris Thrasher	25b86ef3fd	Upgrade CI runners to Ubuntu 22	2025-04-25 23:14:06 -06:00
Martin Hořeňovský	4c8671cfbb	Add MAINTAINERS.md Closes #2970	2025-04-18 16:29:44 +02:00
Mark Jansen	5b3b228603	Update generator docs with relevant headers	2025-04-12 12:05:58 -06:00
Chris Thrasher	2b60af89e2	v3.8.1	2025-04-08 12:40:18 -06:00
abhishekbelgaonkar23	f51dc98dfc	Fix: Clang 19 -Wc++20-extensions warning (#2910 )	2025-04-07 15:45:34 -06:00
Chris Thrasher	76f70b1403	Fix bug where `catch_discover_tests` fails when no `TEST_CASE`s are present	2025-03-12 14:03:56 -06:00
Martin Hořeňovský	914aeecfe2	v3.8.0	2025-01-06 00:41:45 +01:00
Martin Hořeňovský	232e893785	Downgrade required CMake to 3.16 We still want to build VS 2017 through AppVeyor, and those images have CMake 3.16.2 installed. We could install newer CMake as part of the build, but since we don't use newer CMake features yet, this is simpler.	2025-01-05 23:45:00 +01:00
Michal Bukovský	6e9c34aa20	add meson option to not install library	2025-01-05 20:10:45 +01:00
Martin Hořeňovský	7d7b2f89f2	Support adding test tags as CTest labels in catch_discover_tests We also bump the minimum CMake version to 3.20 as per #2943	2025-01-05 20:02:00 +01:00
Martin Hořeňovský	b0d0aa43e6	Fix crash when stringifying pre 1970 dates on Windows `gmtime*` on Windows fails on dates pre 1970, and because we didn't check the return code, we would then pass invalid `tm` struct to `strftime` causing it to assert. Closes #2944	2025-01-05 16:04:38 +01:00
Martin Hořeňovský	a3b67a3abe	Migrate Bazel build to use Bzlmod	2025-01-05 16:03:22 +01:00
Holger Kaelberer	0321d2fce3	Catch.cmake: Remove redundant CTEST_FILE param	2024-11-22 11:05:50 +01:00
Thomas Braun	506276c592	Fix wrong reference to REGISTER_ENUM This was renamed to CATCH_REGISTER_ENUM in `541f1ed1` (Only provide CATCH_REGISTER_ENUM, 2019-04-21).	2024-11-12 23:29:54 +01:00
Martin Hořeňovský	f5cee49c71	Add test for iterators with const T as the value_type	2024-11-11 06:49:11 +01:00
Michal Bukovský	7bbd4b9075	Fix using from_range with std::vector<>::const_iterator	2024-11-09 18:46:07 +01:00
Martin Hořeňovský	119a7bbe53	Cleanup clang-tidy warning about enum sizes	2024-10-29 21:06:54 +01:00
Martin Hořeňovský	9c5a4cf44e	Enable CMake project folders for better target organization Closes #2917	2024-10-27 23:07:55 +01:00
Martin Hořeňovský	e260288807	Allow disabling use of __builtin_constant_p in internal macros Turns out that even in GCC, the expression in `__builtin_cosntant_p` can end up evaluated and side-effects executed. To allow users to work around this bug, I added a configuration option to disable its use in internal macros. Related to #2925	2024-10-27 20:27:03 +01:00
Martin Hořeňovský	7c2e1fb1b2	Update Intel Mac builds to macos-13 images for MacOS GitHub Actions macos-12 images will be removed on 3.12.2024, and macos-14 no longer support Intel-based MacOS in free (OSS) tier.	2024-10-26 16:55:15 +02:00
Pino Toscano	a6ee7e20cd	Use isatty() when using GNU libc While isatty() is a POSIX interface and theoretically could be used more broadly than on Linux and macOS, use a conservative approach and use it on any platform that uses GNU libc.	2024-10-19 20:36:19 +02:00
Sven Fischer	0b2af56271	Explicitly cast values of different types In case the warning -Werror=conversion is active with GCC, the warnings about "conversion from A to B may change value" lead to a compilation error. This explicitly convert the values to address these warnings.	2024-10-14 21:37:35 +02:00
Stefan Haller	69d62abc9a	Provide overloads for {Unordered}RangeEquals taking a std::initializer_list This allows writing something like const auto v = calculateSomeVectorOfInts(); CHECK_THAT(v, RangeEquals({1, 2, 3})); Fixes #2915.	2024-10-14 21:02:03 +02:00
Stefan Haller	1e0ccb1b21	Use default parameter for comparison instead of overloads in {Unordered}RangeEquals Saves some code duplication.	2024-10-14 21:02:03 +02:00
Stefan Haller	5ad66ada7b	Fix typos in comments	2024-10-14 21:02:03 +02:00
Martin Hořeňovský	fa43b77429	v3.7.1	2024-09-17 10:45:43 +02:00
Martin Hořeňovský	79f2d66ea3	Use SKIP_RETURN_CODE test property in catch_discover_tests I also added `SKIP_IS_FAILURE` option to the `catch_discover_tests` function, to allow users to get back the old behaviour. Closes #2873	2024-09-17 09:35:43 +02:00
Martin Hořeňovský	e200443b84	Fix compilation error from missing include in xmlwriter.hpp Fixes #2907	2024-09-15 22:17:39 +02:00
Martin Hořeňovský	ce22c0fe8a	Standardize exit codes for various failures The main reason for this is to be able to distinguish between different errors (or "errors") based on the return code. Before this change, it was impossible to use the exit code to figure out whether a test binary failed because all tests were skipped or because exactly 4 assertions have failed. This meant that using `catch_discover_tests` and telling it to check for exit code == 4 to determine skipped tests could lead to false negatives.	2024-09-13 21:33:45 +02:00
Martin Hořeňovský	18df97df00	Sprinkle some constexpr around to make Jason happy Most of these will not matter in practice due to C++14 imposing significant limitations on what else we can make constexpr, and we cannot have references outliving the constexpr context either way.	2024-09-13 16:40:11 +02:00
Martin Hořeňovský	e97ebe62e7	Remove superfluous include	2024-09-13 16:39:55 +02:00
Martin Hořeňovský	b2b7cbdc31	Remove pointless internal macro	2024-09-13 16:39:53 +02:00
Martin Hořeňovský	412cad546a	Avoid needless copy of string in runContext::handleMessage	2024-09-13 16:39:51 +02:00
Martin Hořeňovský	bd70515c08	Add the catch_config_prefix_messages.hpp to builds Closes #2903	2024-09-13 16:39:49 +02:00
Martin Hořeňovský	7a89b75737	Use steady_clock in the timer	2024-09-13 16:39:47 +02:00
Mark Jansen	02d3304782	Fix bug in TokenStream parser When presented with just '-' it would access the string at position [1]	2024-09-13 15:32:49 +02:00
Mark Jansen	77eca4e819	Simplify instructions by not changing directories for the ctest command	2024-09-13 14:45:04 +02:00
Kasper Laudrup	bc63412e2a	Suppress GCC useless-cast warning from CHECK_THROWS_MATCHES Suppress warning from GCC about useless cast in the CHECK_THROWS_MATCHES macro the same way it is already being done for the similar CHECK macros.	2024-09-06 16:04:35 +02:00
Martin Hořeňovský	fa306fc85e	Improve performance of SonarQube reporter handling passing assertions This mirrors the changes done to the JUnit reporter in commit `fe483c056d`	2024-08-14 12:33:55 +02:00
Martin Hořeňovský	35c3403fbb	Fix typo in release notes	2024-08-14 12:27:57 +02:00
Martin Hořeňovský	31588bb4f5	v3.7.0	2024-08-14 12:05:21 +02:00
Martin Hořeňovský	f24569a1b4	Large output redirect refactor This rework changes two important things 1) the output redirect is deactivated while control is given to the reporters. This means that combining reporters that write to stdout with capturing reporters, e.g. `./tests -s -r console -r junit::out=junit.xml`, no longer leads to the capturing reporter seeing all the output from the other reporter captured. Trying this with the `SelfTest` binary would previously lead to JUnit spending hours trying to escape all of ConsoleReporter's output and write it to the output file. I actually ended up killing the process after 3 hours, during which the JUnit reporter wrote something like 50 MBs of output to a file. 2) The redirect object's lifetime is tied to the `RunContext`, instead of being constructed for every partial test case run separately. This has no effect on the basic StreamRedirect, but improves the FileRedirect significantly. Previously, running many tests in single process with this redirect (e.g. running `SelfTest -r junit`) would cause later tests to always fail before starting, due to exceeding the limit of temporary files. For the current `SelfTest` binary, the old implementation would lead to 295 test failures from not being able to initiate the redirect. The new implementation completely eliminates them. ---- There is one downside to the new implementation of FileRedirect, specific to Linux. Running the `SelfTest` binary on Linux causes 3-4 tests to have no captured stdout/stderr, even though the tests were supposed to be writing there (there was no output to the actual stdout/stderr either, the output was just completely lost). Since this never happen for smaller test case sets, nor does it reproduce on other platforms, this implementation is still strictly better than the old one, and thus it can get reasonably merged.	2024-08-13 23:32:24 +02:00
Martin Hořeňovský	a579b5f640	Properly handle prepending user-specified paths to DYLD_FRAMEWORK_PATH	2024-08-13 23:05:21 +02:00
Chien-Yu Lin	1538be67cb	Respect path order of DL_PATHS in catch_discover_tests function	2024-08-13 22:23:16 +02:00
Omar Boukli-Hacene	9721048a32	Move header from internal Move `catch_case_sensitive.hpp` from directory `src/catch2/internal/internal` to be directly under `src/catch2/`. Header `catch_case_sensitive.hpp` defines `enum CaseSensitive` which is part of the public API, since it is exposed by the string matcher contracts. Fixes issue caught by Clang Tidy misc-include-cleaner check.	2024-08-13 19:51:00 +02:00
Martin Hořeňovský	aad0a3a8d6	Prune away g++-11 build from Mac	2024-08-13 19:36:19 +02:00
Martin Hořeňovský	008676a741	Use correct matcher name in the matcher example in assertion docs	2024-08-13 19:21:07 +02:00
Martin Hořeňovský	fe483c056d	Improve performance of JUnit reporter when handling passing assertions This is done by no longer requiring all assertions to be seen by the JUnit reporter. Since the JUnit reporter never outputs all assertions, even with `-s`, the only difference from storing passing assertions in the `CumulativeReporterBase` was some bookkeeping in deciding which sections are relevant to the output. Given `TEST_CASE` that just runs many passing assertions, e.g. ``` TEST_CASE( "PERFORMANCE_TEST_CASE", "[.]" ) { for (size_t i = 0; i < 1000'000'000; ++i) { REQUIRE( i == i ); } } ``` the new JUnit reporter will finish in 5:47, using up ~7.7 MB of RAM. The old JUnit reporter would finish in 0:30, due to bad_alloc after using up 14.5 GB of RAM (the system has 16 GB total). If the total number of assertions is lowered to 10M, the old implementation uses up ~7.1 GB of RAM and finishes in 12 minutes. The new implementation still needs only ~7.7 MB of RAM, and finishes in 4 minutes. There is a slight downside in that the output is slightly different; the new implementation will include the `TEST_CASE` level section in output, even if it does not have its own assertion. In other words, given a `TEST_CASE` like this ``` TEST_CASE( "JsonWriter", "[JSON][JsonWriter]" ) { std::stringstream stream; SECTION( "Newly constructed JsonWriter does nothing" ) { Catch::JsonValueWriter writer{ stream }; REQUIRE( stream.str() == "" ); } SECTION( "Calling writeObject will create an empty pair of braces" ) { { auto writer = Catch::JsonValueWriter{ stream }.writeObject(); } REQUIRE( stream.str() == "{\n}" ); } } ``` the new implementation will output 3 `testcase` tags, 2 for the explicit `SECTION`s with tests, and 1 for the top level section. However, this can be worked-around if required, and the performance improvement is such that it is worth changing the current output, even if it needs to be fixed in the future. Closes #2897	2024-08-13 19:13:03 +02:00
SirNate0	b15158c1db	Fix typo in test-cases-and-sections.md	2024-08-13 12:28:03 +02:00
Martin Hořeňovský	8898cc6160	Mark non-const function for TEST_CASE_METHOD as deprecated	2024-08-05 20:13:03 +02:00
Keith Stockdale	f7cd0ba051	TEST_CASE_PERSISTENT_FIXTURE: A new fixture macro for allowing persistent fixtures throughout a TEST_CASE (#2885 ) This PR introduces a new `TEST_CASE` macro called `TEST_CASE_PERSISTENT_FIXTURE`. `TEST_CASE_PERSISTENT_FIXTURE` offers the same functionality as `TEST_CASE_METHOD` except for one difference. The object on which the test method is invoked is only created once for all invocations of the test case. The object is created just after the `testCaseStarting` event is broadcast and the object is destroyed just before the `testCaseEnding` event is broadcast. The main motivation for this new functionality is to allow `TEST_CASE`s to do expensive setup and teardown once per `TEST_CASE`, without having to resort to abusing event listeners or static function variables with manual initialization. Implements #1602 --------- Co-authored-by: Martin Hořeňovský <martin.horenovsky@gmail.com>	2024-08-05 17:01:41 +02:00
Martin Hořeňovský	33e24b14fc	Add missing break to a switch to silence fall-through warning Closes #2891	2024-07-31 17:38:02 +02:00
Martin Hořeňovský	a40dd478f3	Update docs for REQUIRE_THROWS_MATCHES	2024-07-27 14:02:28 +02:00
Andy Phillips	85b7f3d6ab	Add optional argument to catch_discover_tests to set DYLD_FRAMEWORK_PATH (#2880 ) * Added optional argument to catch_discover_tests to set the DYLD_FRAMEWORK_PATH environment variable on Apple platforms.	2024-07-22 19:25:24 +02:00
Martin Hořeňovský	7af96bbb22	Slight improvement to computing clock resolution in benchmarking	2024-07-22 10:54:16 +02:00
Martin Hořeňovský	22e6490325	Remove copyability from BenchmarkFunction Technically we should be able to remove moveability as well, but then we would need a larger surgery. This already improves the compile times and binary sizes by a surprising amount.	2024-07-22 10:54:14 +02:00
Martin Hořeňovský	595bf9864e	Update to macos-12 GHA image Since the last time, macos-12 has fixed the toolchain's linker crash bug, so we can update here. macos-13 has a new and exciting bug when unwinding exceptions in binaries compiled with GCC, so we cannot update all the way at this time.	2024-07-22 10:47:25 +02:00
Vertexwahn	381f29e974	Bazel support: Update skylib version to 1.6.1	2024-07-22 10:21:44 +02:00
KStocky	37c8b2d2b3	Adding unapproved.txt files to gitignore	2024-07-19 22:21:09 +02:00
KStocky	292d64da32	Ignore all files with the name CMakeUserPresets.json	2024-07-19 22:08:57 +02:00