WIP: unreachable?

.bazelrc

@@ -1,6 +1,3 @@
-# Enable Bzlmod for every Bazel command
-common --enable_bzlmod
-
 build --enable_platform_specific_config
 
 build:gcc9 --cxxopt=-std=c++2a

.conan/test_package/CMakeLists.txt

@@ -1,7 +1,8 @@
-cmake_minimum_required(VERSION 3.16)
-project(PackageTest LANGUAGES CXX)
+cmake_minimum_required(VERSION 3.15)
+project(PackageTest 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)

.github/workflows/linux-bazel-builds.yml

@@ -1,4 +1,4 @@
-name: Linux Builds (Bazel)
+name: Bazel build
 
 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
-      run: bazelisk build --compilation_mode=${{matrix.compilation_mode}} //...
+    - name: Build Catch2
+      run: |
+        bazelisk build --compilation_mode=${{matrix.compilation_mode}} //...

.github/workflows/linux-meson-builds.yml

@@ -1,4 +1,4 @@
-name: Linux Builds (Meson)
+name: Linux builds (meson)
 
 on: [push, pull_request]
 
@@ -7,7 +7,6 @@ jobs:
     name: meson ${{matrix.cxx}}, C++${{matrix.std}}, ${{matrix.build_type}}
     runs-on: ubuntu-22.04
     strategy:
-      fail-fast: false
       matrix:
         cxx:
           - g++-11
@@ -26,7 +25,7 @@ jobs:
         sudo apt-get update
         sudo apt-get install -y meson ninja-build ${{matrix.other_pkgs}}
 
-    - name: Configure
+    - name: Configure build
       env:
         CXX: ${{matrix.cxx}}
         CXXFLAGS: -std=c++${{matrix.std}} ${{matrix.cxxflags}}
@@ -35,10 +34,11 @@ jobs:
       run: |
         meson -Dbuildtype=${{matrix.build_type}} ${{runner.workspace}}/meson-build
 
-    - name: Build
+    - name: Build tests + lib
       working-directory: ${{runner.workspace}}/meson-build
       run: ninja
 
-    - name: Test
+    - name: Run tests
       working-directory: ${{runner.workspace}}/meson-build
-      run: meson test --verbose
+      run: |
+        meson test --verbose

.github/workflows/linux-other-builds.yml

@@ -1,73 +1,72 @@
 # 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-22.04
+    runs-on: ubuntu-20.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++-14
+          - cxx: clang++-10
             build_description: Surrogates build
             build_type: Debug
             std: 14
-            other_pkgs: clang-14
+            other_pkgs: clang-10
             cmake_configurations: -DCATCH_BUILD_SURROGATES=ON
 
-          # Extras and examples with gcc-11
-          - cxx: g++-11
+          # Extras and examples with gcc-7
+          - cxx: g++-7
             build_description: Extras + Examples
             build_type: Debug
             std: 14
-            other_pkgs: g++-11
+            other_pkgs: g++-7
             cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON
-          - cxx: g++-11
+          - cxx: g++-7
             build_description: Extras + Examples
             build_type: Release
             std: 14
-            other_pkgs: g++-11
+            other_pkgs: g++-7
             cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON
 
-          # Extras and examples with Clang-14
-          - cxx: clang++-14
+          # Extras and examples with Clang-10
+          - cxx: clang++-10
             build_description: Extras + Examples
             build_type: Debug
             std: 17
-            other_pkgs: clang-14
+            other_pkgs: clang-10
             cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON
-          - cxx: clang++-14
+          - cxx: clang++-10
             build_description: Extras + Examples
             build_type: Release
             std: 17
-            other_pkgs: clang-14
+            other_pkgs: clang-10
             cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON
 
-          # Configure tests with Clang-14
-          - cxx: clang++-14
+          # Configure tests with Clang-10
+          - cxx: clang++-10
             build_description: CMake configuration tests
             build_type: Debug
             std: 14
-            other_pkgs: clang-14
+            other_pkgs: clang-10
             cmake_configurations: -DCATCH_ENABLE_CONFIGURE_TESTS=ON
 
-          # 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
+          # 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
 
 
     steps:
@@ -79,51 +78,77 @@ 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 --preset basic-tests -GNinja \
+        cmake -Bbuild -H$GITHUB_WORKSPACE \
               -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
-              -DCMAKE_CXX_COMPILER=${{matrix.cxx}} \
               -DCMAKE_CXX_STANDARD=${{matrix.std}} \
-              ${{matrix.cmake_configurations}}
+              -DCMAKE_CXX_STANDARD_REQUIRED=ON \
+              -DCMAKE_CXX_EXTENSIONS=OFF \
+              -DCATCH_DEVELOPMENT_BUILD=ON \
+              ${{matrix.cmake_configurations}} \
+              -G Ninja
 
-    - name: Build
-      run: cmake --build build
-
-    - name: Test
-      run: ctest --test-dir build -j --output-on-failure
+    - name: Build tests + lib
+      working-directory: ${{runner.workspace}}/build
+      run: ninja
 
+    - 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
+    name: clang-tidy ${{matrix.version}}, ${{matrix.build_description}}, C++${{matrix.std}} ${{matrix.build_type}}
     runs-on: ubuntu-22.04
+    strategy:
+      matrix:
+        include:
+          - version: "15"
+            build_description: all
+            build_type: Debug
+            std: 17
+            other_pkgs: ''
+            cmake_configurations: -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON
     steps:
     - uses: actions/checkout@v4
 
     - name: Prepare environment
       run: |
         sudo apt-get update
-        sudo apt-get install -y ninja-build clang-15 clang-tidy-15
+        sudo apt-get install -y ninja-build clang-${{matrix.version}} clang-tidy-${{matrix.version}} ${{matrix.other_pkgs}}
 
-    - name: Configure
+    - name: Configure build
+      working-directory: ${{runner.workspace}}
+      env:
+        CXX: clang++-${{matrix.version}}
+        CXXFLAGS: ${{matrix.cxxflags}}
       # Note: $GITHUB_WORKSPACE is distinct from ${{runner.workspace}}.
       #       This is important
       run: |
-        clangtidy="clang-tidy-15;-use-color"
+        clangtidy="clang-tidy-${{matrix.version}};-use-color"
         # Use a dummy compiler/linker/ar/ranlib to effectively disable the
         # compilation and only run clang-tidy.
-        cmake --preset basic-tests -GNinja \
-              -DCMAKE_AR=/usr/bin/true \
-              -DCMAKE_BUILD_TYPE=Debug \
+        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_AR=/usr/bin/true \
               -DCMAKE_CXX_COMPILER_LAUNCHER=/usr/bin/true \
-              -DCMAKE_CXX_COMPILER=clang++-15 \
-              -DCMAKE_CXX_LINK_EXECUTABLE=/usr/bin/true \
-              -DCMAKE_CXX_STANDARD=17 \
+              -DCMAKE_AR=/usr/bin/true \
+              -DCMAKE_CXX_COMPILER_AR=/usr/bin/true \
               -DCMAKE_RANLIB=/usr/bin/true \
-              -DCATCH_BUILD_EXAMPLES=ON \
-              -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON
+              -DCMAKE_CXX_LINK_EXECUTABLE=/usr/bin/true \
+              ${{matrix.cmake_configurations}} \
+              -G Ninja
 
     - name: Run clang-tidy
-      run: cmake --build build
+      working-directory: ${{runner.workspace}}/build
+      run: ninja

.github/workflows/linux-simple-builds.yml

@@ -1,33 +1,32 @@
-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-22.04
+    runs-on: ubuntu-20.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
@@ -36,10 +35,6 @@ 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
@@ -50,64 +45,79 @@ jobs:
             other_pkgs: clang-9
           - cxx: clang++-10
             other_pkgs: 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
+          # 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
             build_type: Debug
             std: 17
-            other_pkgs: clang-14
-          - cxx: clang++-14
+            other_pkgs: clang-10
+          - cxx: clang++-10
             build_type: Release
             std: 17
-            other_pkgs: clang-14
-          - cxx: clang++-14
+            other_pkgs: clang-10
+          - cxx: clang++-10
             build_type: Debug
             std: 20
-            other_pkgs: clang-14
-          - cxx: clang++-14
+            other_pkgs: clang-10
+          - cxx: clang++-10
             build_type: Release
             std: 20
-            other_pkgs: clang-14
-          - cxx: g++-11
+            other_pkgs: clang-10
+          - cxx: g++-10
             build_type: Debug
             std: 20
-            other_pkgs: g++-11
-          - cxx: g++-11
+            other_pkgs: g++-10
+          - cxx: g++-10
             build_type: Release
             std: 20
-            other_pkgs: g++-11
+            other_pkgs: g++-10
 
     steps:
     - uses: actions/checkout@v4
 
-    - name: Add repositories for older compilers
+    - name: Add repositories for older GCC
       run: |
-        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'
+        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' }}
 
     - name: Prepare environment
       run: |
         sudo apt-get update
         sudo apt-get install -y ninja-build ${{matrix.other_pkgs}}
 
-    - name: Configure
+    - 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 --preset basic-tests -GNinja \
+        cmake -Bbuild -H$GITHUB_WORKSPACE \
               -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
-              -DCMAKE_CXX_COMPILER=${{matrix.cxx}} \
-              -DCMAKE_CXX_STANDARD=${{matrix.std}}
+              -DCMAKE_CXX_STANDARD=${{matrix.std}} \
+              -DCMAKE_CXX_STANDARD_REQUIRED=ON \
+              -DCMAKE_CXX_EXTENSIONS=OFF \
+              -DCATCH_DEVELOPMENT_BUILD=ON \
+              -G Ninja
 
-    - name: Build
-      run: cmake --build build
+    - name: Build tests + lib
+      working-directory: ${{runner.workspace}}/build
+      run: ninja
 
-    - 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`

.github/workflows/mac-builds-m1.yml

@@ -0,0 +1,44 @@
+name: Arm 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`

.github/workflows/mac-builds.yml

@@ -1,32 +1,48 @@
-name: Mac Builds
+name: Intel Mac builds
 
 on: [push, pull_request]
 
 jobs:
   build:
     # From macos-14 forward, the baseline "macos-X" image is Arm based,
-    # and not Intel based.
-    runs-on: ${{matrix.image}}
+    # and not Intel based. Thus this is the newest image we can use for
+    # Intel MacOS CI, and there don't seem to be any plans to keep providing
+    # the Intel based images for free to OSS projects.
+    runs-on: macos-13
     strategy:
-      fail-fast: false
       matrix:
-        image: [macos-13, macos-14, macos-15]
+        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
+    - name: Configure build
+      working-directory: ${{runner.workspace}}
+      env:
+        CXX: ${{matrix.cxx}}
+        CXXFLAGS: ${{matrix.cxxflags}}
       run: |
-        cmake --preset basic-tests -GNinja \
+        cmake -Bbuild -H$GITHUB_WORKSPACE \
               -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
               -DCMAKE_CXX_STANDARD=${{matrix.std}} \
-              -DCATCH_BUILD_EXAMPLES=ON \
-              -DCATCH_BUILD_EXTRA_TESTS=ON
+              -DCMAKE_CXX_STANDARD_REQUIRED=ON \
+              -DCATCH_DEVELOPMENT_BUILD=ON \
+              -DCATCH_BUILD_EXAMPLES=${{matrix.examples}} \
+              -DCATCH_BUILD_EXTRA_TESTS=${{matrix.examples}}
 
-    - name: Build
-      run: cmake --build build
+    - name: Build tests + lib
+      working-directory: ${{runner.workspace}}/build
+      run: make -j `sysctl -n hw.ncpu`
 
-    - 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 `sysctl -n hw.ncpu`

.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-22.04
+    runs-on: ubuntu-20.04
     strategy:
       matrix:
         conan_version:

.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-22.04
+    runs-on: ubuntu-20.04
     steps:
 
       - name: Checkout source code

.github/workflows/windows-simple-builds.yml

@@ -1,4 +1,4 @@
-name: Windows Builds (Basic)
+name: Windows builds (basic)
 
 on: [push, pull_request]
 
@@ -7,9 +7,8 @@ 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, windows-2025]
+        os: [windows-2019, windows-2022]
         platform: [Win32, x64]
         build_type: [Debug, Release]
         std: [14, 17]
@@ -17,15 +16,22 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: Configure build
+        working-directory: ${{runner.workspace}}
         run: |
-          cmake --preset all-tests `
-                -A ${{matrix.platform}} `
-                -DCMAKE_CXX_STANDARD=${{matrix.std}} `
+          cmake -S $Env:GITHUB_WORKSPACE               `
+                -B ${{runner.workspace}}/build         `
+                -DCMAKE_CXX_STANDARD=${{matrix.std}}   `
+                -A ${{matrix.platform}}                `
+                --preset all-tests
 
       - name: Build tests
+        working-directory: ${{runner.workspace}}
         run: cmake --build build --config ${{matrix.build_type}} --parallel %NUMBER_OF_PROCESSORS%
         shell: cmd
 
       - name: Run tests
-        run: ctest --test-dir build -C ${{matrix.build_type}} -j %NUMBER_OF_PROCESSORS% --output-on-failure
+        working-directory: ${{runner.workspace}}/build
+        env:
+            CTEST_OUTPUT_ON_FAILURE: 1
+        run: ctest -C ${{matrix.build_type}} -j %NUMBER_OF_PROCESSORS%
         shell: cmd

BUILD.bazel

@@ -68,7 +68,7 @@ expand_template(
 cc_library(
     name = "catch2_generated",
     hdrs = ["catch2/catch_user_config.hpp"],
-    include_prefix = ".",  # to manipulate -I of dependencies
+    include_prefix = ".",  # to manipulate -I of dependenices
     visibility = ["//visibility:public"],
 )
 

CMake/Catch2Config.cmake.in

@@ -1,9 +1,10 @@
 @PACKAGE_INIT@
 
+
 # Avoid repeatedly including the targets
 if(NOT TARGET Catch2::Catch2)
-  # Provide path for scripts
-  list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}")
+    # Provide path for scripts
+    list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}")
 
-  include(${CMAKE_CURRENT_LIST_DIR}/Catch2Targets.cmake)
+    include(${CMAKE_CURRENT_LIST_DIR}/Catch2Targets.cmake)
 endif()

CMake/CatchConfigOptions.cmake

@@ -14,6 +14,7 @@
 #
 # 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)
@@ -73,9 +74,9 @@ foreach(OptionName ${_OtherConfigOptions})
   AddConfigOption(${OptionName})
 endforeach()
 if(DEFINED BUILD_SHARED_LIBS)
-  set(CATCH_CONFIG_SHARED_LIBRARY ${BUILD_SHARED_LIBS})
+    set(CATCH_CONFIG_SHARED_LIBRARY ${BUILD_SHARED_LIBS})
 else()
-  set(CATCH_CONFIG_SHARED_LIBRARY "")
+    set(CATCH_CONFIG_SHARED_LIBRARY "")
 endif()
 
 set(CATCH_CONFIG_DEFAULT_REPORTER "console" CACHE STRING "Read docs/configuration.md for details. The name of the reporter should be without quotes.")

CMake/CatchMiscFunctions.cmake

@@ -8,107 +8,108 @@
 
 include(CheckCXXCompilerFlag)
 function(add_cxx_flag_if_supported_to_targets flagname targets)
-  string(MAKE_C_IDENTIFIER ${flagname} flag_identifier)
-  check_cxx_compiler_flag("${flagname}" HAVE_FLAG_${flag_identifier})
+    string(MAKE_C_IDENTIFIER ${flagname} flag_identifier )
+    check_cxx_compiler_flag("${flagname}" HAVE_FLAG_${flag_identifier})
 
-  if(HAVE_FLAG_${flag_identifier})
-    foreach(target ${targets})
-      target_compile_options(${target} PRIVATE ${flagname})
-    endforeach()
-  endif()
+    if (HAVE_FLAG_${flag_identifier})
+        foreach(target ${targets})
+            target_compile_options(${target} PRIVATE ${flagname})
+        endforeach()
+    endif()
 endfunction()
 
 # Assumes that it is only called for development builds, where warnings
 # and Werror is desired, so it also enables Werror.
 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)
-    foreach(target ${targets})
-      # Force MSVC to consider everything as encoded in utf-8
-      target_compile_options(${target} PRIVATE /utf-8)
-      # Enable Werror equivalent
-      if(CATCH_ENABLE_WERROR)
-        target_compile_options(${target} PRIVATE /WX)
-      endif()
+    LIST(LENGTH targets TARGETS_LEN)
+    # For now we just assume 2 possibilities: msvc and msvc-like compilers,
+    # and other.
+    if (MSVC)
+        foreach(target ${targets})
+            # Force MSVC to consider everything as encoded in utf-8
+            target_compile_options( ${target} PRIVATE /utf-8 )
+            # Enable Werror equivalent
+            if (CATCH_ENABLE_WERROR)
+                target_compile_options( ${target} PRIVATE /WX )
+            endif()
 
-      # MSVC is currently handled specially
-      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)
-      endif()
-    endforeach()
-  endif()
+            # MSVC is currently handled specially
+            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 )
+            endif()
+        endforeach()
 
-  if(NOT MSVC)
-    set(CHECKED_WARNING_FLAGS
-      "-Wabsolute-value"
-      "-Wall"
-      "-Wcall-to-pure-virtual-from-ctor-dtor"
-      "-Wcast-align"
-      "-Wcatch-value"
-      "-Wdangling"
-      "-Wdeprecated"
-      "-Wdeprecated-register"
-      "-Wexceptions"
-      "-Wexit-time-destructors"
-      "-Wextra"
-      "-Wextra-semi"
-      "-Wfloat-equal"
-      "-Wglobal-constructors"
-      "-Winit-self"
-      "-Wmisleading-indentation"
-      "-Wmismatched-new-delete"
-      "-Wmismatched-return-types"
-      "-Wmismatched-tags"
-      "-Wmissing-braces"
-      "-Wmissing-declarations"
-      "-Wmissing-noreturn"
-      "-Wmissing-prototypes"
-      "-Wmissing-variable-declarations"
-      "-Wnon-virtual-dtor"
-      "-Wnull-dereference"
-      "-Wold-style-cast"
-      "-Woverloaded-virtual"
-      "-Wparentheses"
-      "-Wpedantic"
-      "-Wredundant-decls"
-      "-Wreorder"
-      "-Wreturn-std-move"
-      "-Wshadow"
-      "-Wstrict-aliasing"
-      "-Wsubobject-linkage"
-      "-Wsuggest-destructor-override"
-      "-Wsuggest-override"
-      "-Wundef"
-      "-Wuninitialized"
-      "-Wunneeded-internal-declaration"
-      "-Wunreachable-code-aggressive"
-      "-Wunused"
-      "-Wunused-function"
-      "-Wunused-parameter"
-      "-Wvla"
-      "-Wweak-vtables"
-
-      # This is a useful warning, but our tests sometimes rely on
-      # functions being present, but not picked (e.g. various checks
-      # for stringification implementation ordering).
-      # Ergo, we should use it every now and then, but we cannot
-      # enable it by default.
-      # "-Wunused-member-function"
-    )
-    foreach(warning ${CHECKED_WARNING_FLAGS})
-      add_cxx_flag_if_supported_to_targets(${warning} "${targets}")
-    endforeach()
-
-    if(CATCH_ENABLE_WERROR)
-      foreach(target ${targets})
-        # Enable Werror equivalent
-        target_compile_options(${target} PRIVATE -Werror)
-      endforeach()
     endif()
-  endif()
+
+    if (NOT MSVC)
+        set(CHECKED_WARNING_FLAGS
+          "-Wabsolute-value"
+          "-Wall"
+          "-Wcall-to-pure-virtual-from-ctor-dtor"
+          "-Wcast-align"
+          "-Wcatch-value"
+          "-Wdangling"
+          "-Wdeprecated"
+          "-Wdeprecated-register"
+          "-Wexceptions"
+          "-Wexit-time-destructors"
+          "-Wextra"
+          "-Wextra-semi"
+          "-Wfloat-equal"
+          "-Wglobal-constructors"
+          "-Winit-self"
+          "-Wmisleading-indentation"
+          "-Wmismatched-new-delete"
+          "-Wmismatched-return-types"
+          "-Wmismatched-tags"
+          "-Wmissing-braces"
+          "-Wmissing-declarations"
+          "-Wmissing-noreturn"
+          "-Wmissing-prototypes"
+          "-Wmissing-variable-declarations"
+          "-Wnon-virtual-dtor"
+          "-Wnull-dereference"
+          "-Wold-style-cast"
+          "-Woverloaded-virtual"
+          "-Wparentheses"
+          "-Wpedantic"
+          "-Wredundant-decls"
+          "-Wreorder"
+          "-Wreturn-std-move"
+          "-Wshadow"
+          "-Wstrict-aliasing"
+          "-Wsubobject-linkage"
+          "-Wsuggest-destructor-override"
+          "-Wsuggest-override"
+          "-Wundef"
+          "-Wuninitialized"
+          "-Wunneeded-internal-declaration"
+          "-Wunreachable-code-aggressive"
+          "-Wunused"
+          "-Wunused-function"
+          "-Wunused-parameter"
+          "-Wvla"
+          "-Wweak-vtables"
+
+          # This is a useful warning, but our tests sometimes rely on
+          # functions being present, but not picked (e.g. various checks
+          # for stringification implementation ordering).
+          # Ergo, we should use it every now and then, but we cannot
+          # enable it by default.
+          # "-Wunused-member-function"
+        )
+        foreach(warning ${CHECKED_WARNING_FLAGS})
+            add_cxx_flag_if_supported_to_targets(${warning} "${targets}")
+        endforeach()
+
+        if (CATCH_ENABLE_WERROR)
+            foreach(target ${targets})
+                # Enable Werror equivalent
+                target_compile_options( ${target} PRIVATE -Werror )
+            endforeach()
+        endif()
+    endif()
 endfunction()
 
 # Adds flags required for reproducible build to the target

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required(VERSION 3.10)
 
 # detect if Catch is being bundled,
 # disable testsuite in that case
@@ -26,17 +26,20 @@ 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)
-  message(FATAL_ERROR "Building in-source is not supported! Create a build dir and remove ${CMAKE_SOURCE_DIR}/CMakeCache.txt")
+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.8.1 # CML version placeholder, don't delete
+  VERSION 3.7.1 # CML version placeholder, don't delete
   LANGUAGES CXX
-  HOMEPAGE_URL "https://github.com/catchorg/Catch2"
+  # HOMEPAGE_URL is not supported until CMake version 3.12, which
+  # we do not target yet.
+  # HOMEPAGE_URL "https://github.com/catchorg/Catch2"
   DESCRIPTION "A modern, C++-native, unit test framework."
 )
 
@@ -45,7 +48,7 @@ project(Catch2
 # 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")
@@ -66,9 +69,10 @@ set(CATCH_CMAKE_CONFIG_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/Catch2")
 # are built during these tests, so this is required here, before
 # the subdirectories are added.
 if(CATCH_TEST_USE_WMAIN)
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /ENTRY:wmainCRTStartup")
+    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)
@@ -78,117 +82,125 @@ 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)
-  find_package(PythonInterp 3 REQUIRED)
-  if(NOT PYTHONINTERP_FOUND)
-    message(FATAL_ERROR "Python not found, but required for tests")
-  endif()
-  set(CMAKE_FOLDER "tests")
-  add_subdirectory(tests)
+if (BUILD_TESTING AND CATCH_BUILD_TESTING AND NOT_SUBPROJECT)
+    find_package(PythonInterp 3 REQUIRED)
+    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)
+    set(CMAKE_FOLDER "Examples")
+    add_subdirectory(examples)
 endif()
 
 if(CATCH_BUILD_EXTRA_TESTS)
-  set(CMAKE_FOLDER "tests/ExtraTests")
-  add_subdirectory(tests/ExtraTests)
+    set(CMAKE_FOLDER "tests/ExtraTests")
+    add_subdirectory(tests/ExtraTests)
 endif()
 
 if(CATCH_BUILD_FUZZERS)
-  set(CMAKE_FOLDER "fuzzing")
-  add_subdirectory(fuzzing)
+    set(CMAKE_FOLDER "fuzzing")
+    add_subdirectory(fuzzing)
 endif()
 
-if(CATCH_DEVELOPMENT_BUILD)
-  add_warnings_to_targets("${CATCH_WARNING_TARGETS}")
+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)
-  configure_package_config_file(
-    ${CMAKE_CURRENT_LIST_DIR}/CMake/Catch2Config.cmake.in
-    ${CMAKE_CURRENT_BINARY_DIR}/Catch2Config.cmake
-    INSTALL_DESTINATION
-      ${CATCH_CMAKE_CONFIG_DESTINATION}
-  )
-
-  write_basic_package_version_file(
-    "${CMAKE_CURRENT_BINARY_DIR}/Catch2ConfigVersion.cmake"
-    COMPATIBILITY
-      SameMajorVersion
-  )
-
-  install(
-    FILES
-      "${CMAKE_CURRENT_BINARY_DIR}/Catch2Config.cmake"
-      "${CMAKE_CURRENT_BINARY_DIR}/Catch2ConfigVersion.cmake"
-    DESTINATION
-      ${CATCH_CMAKE_CONFIG_DESTINATION}
-  )
-
-  # Install documentation
-  if(CATCH_INSTALL_DOCS)
-    install(
-      DIRECTORY
-        docs/
-      DESTINATION
-        "${CMAKE_INSTALL_DOCDIR}"
-      PATTERN "doxygen" EXCLUDE
+if (NOT_SUBPROJECT)
+    configure_package_config_file(
+        ${CMAKE_CURRENT_LIST_DIR}/CMake/Catch2Config.cmake.in
+        ${CMAKE_CURRENT_BINARY_DIR}/Catch2Config.cmake
+        INSTALL_DESTINATION
+          ${CATCH_CMAKE_CONFIG_DESTINATION}
+    )
+
+    write_basic_package_version_file(
+      "${CMAKE_CURRENT_BINARY_DIR}/Catch2ConfigVersion.cmake"
+      COMPATIBILITY
+        SameMajorVersion
     )
-  endif()
 
-  if(CATCH_INSTALL_EXTRAS)
-    # Install CMake scripts
     install(
       FILES
-        "extras/ParseAndAddCatchTests.cmake"
-        "extras/Catch.cmake"
-        "extras/CatchAddTests.cmake"
-        "extras/CatchShardTests.cmake"
-        "extras/CatchShardTestsImpl.cmake"
+        "${CMAKE_CURRENT_BINARY_DIR}/Catch2Config.cmake"
+        "${CMAKE_CURRENT_BINARY_DIR}/Catch2ConfigVersion.cmake"
       DESTINATION
         ${CATCH_CMAKE_CONFIG_DESTINATION}
     )
 
-    # Install debugger helpers
+    # Install documentation
+    if(CATCH_INSTALL_DOCS)
+      install(
+        DIRECTORY
+          docs/
+        DESTINATION
+          "${CMAKE_INSTALL_DOCDIR}"
+        PATTERN "doxygen" EXCLUDE
+      )
+    endif()
+
+    if(CATCH_INSTALL_EXTRAS)
+        # Install CMake scripts
+        install(
+          FILES
+            "extras/ParseAndAddCatchTests.cmake"
+            "extras/Catch.cmake"
+            "extras/CatchAddTests.cmake"
+            "extras/CatchShardTests.cmake"
+            "extras/CatchShardTestsImpl.cmake"
+          DESTINATION
+            ${CATCH_CMAKE_CONFIG_DESTINATION}
+        )
+    
+        # Install debugger helpers
+        install(
+          FILES
+            "extras/gdbinit"
+            "extras/lldbinit"
+          DESTINATION
+            ${CMAKE_INSTALL_DATAROOTDIR}/Catch2
+        )
+    endif()
+
+    ## Provide some pkg-config integration
+    set(PKGCONFIG_INSTALL_DIR
+        "${CMAKE_INSTALL_DATAROOTDIR}/pkgconfig"
+        CACHE PATH "Path where catch2.pc is installed"
+    )
+    configure_file(
+      ${CMAKE_CURRENT_SOURCE_DIR}/CMake/catch2.pc.in
+      ${CMAKE_CURRENT_BINARY_DIR}/catch2.pc
+      @ONLY
+    )
+    configure_file(
+      ${CMAKE_CURRENT_SOURCE_DIR}/CMake/catch2-with-main.pc.in
+      ${CMAKE_CURRENT_BINARY_DIR}/catch2-with-main.pc
+      @ONLY
+    )
     install(
       FILES
-        "extras/gdbinit"
-        "extras/lldbinit"
+        "${CMAKE_CURRENT_BINARY_DIR}/catch2.pc"
+        "${CMAKE_CURRENT_BINARY_DIR}/catch2-with-main.pc"
       DESTINATION
-        ${CMAKE_INSTALL_DATAROOTDIR}/Catch2
+        ${PKGCONFIG_INSTALL_DIR}
     )
-  endif()
 
-  ## Provide some pkg-config integration
-  set(PKGCONFIG_INSTALL_DIR
-    "${CMAKE_INSTALL_DATAROOTDIR}/pkgconfig"
-    CACHE PATH "Path where catch2.pc is installed"
-  )
-  configure_file(
-    ${CMAKE_CURRENT_SOURCE_DIR}/CMake/catch2.pc.in
-    ${CMAKE_CURRENT_BINARY_DIR}/catch2.pc
-    @ONLY
-  )
-  configure_file(
-    ${CMAKE_CURRENT_SOURCE_DIR}/CMake/catch2-with-main.pc.in
-    ${CMAKE_CURRENT_BINARY_DIR}/catch2-with-main.pc
-    @ONLY
-  )
-  install(
-    FILES
-      "${CMAKE_CURRENT_BINARY_DIR}/catch2.pc"
-      "${CMAKE_CURRENT_BINARY_DIR}/catch2-with-main.pc"
-    DESTINATION
-      ${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/")
+    set(CPACK_PACKAGE_CONTACT "https://github.com/catchorg/Catch2/")
+
+
+    include( CPack )
 
-  include(CPack)
 endif()

CMakePresets.json

@@ -3,14 +3,9 @@
     "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"
             }
         },

MAINTAINERS.md

@@ -1,11 +0,0 @@
-<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))

MODULE.bazel

@@ -1,4 +1,3 @@
 module(name = "catch2")
 
 bazel_dep(name = "bazel_skylib", version = "1.7.1")
-bazel_dep(name = "rules_cc", version = "0.0.17")

WORKSPACE.bazel

@@ -0,0 +1,16 @@
+workspace(name = "catch2")
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+http_archive(
+    name = "bazel_skylib",
+    sha256 = "bc283cdfcd526a52c3201279cda4bc298652efa898b10b4db0837dc51652756f",
+    urls = [
+        "https://mirror.bazel.build/github.com/bazelbuild/bazel-skylib/releases/download/1.7.1/bazel-skylib-1.7.1.tar.gz",
+        "https://github.com/bazelbuild/bazel-skylib/releases/download/1.7.1/bazel-skylib-1.7.1.tar.gz",
+    ],
+)
+
+load("@bazel_skylib//:workspace.bzl", "bazel_skylib_workspace")
+
+bazel_skylib_workspace()

docs/cmake-integration.md

@@ -81,11 +81,12 @@ to your CMake module path.
 
 `Catch.cmake` provides function `catch_discover_tests` to get tests from
 a target. This function works by running the resulting executable with
-`--list-test` flag, and then parsing the output to find all existing tests.
+`--list-test-names-only` flag, and then parsing the output to find all
+existing tests.
 
 #### Usage
 ```cmake
-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required(VERSION 3.5)
 
 project(baz LANGUAGES CXX VERSION 0.0.1)
 
@@ -127,8 +128,6 @@ catch_discover_tests(target
                      [OUTPUT_PREFIX prefix]
                      [OUTPUT_SUFFIX suffix]
                      [DISCOVERY_MODE <POST_BUILD|PRE_TEST>]
-                     [SKIP_IS_FAILURE]
-                     [ADD_TAGS_AS_LABELS]
 )
 ```
 
@@ -212,15 +211,6 @@ execution (useful e.g. in cross-compilation environments).
 calling ``catch_discover_tests``. This provides a mechanism for globally
 selecting a preferred test discovery behavior.
 
-* `SKIP_IS_FAILURE`
-
-Skipped tests will be marked as failed instead.
-
-* `ADD_TAGS_AS_LABELS`
-
-Add the tags from tests as labels to CTest.
-
-
 ### `ParseAndAddCatchTests.cmake`
 
 ⚠ This script is [deprecated](https://github.com/catchorg/Catch2/pull/2120)
@@ -239,7 +229,7 @@ parsed are *silently ignored*.
 #### Usage
 
 ```cmake
-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required(VERSION 3.5)
 
 project(baz LANGUAGES CXX VERSION 0.0.1)
 

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 precedence over simple concatenation. This means
+    Note that commas take precendence 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]".
 

docs/generators.md

@@ -21,10 +21,7 @@ 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. 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>`.
+below, the test case will be run 6 (2\*3) times.
 
 ```cpp
 TEST_CASE("Generators") {
@@ -106,7 +103,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 (defined in `catch2/generators/catch_generators_adapters.hpp`)
+* 5 generic generators that modify other generators
   * `FilterGenerator<T, Predicate>` -- filters out elements from a generator
   for which the predicate returns "false"
   * `TakeGenerator<T>` -- takes first `n` elements from a generator
@@ -114,11 +111,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 (defined in `catch2/generators/catch_generators_random.hpp`)
+* 4 specific purpose generators
   * `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 (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`)
+  * `RangeGenerator<T>(first, last)` -- generates all values inside a `[first, last)` arithmetic range
+  * `IteratorGenerator<T>` -- copies and returns values from an iterator range
 
 > `ChunkGenerator<T>`, `RandomIntegerGenerator<Integral>`, `RandomFloatGenerator<Float>` and `RangeGenerator<T>` were introduced in Catch2 2.7.0.
 
@@ -219,8 +216,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 targeting the x87 FPU and another
-one targeting SSE2 for floating point math, their results will vary.
+same way, e.g. if you compile a binary targetting the x87 FPU and another
+one targetting SSE2 for floating point math, their results will vary.
 Similarly, binaries compiled with compiler flags that relax the IEEE-754
 adherence, e.g. `-ffast-math`, might provide different results than those
 compiled for strict IEEE-754 adherence.

docs/release-notes.md

@@ -2,8 +2,6 @@
 
 # Release notes
 **Contents**<br>
-[3.8.1](#381)<br>
-[3.8.0](#380)<br>
 [3.7.1](#371)<br>
 [3.7.0](#370)<br>
 [3.6.0](#360)<br>
@@ -67,38 +65,6 @@
 [Even Older versions](#even-older-versions)<br>
 
 
-## 3.8.1
-
-### Fixes
-* Fixed bug where catch_discover_tests fails when no TEST_CASEs are present (#2962)
-* Fixed Clang 19 -Wc++20-extensions warning (#2968)
-
-
-## 3.8.0
-
-### Improvements
-* Added `std::initializer_list` overloads for `(Unordered)RangeEquals` matcher (#2915, #2919)
-* Added explicit casts to silence GCC's `Wconversion` (#2875)
-* Made the use of `builtin_constant_p` tricks in assertion macros configurable (#2925)
-  * It is used to prod GCC-like compilers into providing warnings for the asserted expressions, but the compilers miscompile it annoyingly often.
-* Cleaned out Clang-Tidy's `performance-enum-size` warnings
-* Added support for using `from_range` generator with iterators with `value_type = const T` (#2926)
-  * This is not correct `value_type` typedef, but it is used in the wild and the change does not make the code meaningfully worse.
-
-### Fixes
-* Fixed crash when stringifying pre-1970 (epoch) dates on Windows (#2944)
-
-### Miscellaneous
-* Fixes and improvements for `catch_discover_tests` CMake helper
-  * Removed redundant `CTEST_FILE` param when creating the indirection file for `PRE_TEST` discovery mode (#2936)
-  * Rewrote the test discovery logic to use output from the JSON reporter
-    * This means that `catch_discover_tests` now requires CMake 3.19 or newer
-  * Added `ADD_TAGS_AS_LABELS` option. If specified, each CTest test will be labeled with 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
@@ -175,7 +141,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 targeting newest MacOS (Sonoma) using GCC (#2837, #2839)
+* Added workaround for targetting newest MacOS (Sonoma) using GCC (#2837, #2839)
 * `CATCH_CONFIG_DEFAULT_REPORTER` can now be an arbitrary reporter spec
   * Previously it could only be a plain reporter name, so it was impossible to compile in custom arguments to the reporter.
 * Improved performance of generating 64bit random integers by 20+%

docs/test-fixtures.md

@@ -130,7 +130,7 @@ TEST_CASE_PERSISTENT_FIXTURE( MyFixture, "Tests with MyFixture" ) {
 }
 ```
 
-This example demonstrates two possible use-cases of this fixture type:
+This example demonstates two possible use-cases of this fixture type:
 1. Improve test run times by reducing the amount of expensive and 
 redundant setup and tear-down required.
 2. Reusing results from the previous partial run, in the current

examples/CMakeLists.txt

@@ -1,47 +1,50 @@
-cmake_minimum_required(VERSION 3.16)
-project(Catch2Examples LANGUAGES CXX)
+cmake_minimum_required( VERSION 3.10 )
+
+project( Catch2Examples LANGUAGES CXX )
+
+message( STATUS "Examples included" )
 
-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
 )
 
 add_executable(231-Cfg_OutputStreams
-  231-Cfg-OutputStreams.cpp
+    231-Cfg-OutputStreams.cpp
 )
 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
-  030-Asn-Require-Check.cpp
-  100-Fix-Section.cpp
-  110-Fix-ClassFixture.cpp
-  111-Fix-PersistentFixture.cpp
-  120-Bdd-ScenarioGivenWhenThen.cpp
-  210-Evt-EventListeners.cpp
-  232-Cfg-CustomMain.cpp
-  300-Gen-OwnGenerator.cpp
-  301-Gen-MapTypeConversion.cpp
-  302-Gen-Table.cpp
-  310-Gen-VariablesInGenerators.cpp
-  311-Gen-CustomCapture.cpp
+set( SOURCES_IDIOMATIC_EXAMPLES
+    030-Asn-Require-Check.cpp
+    100-Fix-Section.cpp
+    110-Fix-ClassFixture.cpp
+    111-Fix-PersistentFixture.cpp
+    120-Bdd-ScenarioGivenWhenThen.cpp
+    210-Evt-EventListeners.cpp
+    232-Cfg-CustomMain.cpp
+    300-Gen-OwnGenerator.cpp
+    301-Gen-MapTypeConversion.cpp
+    302-Gen-Table.cpp
+    310-Gen-VariablesInGenerators.cpp
+    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
@@ -50,9 +53,10 @@ 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)

extras/Catch.cmake

@@ -39,7 +39,6 @@ same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
                          [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
@@ -145,13 +144,10 @@ same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
     ``CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE`` variable if it is not passed when
     calling ``catch_discover_tests``. This provides a mechanism for globally selecting
     a preferred test discovery behavior without having to modify each call site.
-
+    
   ``SKIP_IS_FAILURE``
     Disables skipped test detection.
 
-  ``ADD_TAGS_AS_LABELS``
-    Adds all test tags as CTest labels.
-
 #]=======================================================================]
 
 #------------------------------------------------------------------------------
@@ -159,16 +155,12 @@ function(catch_discover_tests TARGET)
 
   cmake_parse_arguments(
     ""
-    "SKIP_IS_FAILURE;ADD_TAGS_AS_LABELS"
+    "SKIP_IS_FAILURE"
     "TEST_PREFIX;TEST_SUFFIX;WORKING_DIRECTORY;TEST_LIST;REPORTER;OUTPUT_DIR;OUTPUT_PREFIX;OUTPUT_SUFFIX;DISCOVERY_MODE"
     "TEST_SPEC;EXTRA_ARGS;PROPERTIES;DL_PATHS;DL_FRAMEWORK_PATHS"
     ${ARGN}
   )
 
-  if(${CMAKE_VERSION} VERSION_LESS "3.19")
-    message(FATAL_ERROR "This script requires JSON support from CMake version 3.19 or greater.")
-  endif()
-
   if(NOT _WORKING_DIRECTORY)
     set(_WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
   endif()
@@ -187,7 +179,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()
 
@@ -204,7 +196,7 @@ function(catch_discover_tests TARGET)
     TARGET ${TARGET}
     PROPERTY CROSSCOMPILING_EMULATOR
   )
-  if(NOT _SKIP_IS_FAILURE)
+  if (NOT _SKIP_IS_FAILURE)
     set(_PROPERTIES ${_PROPERTIES} SKIP_RETURN_CODE 4)
   endif()
 
@@ -230,7 +222,6 @@ function(catch_discover_tests TARGET)
               -D "TEST_DL_PATHS=${_DL_PATHS}"
               -D "TEST_DL_FRAMEWORK_PATHS=${_DL_FRAMEWORK_PATHS}"
               -D "CTEST_FILE=${ctest_tests_file}"
-              -D "ADD_TAGS_AS_LABELS=${_ADD_TAGS_AS_LABELS}"
               -P "${_CATCH_DISCOVER_TESTS_SCRIPT}"
       VERBATIM
     )
@@ -276,7 +267,7 @@ function(catch_discover_tests TARGET)
       "      CTEST_FILE"             " [==[" "${ctest_tests_file}"        "]==]"   "\n"
       "      TEST_DL_PATHS"          " [==[" "${_DL_PATHS}"               "]==]"   "\n"
       "      TEST_DL_FRAMEWORK_PATHS" " [==[" "${_DL_FRAMEWORK_PATHS}"     "]==]"   "\n"
-      "      ADD_TAGS_AS_LABELS"     " [==[" "${_ADD_TAGS_AS_LABELS}"     "]==]"   "\n"
+      "      CTEST_FILE"             " [==[" "${CTEST_FILE}"              "]==]"   "\n"
       "    )"                                                                      "\n"
       "  endif()"                                                                  "\n"
       "  include(\"${ctest_tests_file}\")"                                         "\n"
@@ -303,10 +294,22 @@ function(catch_discover_tests TARGET)
     endif()
   endif()
 
-  # Add discovered tests to directory TEST_INCLUDE_FILES
-  set_property(DIRECTORY
-    APPEND PROPERTY TEST_INCLUDE_FILES "${ctest_include_file}"
-  )
+  if(NOT ${CMAKE_VERSION} VERSION_LESS "3.10.0")
+    # Add discovered tests to directory TEST_INCLUDE_FILES
+    set_property(DIRECTORY
+      APPEND PROPERTY TEST_INCLUDE_FILES "${ctest_include_file}"
+    )
+  else()
+    # Add discovered tests as directory TEST_INCLUDE_FILE if possible
+    get_property(test_include_file_set DIRECTORY PROPERTY TEST_INCLUDE_FILE SET)
+    if (NOT ${test_include_file_set})
+      set_property(DIRECTORY
+        PROPERTY TEST_INCLUDE_FILE "${ctest_include_file}"
+      )
+    else()
+      message(FATAL_ERROR "Cannot set more than one TEST_INCLUDE_FILE")
+    endif()
+  endif()
 
 endfunction()
 

extras/CatchAddTests.cmake

@@ -22,11 +22,10 @@ function(catch_discover_tests_impl)
     ""
     ""
     "TEST_EXECUTABLE;TEST_WORKING_DIR;TEST_OUTPUT_DIR;TEST_OUTPUT_PREFIX;TEST_OUTPUT_SUFFIX;TEST_PREFIX;TEST_REPORTER;TEST_SPEC;TEST_SUFFIX;TEST_LIST;CTEST_FILE"
-    "TEST_EXTRA_ARGS;TEST_PROPERTIES;TEST_EXECUTOR;TEST_DL_PATHS;TEST_DL_FRAMEWORK_PATHS;ADD_TAGS_AS_LABELS"
+    "TEST_EXTRA_ARGS;TEST_PROPERTIES;TEST_EXECUTOR;TEST_DL_PATHS;TEST_DL_FRAMEWORK_PATHS"
     ${ARGN}
   )
 
-  set(add_tags "${_ADD_TAGS_AS_LABELS}")
   set(prefix "${_TEST_PREFIX}")
   set(suffix "${_TEST_SUFFIX}")
   set(spec ${_TEST_SPEC})
@@ -73,19 +72,25 @@ function(catch_discover_tests_impl)
   endif()
 
   execute_process(
-    COMMAND ${_TEST_EXECUTOR} "${_TEST_EXECUTABLE}" ${spec} --list-tests --reporter json
-    OUTPUT_VARIABLE listing_output
+    COMMAND ${_TEST_EXECUTOR} "${_TEST_EXECUTABLE}" ${spec} --list-tests --verbosity quiet
+    OUTPUT_VARIABLE output
     RESULT_VARIABLE result
     WORKING_DIRECTORY "${_TEST_WORKING_DIR}"
   )
   if(NOT ${result} EQUAL 0)
     message(FATAL_ERROR
-      "Error listing tests from executable '${_TEST_EXECUTABLE}':\n"
+      "Error running test executable '${_TEST_EXECUTABLE}':\n"
       "  Result: ${result}\n"
-      "  Output: ${listing_output}\n"
+      "  Output: ${output}\n"
     )
   endif()
 
+  # Make sure to escape ; (semicolons) in test names first, because
+  # that'd break the foreach loop for "Parse output" later and create
+  # wrongly splitted and thus failing test cases (false positives)
+  string(REPLACE ";" "\;" output "${output}")
+  string(REPLACE "\n" ";" output "${output}")
+
   # Prepare reporter
   if(reporter)
     set(reporter_arg "--reporter ${reporter}")
@@ -105,7 +110,7 @@ function(catch_discover_tests_impl)
       )
     elseif(NOT ${reporter_check_result} EQUAL 0)
       message(FATAL_ERROR
-        "Error checking for reporter in test executable '${_TEST_EXECUTABLE}':\n"
+        "Error running test executable '${_TEST_EXECUTABLE}':\n"
         "  Result: ${reporter_check_result}\n"
         "  Output: ${reporter_check_output}\n"
       )
@@ -134,92 +139,46 @@ function(catch_discover_tests_impl)
     endforeach()
   endif()
 
-  # Parse JSON output for list of tests/class names/tags
-  string(JSON version GET "${listing_output}" "version")
-  if(NOT version STREQUAL "1")
-    message(FATAL_ERROR "Unsupported catch output version: '${version}'")
-  endif()
-
-  # Speed-up reparsing by cutting away unneeded parts of JSON.
-  string(JSON test_listing GET "${listing_output}" "listings" "tests")
-  string(JSON num_tests LENGTH "${test_listing}")
-
-  # Exit early if no tests are detected
-  if(num_tests STREQUAL "0")
-    return()
-  endif()
-
-  # CMake's foreach-RANGE is inclusive, so we have to subtract 1
-  math(EXPR num_tests "${num_tests} - 1")
-
-  foreach(idx RANGE ${num_tests})
-    string(JSON single_test GET ${test_listing} ${idx})
-    string(JSON test_tags GET "${single_test}" "tags")
-    string(JSON plain_name GET "${single_test}" "name")
-
+  # Parse output
+  foreach(line ${output})
+    set(test "${line}")
     # Escape characters in test case names that would be parsed by Catch2
     # Note that the \ escaping must happen FIRST! Do not change the order.
-    set(escaped_name "${plain_name}")
-    foreach(char \\ , [ ] ;)
-      string(REPLACE ${char} "\\${char}" escaped_name "${escaped_name}")
+    set(test_name "${test}")
+    foreach(char \\ , [ ])
+      string(REPLACE ${char} "\\${char}" test_name "${test_name}")
     endforeach(char)
     # ...add output dir
     if(output_dir)
-      string(REGEX REPLACE "[^A-Za-z0-9_]" "_" escaped_name_clean "${escaped_name}")
-      set(output_dir_arg "--out ${output_dir}/${output_prefix}${escaped_name_clean}${output_suffix}")
+      string(REGEX REPLACE "[^A-Za-z0-9_]" "_" test_name_clean "${test_name}")
+      set(output_dir_arg "--out ${output_dir}/${output_prefix}${test_name_clean}${output_suffix}")
     endif()
 
     # ...and add to script
     add_command(add_test
-      "${prefix}${plain_name}${suffix}"
+      "${prefix}${test}${suffix}"
       ${_TEST_EXECUTOR}
       "${_TEST_EXECUTABLE}"
-      "${escaped_name}"
+      "${test_name}"
       ${extra_args}
       "${reporter_arg}"
       "${output_dir_arg}"
     )
     add_command(set_tests_properties
-      "${prefix}${plain_name}${suffix}"
+      "${prefix}${test}${suffix}"
       PROPERTIES
       WORKING_DIRECTORY "${_TEST_WORKING_DIR}"
       ${properties}
     )
 
-    if(add_tags)
-      string(JSON num_tags LENGTH "${test_tags}")
-      math(EXPR num_tags "${num_tags} - 1")
-      set(tag_list "")
-      if(num_tags GREATER_EQUAL "0")
-        foreach(tag_idx RANGE ${num_tags})
-          string(JSON a_tag GET "${test_tags}" "${tag_idx}")
-          # Catch2's tags can contain semicolons, which are list element separators
-          # in CMake, so we have to escape them. Ideally we could use the [=[...]=]
-          # syntax for this, but CTest currently keeps the square quotes in the label
-          # name. So we add 2 backslashes to escape it instead.
-          # **IMPORTANT**: The number of backslashes depends on how many layers
-          #                of CMake the tag goes. If this script is changed, the
-          #                number of backslashes to escape may change as well.
-          string(REPLACE ";" "\\;" a_tag "${a_tag}")
-          list(APPEND tag_list "${a_tag}")
-        endforeach()
-
-        add_command(set_tests_properties
-          "${prefix}${plain_name}${suffix}"
-          PROPERTIES
-          LABELS "${tag_list}"
-        )
-      endif()
-    endif(add_tags)
-
     if(environment_modifications)
       add_command(set_tests_properties
-        "${prefix}${plain_name}${suffix}"
+        "${prefix}${test}${suffix}"
         PROPERTIES
         ENVIRONMENT_MODIFICATION "${environment_modifications}")
     endif()
 
-    list(APPEND tests "${prefix}${plain_name}${suffix}")
+    list(APPEND tests "${prefix}${test}${suffix}")
   endforeach()
 
   # Create a list of all discovered tests, which users may use to e.g. set
@@ -248,6 +207,5 @@ if(CMAKE_SCRIPT_MODE_FILE)
     TEST_DL_PATHS ${TEST_DL_PATHS}
     TEST_DL_FRAMEWORK_PATHS ${TEST_DL_FRAMEWORK_PATHS}
     CTEST_FILE ${CTEST_FILE}
-    ADD_TAGS_AS_LABELS ${ADD_TAGS_AS_LABELS}
   )
 endif()

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,6 +61,8 @@ function(catch_add_sharded_tests TARGET)
             -P "${shard_impl_script_file}"
     VERBATIM
   )
+
+
 endfunction()
 
 

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()
 

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()
 
@@ -67,9 +67,9 @@ option(PARSE_CATCH_TESTS_ADD_TARGET_IN_TEST_NAME "Add target name to the test na
 option(PARSE_CATCH_TESTS_ADD_TO_CONFIGURE_DEPENDS "Add test file to CMAKE_CONFIGURE_DEPENDS property" OFF)
 
 function(ParseAndAddCatchTests_PrintDebugMessage)
-  if(PARSE_CATCH_TESTS_VERBOSE)
-    message(STATUS "ParseAndAddCatchTests: ${ARGV}")
-  endif()
+    if(PARSE_CATCH_TESTS_VERBOSE)
+            message(STATUS "ParseAndAddCatchTests: ${ARGV}")
+    endif()
 endfunction()
 
 # This removes the contents between
@@ -90,161 +90,163 @@ endfunction()
 
 # Worker function
 function(ParseAndAddCatchTests_ParseFile SourceFile TestTarget)
-  # If SourceFile is an object library, do not scan it (as it is not a file). Exit without giving a warning about a missing file.
-  if(SourceFile MATCHES "\\\$<TARGET_OBJECTS:.+>")
-    ParseAndAddCatchTests_PrintDebugMessage("Detected OBJECT library: ${SourceFile} this will not be scanned for tests.")
-    return()
-  endif()
-  # According to CMake docs EXISTS behavior is well-defined only for full paths.
-  get_filename_component(SourceFile ${SourceFile} ABSOLUTE)
-  if(NOT EXISTS ${SourceFile})
-    message(WARNING "Cannot find source file: ${SourceFile}")
-    return()
-  endif()
-  ParseAndAddCatchTests_PrintDebugMessage("parsing ${SourceFile}")
-  file(STRINGS ${SourceFile} Contents NEWLINE_CONSUME)
-
-  # Remove block and fullline comments
-  ParseAndAddCatchTests_RemoveComments(Contents)
-
-  # Find definition of test names
-  # https://regex101.com/r/JygOND/1
-  string(REGEX MATCHALL "[ \t]*(CATCH_)?(TEMPLATE_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)[ \t]*\\([ \t\n]*\"[^\"]*\"[ \t\n]*(,[ \t\n]*\"[^\"]*\")?(,[ \t\n]*[^\,\)]*)*\\)[ \t\n]*\{+[ \t]*(//[^\n]*[Tt][Ii][Mm][Ee][Oo][Uu][Tt][ \t]*[0-9]+)*" Tests "${Contents}")
-
-  if(PARSE_CATCH_TESTS_ADD_TO_CONFIGURE_DEPENDS AND Tests)
-    ParseAndAddCatchTests_PrintDebugMessage("Adding ${SourceFile} to CMAKE_CONFIGURE_DEPENDS property")
-    set_property(
-      DIRECTORY
-      APPEND
-      PROPERTY CMAKE_CONFIGURE_DEPENDS ${SourceFile}
-    )
-  endif()
-
-  # check CMP0110 policy for new add_test() behavior
-  if(POLICY CMP0110)
-    cmake_policy(GET CMP0110 _cmp0110_value) # new add_test() behavior
-  else()
-    # just to be thorough explicitly set the variable
-    set(_cmp0110_value)
-  endif()
-
-  foreach(TestName ${Tests})
-    # Strip newlines
-    string(REGEX REPLACE "\\\\\n|\n" "" TestName "${TestName}")
-
-    # Get test type and fixture if applicable
-    string(REGEX MATCH "(CATCH_)?(TEMPLATE_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)[ \t]*\\([^,^\"]*" TestTypeAndFixture "${TestName}")
-    string(REGEX MATCH "(CATCH_)?(TEMPLATE_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)" TestType "${TestTypeAndFixture}")
-    string(REGEX REPLACE "${TestType}\\([ \t]*" "" TestFixture "${TestTypeAndFixture}")
-
-    # Get string parts of test definition
-    string(REGEX MATCHALL "\"+([^\\^\"]|\\\\\")+\"+" TestStrings "${TestName}")
-
-    # Strip wrapping quotation marks
-    string(REGEX REPLACE "^\"(.*)\"$" "\\1" TestStrings "${TestStrings}")
-    string(REPLACE "\";\"" ";" TestStrings "${TestStrings}")
-
-    # Validate that a test name and tags have been provided
-    list(LENGTH TestStrings TestStringsLength)
-    if(TestStringsLength GREATER 2 OR TestStringsLength LESS 1)
-      message(FATAL_ERROR "You must provide a valid test name and tags for all tests in ${SourceFile}")
+    # If SourceFile is an object library, do not scan it (as it is not a file). Exit without giving a warning about a missing file.
+    if(SourceFile MATCHES "\\\$<TARGET_OBJECTS:.+>")
+        ParseAndAddCatchTests_PrintDebugMessage("Detected OBJECT library: ${SourceFile} this will not be scanned for tests.")
+        return()
     endif()
-
-    # Assign name and tags
-    list(GET TestStrings 0 Name)
-    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)
-      set(CTestName "${TestFixture}:${Name}")
-    else()
-      set(CTestName "${Name}")
-    endif()
-    if(PARSE_CATCH_TESTS_ADD_TARGET_IN_TEST_NAME)
-      set(CTestName "${TestTarget}:${CTestName}")
-    endif()
-    # add target to labels to enable running all tests added from this target
-    set(Labels ${TestTarget})
-    if(TestStringsLength EQUAL 2)
-      list(GET TestStrings 1 Tags)
-      string(TOLOWER "${Tags}" Tags)
-      # remove target from labels if the test is hidden
-      if("${Tags}" MATCHES ".*\\[!?(hide|\\.)\\].*")
-        list(REMOVE_ITEM Labels ${TestTarget})
-      endif()
-      string(REPLACE "]" ";" Tags "${Tags}")
-      string(REPLACE "[" "" Tags "${Tags}")
-    else()
-      # unset tags variable from previous loop
-      unset(Tags)
+    # According to CMake docs EXISTS behavior is well-defined only for full paths.
+    get_filename_component(SourceFile ${SourceFile} ABSOLUTE)
+    if(NOT EXISTS ${SourceFile})
+        message(WARNING "Cannot find source file: ${SourceFile}")
+        return()
     endif()
+    ParseAndAddCatchTests_PrintDebugMessage("parsing ${SourceFile}")
+    file(STRINGS ${SourceFile} Contents NEWLINE_CONSUME)
 
-    list(APPEND Labels ${Tags})
+    # Remove block and fullline comments
+    ParseAndAddCatchTests_RemoveComments(Contents)
 
-    set(HiddenTagFound OFF)
-    foreach(label ${Labels})
-      string(REGEX MATCH "^!hide|^\\." result ${label})
-      if(result)
-        set(HiddenTagFound ON)
-        break()
-      endif()
-    endforeach(label)
-    if(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS AND ${HiddenTagFound} AND ${CMAKE_VERSION} VERSION_LESS "3.9")
-      ParseAndAddCatchTests_PrintDebugMessage("Skipping test \"${CTestName}\" as it has [!hide], [.] or [.foo] label")
-    else()
-      ParseAndAddCatchTests_PrintDebugMessage("Adding test \"${CTestName}\"")
-      if(Labels)
-        ParseAndAddCatchTests_PrintDebugMessage("Setting labels to ${Labels}")
-      endif()
+    # Find definition of test names
+    # https://regex101.com/r/JygOND/1
+    string(REGEX MATCHALL "[ \t]*(CATCH_)?(TEMPLATE_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)[ \t]*\\([ \t\n]*\"[^\"]*\"[ \t\n]*(,[ \t\n]*\"[^\"]*\")?(,[ \t\n]*[^\,\)]*)*\\)[ \t\n]*\{+[ \t]*(//[^\n]*[Tt][Ii][Mm][Ee][Oo][Uu][Tt][ \t]*[0-9]+)*" Tests "${Contents}")
 
-      # Escape commas in the test spec
-      string(REPLACE "," "\\," Name ${Name})
-
-      # Work around CMake 3.18.0 change in `add_test()`, before the escaped quotes were necessary,
-      # only with CMake 3.18.0 the escaped double quotes confuse the call. This change is reverted in 3.18.1
-      # And properly introduced in 3.19 with the CMP0110 policy
-      if(_cmp0110_value STREQUAL "NEW" OR ${CMAKE_VERSION} VERSION_EQUAL "3.18")
-        ParseAndAddCatchTests_PrintDebugMessage("CMP0110 set to NEW, no need for add_test(\"\") workaround")
-      else()
-        ParseAndAddCatchTests_PrintDebugMessage("CMP0110 set to OLD adding \"\" for add_test() workaround")
-        set(CTestName "\"${CTestName}\"")
-      endif()
-
-      # Handle template test cases
-      if("${TestTypeAndFixture}" MATCHES ".*TEMPLATE_.*")
-        set(Name "${Name} - *")
-      endif()
-
-      # Add the test and set its properties
-      add_test(NAME "${CTestName}" COMMAND ${OptionalCatchTestLauncher} $<TARGET_FILE:${TestTarget}> ${Name} ${AdditionalCatchParameters})
-      # Old CMake versions do not document VERSION_GREATER_EQUAL, so we use VERSION_GREATER with 3.8 instead
-      if(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS AND ${HiddenTagFound} AND ${CMAKE_VERSION} VERSION_GREATER "3.8")
-        ParseAndAddCatchTests_PrintDebugMessage("Setting DISABLED test property")
-        set_tests_properties("${CTestName}" PROPERTIES DISABLED ON)
-      else()
-        set_tests_properties("${CTestName}" PROPERTIES FAIL_REGULAR_EXPRESSION "No tests ran"
-                                                LABELS "${Labels}")
-      endif()
+    if(PARSE_CATCH_TESTS_ADD_TO_CONFIGURE_DEPENDS AND Tests)
+      ParseAndAddCatchTests_PrintDebugMessage("Adding ${SourceFile} to CMAKE_CONFIGURE_DEPENDS property")
       set_property(
-        TARGET ${TestTarget}
+        DIRECTORY
         APPEND
-        PROPERTY ParseAndAddCatchTests_TESTS "${CTestName}")
-      set_property(
-        SOURCE ${SourceFile}
-        APPEND
-        PROPERTY ParseAndAddCatchTests_TESTS "${CTestName}")
+        PROPERTY CMAKE_CONFIGURE_DEPENDS ${SourceFile}
+      )
     endif()
-  endforeach()
+
+    # check CMP0110 policy for new add_test() behavior
+    if(POLICY CMP0110)
+        cmake_policy(GET CMP0110 _cmp0110_value) # new add_test() behavior
+    else()
+        # just to be thorough explicitly set the variable
+        set(_cmp0110_value)
+    endif()
+
+    foreach(TestName ${Tests})
+        # Strip newlines
+        string(REGEX REPLACE "\\\\\n|\n" "" TestName "${TestName}")
+
+        # Get test type and fixture if applicable
+        string(REGEX MATCH "(CATCH_)?(TEMPLATE_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)[ \t]*\\([^,^\"]*" TestTypeAndFixture "${TestName}")
+        string(REGEX MATCH "(CATCH_)?(TEMPLATE_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)" TestType "${TestTypeAndFixture}")
+        string(REGEX REPLACE "${TestType}\\([ \t]*" "" TestFixture "${TestTypeAndFixture}")
+
+        # Get string parts of test definition
+        string(REGEX MATCHALL "\"+([^\\^\"]|\\\\\")+\"+" TestStrings "${TestName}")
+
+        # Strip wrapping quotation marks
+        string(REGEX REPLACE "^\"(.*)\"$" "\\1" TestStrings "${TestStrings}")
+        string(REPLACE "\";\"" ";" TestStrings "${TestStrings}")
+
+        # Validate that a test name and tags have been provided
+        list(LENGTH TestStrings TestStringsLength)
+        if(TestStringsLength GREATER 2 OR TestStringsLength LESS 1)
+            message(FATAL_ERROR "You must provide a valid test name and tags for all tests in ${SourceFile}")
+        endif()
+
+        # Assign name and tags
+        list(GET TestStrings 0 Name)
+        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 )
+            set(CTestName "${TestFixture}:${Name}")
+        else()
+            set(CTestName "${Name}")
+        endif()
+        if(PARSE_CATCH_TESTS_ADD_TARGET_IN_TEST_NAME)
+            set(CTestName "${TestTarget}:${CTestName}")
+        endif()
+        # add target to labels to enable running all tests added from this target
+        set(Labels ${TestTarget})
+        if(TestStringsLength EQUAL 2)
+            list(GET TestStrings 1 Tags)
+            string(TOLOWER "${Tags}" Tags)
+            # remove target from labels if the test is hidden
+            if("${Tags}" MATCHES ".*\\[!?(hide|\\.)\\].*")
+                list(REMOVE_ITEM Labels ${TestTarget})
+            endif()
+            string(REPLACE "]" ";" Tags "${Tags}")
+            string(REPLACE "[" "" Tags "${Tags}")
+        else()
+          # unset tags variable from previous loop
+          unset(Tags)
+        endif()
+
+        list(APPEND Labels ${Tags})
+
+        set(HiddenTagFound OFF)
+        foreach(label ${Labels})
+            string(REGEX MATCH "^!hide|^\\." result ${label})
+            if(result)
+                set(HiddenTagFound ON)
+                break()
+            endif()
+        endforeach(label)
+        if(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS AND ${HiddenTagFound} AND ${CMAKE_VERSION} VERSION_LESS "3.9")
+            ParseAndAddCatchTests_PrintDebugMessage("Skipping test \"${CTestName}\" as it has [!hide], [.] or [.foo] label")
+        else()
+            ParseAndAddCatchTests_PrintDebugMessage("Adding test \"${CTestName}\"")
+            if(Labels)
+                ParseAndAddCatchTests_PrintDebugMessage("Setting labels to ${Labels}")
+            endif()
+
+            # Escape commas in the test spec
+            string(REPLACE "," "\\," Name ${Name})
+
+            # Work around CMake 3.18.0 change in `add_test()`, before the escaped quotes were necessary,
+            # only with CMake 3.18.0 the escaped double quotes confuse the call. This change is reverted in 3.18.1
+            # And properly introduced in 3.19 with the CMP0110 policy
+            if(_cmp0110_value STREQUAL "NEW" OR ${CMAKE_VERSION} VERSION_EQUAL "3.18")
+                ParseAndAddCatchTests_PrintDebugMessage("CMP0110 set to NEW, no need for add_test(\"\") workaround")
+            else()
+                ParseAndAddCatchTests_PrintDebugMessage("CMP0110 set to OLD adding \"\" for add_test() workaround")
+                set(CTestName "\"${CTestName}\"")
+            endif()
+
+            # Handle template test cases
+            if("${TestTypeAndFixture}" MATCHES ".*TEMPLATE_.*")
+              set(Name "${Name} - *")
+            endif()
+
+            # Add the test and set its properties
+            add_test(NAME "${CTestName}" COMMAND ${OptionalCatchTestLauncher} $<TARGET_FILE:${TestTarget}> ${Name} ${AdditionalCatchParameters})
+            # Old CMake versions do not document VERSION_GREATER_EQUAL, so we use VERSION_GREATER with 3.8 instead
+            if(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS AND ${HiddenTagFound} AND ${CMAKE_VERSION} VERSION_GREATER "3.8")
+                ParseAndAddCatchTests_PrintDebugMessage("Setting DISABLED test property")
+                set_tests_properties("${CTestName}" PROPERTIES DISABLED ON)
+            else()
+                set_tests_properties("${CTestName}" PROPERTIES FAIL_REGULAR_EXPRESSION "No tests ran"
+                                                        LABELS "${Labels}")
+            endif()
+            set_property(
+              TARGET ${TestTarget}
+              APPEND
+              PROPERTY ParseAndAddCatchTests_TESTS "${CTestName}")
+            set_property(
+              SOURCE ${SourceFile}
+              APPEND
+              PROPERTY ParseAndAddCatchTests_TESTS "${CTestName}")
+        endif()
+
+
+    endforeach()
 endfunction()
 
 # entry point
 function(ParseAndAddCatchTests TestTarget)
-  message(DEPRECATION "ParseAndAddCatchTest: function deprecated because of possibility of missed test cases. Consider using 'catch_discover_tests' from 'Catch.cmake'")
-  ParseAndAddCatchTests_PrintDebugMessage("Started parsing ${TestTarget}")
-  get_target_property(SourceFiles ${TestTarget} SOURCES)
-  ParseAndAddCatchTests_PrintDebugMessage("Found the following sources: ${SourceFiles}")
-  foreach(SourceFile ${SourceFiles})
-    ParseAndAddCatchTests_ParseFile(${SourceFile} ${TestTarget})
-  endforeach()
-  ParseAndAddCatchTests_PrintDebugMessage("Finished parsing ${TestTarget}")
+    message(DEPRECATION "ParseAndAddCatchTest: function deprecated because of possibility of missed test cases. Consider using 'catch_discover_tests' from 'Catch.cmake'")
+    ParseAndAddCatchTests_PrintDebugMessage("Started parsing ${TestTarget}")
+    get_target_property(SourceFiles ${TestTarget} SOURCES)
+    ParseAndAddCatchTests_PrintDebugMessage("Found the following sources: ${SourceFiles}")
+    foreach(SourceFile ${SourceFiles})
+        ParseAndAddCatchTests_ParseFile(${SourceFile} ${TestTarget})
+    endforeach()
+    ParseAndAddCatchTests_PrintDebugMessage("Finished parsing ${TestTarget}")
 endfunction()

extras/catch_amalgamated.cpp

@@ -6,8 +6,8 @@
 
 // SPDX-License-Identifier: BSL-1.0
 
-//  Catch v3.8.1
-//  Generated: 2025-04-08 12:33:19.863332
+//  Catch v3.7.1
+//  Generated: 2024-09-17 10:36:45.608896
 //  ----------------------------------------------------------
 //  This file is an amalgamation of multiple different files.
 //  You probably shouldn't edit it directly.
@@ -332,7 +332,7 @@ namespace Catch {
                                              double diff = b - m;
                                              return a + diff * diff;
                                          } ) /
-                        static_cast<double>( last - first );
+                        ( last - first );
                     return std::sqrt( variance );
                 }
 
@@ -367,7 +367,7 @@ namespace Catch {
                                               double* first,
                                               double* last ) {
                 auto count = last - first;
-                double idx = static_cast<double>((count - 1) * k) / static_cast<double>(q);
+                double idx = (count - 1) * k / static_cast<double>(q);
                 int j = static_cast<int>(idx);
                 double g = idx - j;
                 std::nth_element(first, first + j, last);
@@ -470,10 +470,10 @@ namespace Catch {
 
                 double accel = sum_cubes / ( 6 * std::pow( sum_squares, 1.5 ) );
                 long n = static_cast<long>( resample.size() );
-                double prob_n = static_cast<double>(
+                double prob_n =
                     std::count_if( resample.begin(),
                                    resample.end(),
-                                   [point]( double x ) { return x < point; } )) /
+                                   [point]( double x ) { return x < point; } ) /
                     static_cast<double>( n );
                 // degenerate case with uniform samples
                 if ( Catch::Detail::directCompare( prob_n, 0. ) ) {
@@ -1926,7 +1926,7 @@ namespace Catch {
         return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
     }
     auto Timer::getElapsedSeconds() const -> double {
-        return static_cast<double>(getElapsedMicroseconds())/1000000.0;
+        return getElapsedMicroseconds()/1000000.0;
     }
 
 
@@ -1946,10 +1946,7 @@ namespace Detail {
         const int hexThreshold = 255;
 
         struct Endianness {
-            enum Arch : uint8_t {
-                Big,
-                Little
-            };
+            enum Arch { Big, Little };
 
             static Arch which() {
                 int one = 1;
@@ -2283,7 +2280,7 @@ namespace Catch {
     }
 
     Version const& libraryVersion() {
-        static Version version( 3, 8, 1, "", 0 );
+        static Version version( 3, 7, 1, "", 0 );
         return version;
     }
 
@@ -3519,7 +3516,7 @@ namespace {
 #endif // Windows/ ANSI/ None
 
 
-#if defined( CATCH_PLATFORM_LINUX ) || defined( CATCH_PLATFORM_MAC ) || defined( __GLIBC__ )
+#if defined( CATCH_PLATFORM_LINUX ) || defined( CATCH_PLATFORM_MAC )
 #    define CATCH_INTERNAL_HAS_ISATTY
 #    include <unistd.h>
 #endif
@@ -5261,7 +5258,7 @@ namespace {
     SimplePcg32::result_type SimplePcg32::operator()() {
         // prepare the output value
         const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
-        const auto output = rotate_right(xorshifted, static_cast<uint32_t>(m_state >> 59u));
+        const auto output = rotate_right(xorshifted, m_state >> 59u);
 
         // advance state
         m_state = m_state * 6364136223846793005ULL + s_inc;
@@ -9111,7 +9108,7 @@ struct RowBreak {};
 struct OutputFlush {};
 
 class Duration {
-    enum class Unit : uint8_t {
+    enum class Unit {
         Auto,
         Nanoseconds,
         Microseconds,
@@ -9183,10 +9180,7 @@ public:
 };
 } // end anon namespace
 
-enum class Justification : uint8_t {
-    Left,
-    Right
-};
+enum class Justification { Left, Right };
 
 struct ColumnInfo {
     std::string name;

extras/catch_amalgamated.hpp

@@ -6,8 +6,8 @@
 
 // SPDX-License-Identifier: BSL-1.0
 
-//  Catch v3.8.1
-//  Generated: 2025-04-08 12:33:19.851017
+//  Catch v3.7.1
+//  Generated: 2024-09-17 10:36:40.974985
 //  ----------------------------------------------------------
 //  This file is an amalgamation of multiple different files.
 //  You probably shouldn't edit it directly.
@@ -150,7 +150,7 @@
 #    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
          _Pragma( "GCC diagnostic ignored \"-Wshadow\"" )
 
-#    define CATCH_INTERNAL_CONFIG_USE_BUILTIN_CONSTANT_P
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
 
 #endif
 
@@ -174,45 +174,14 @@
 // clang-cl defines _MSC_VER as well as __clang__, which could cause the
 // start/stop internal suppression macros to be double defined.
 #if defined(__clang__) && !defined(_MSC_VER)
-#    define CATCH_INTERNAL_CONFIG_USE_BUILTIN_CONSTANT_P
+
 #    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
 #    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )
+
 #endif // __clang__ && !_MSC_VER
 
 #if defined(__clang__)
 
-#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
-         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
-
-#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
-
-#    if (__clang_major__ >= 20)
-#        define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-             _Pragma( "clang diagnostic ignored \"-Wvariadic-macro-arguments-omitted\"" )
-#    elif (__clang_major__ == 19)
-#        define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-	         _Pragma( "clang diagnostic ignored \"-Wc++20-extensions\"" )
-#    else
-#        define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
-             _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
-#    endif
-
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
-        _Pragma( "clang diagnostic ignored \"-Wcomma\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
-        _Pragma( "clang diagnostic ignored \"-Wshadow\"" )
-
-#endif // __clang__
-
 // As of this writing, IBM XL's implementation of __builtin_constant_p has a bug
 // which results in calls to destructors being emitted for each temporary,
 // without a matching initialization. In practice, this can result in something
@@ -229,11 +198,35 @@
 // https://developer.nvidia.com/nvidia_bug/3321845.
 //
 // Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented.
-#if defined( __ibmxl__ ) || defined( __CUDACC__ ) || defined( __NVCOMPILER )
-#    define CATCH_INTERNAL_CONFIG_NO_USE_BUILTIN_CONSTANT_P
-#endif
+#  if !defined(__ibmxl__) && !defined(__CUDACC__) && !defined( __NVCOMPILER )
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */
+#  endif
 
 
+#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
+         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
+
+#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
+        _Pragma( "clang diagnostic ignored \"-Wcomma\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
+        _Pragma( "clang diagnostic ignored \"-Wshadow\"" )
+
+#endif // __clang__
+
 
 ////////////////////////////////////////////////////////////////////////////////
 // We know some environments not to support full POSIX signals
@@ -457,22 +450,6 @@
 #endif
 
 
-// The goal of this macro is to avoid evaluation of the arguments, but
-// still have the compiler warn on problems inside...
-#if defined( CATCH_INTERNAL_CONFIG_USE_BUILTIN_CONSTANT_P ) && \
-    !defined( CATCH_INTERNAL_CONFIG_NO_USE_BUILTIN_CONSTANT_P ) && !defined(CATCH_CONFIG_USE_BUILTIN_CONSTANT_P)
-#define CATCH_CONFIG_USE_BUILTIN_CONSTANT_P
-#endif
-
-#if defined( CATCH_CONFIG_USE_BUILTIN_CONSTANT_P ) && \
-    !defined( CATCH_CONFIG_NO_USE_BUILTIN_CONSTANT_P )
-#    define CATCH_INTERNAL_IGNORE_BUT_WARN( ... )                                              \
-        (void)__builtin_constant_p( __VA_ARGS__ ) /* NOLINT(cppcoreguidelines-pro-type-vararg, \
-                                                     hicpp-vararg) */
-#else
-#    define CATCH_INTERNAL_IGNORE_BUT_WARN( ... )
-#endif
-
 // Even if we do not think the compiler has that warning, we still have
 // to provide a macro that can be used by the code.
 #if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
@@ -509,6 +486,13 @@
 #    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS
 #endif
 
+
+// The goal of this macro is to avoid evaluation of the arguments, but
+// still have the compiler warn on problems inside...
+#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
+#   define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
+#endif
+
 #if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
 #   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
 #elif defined(__clang__) && (__clang_major__ < 5)
@@ -3066,11 +3050,7 @@ struct ratio_string<std::milli> {
 
 #ifdef _MSC_VER
             std::tm timeInfo = {};
-            const auto err = gmtime_s(&timeInfo, &converted);
-            if ( err ) {
-                return "gmtime from provided timepoint has failed. This "
-                       "happens e.g. with pre-1970 dates using Microsoft libc";
-            }
+            gmtime_s(&timeInfo, &converted);
 #else
             std::tm* timeInfo = std::gmtime(&converted);
 #endif
@@ -7349,7 +7329,7 @@ namespace Catch {
 #define CATCH_VERSION_MACROS_HPP_INCLUDED
 
 #define CATCH_VERSION_MAJOR 3
-#define CATCH_VERSION_MINOR 8
+#define CATCH_VERSION_MINOR 7
 #define CATCH_VERSION_PATCH 1
 
 #endif // CATCH_VERSION_MACROS_HPP_INCLUDED
@@ -8733,7 +8713,7 @@ public:
 
 template <typename InputIterator,
           typename InputSentinel,
-          typename ResultType = std::remove_const_t<typename std::iterator_traits<InputIterator>::value_type>>
+          typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
 GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
     return GeneratorWrapper<ResultType>(Catch::Detail::make_unique<IteratorGenerator<ResultType>>(from, to));
 }
@@ -12711,65 +12691,56 @@ namespace Catch {
          * Creates a matcher that checks if all elements in a range are equal
          * to all elements in another range.
          *
-         * Uses the provided predicate `predicate` to do the comparisons
-         * (defaulting to `std::equal_to`)
+         * Uses `std::equal_to` to do the comparison
          */
-        template <typename RangeLike,
-                  typename Equality = decltype( std::equal_to<>{} )>
+        template <typename RangeLike>
+        constexpr
+        std::enable_if_t<!Detail::is_matcher<RangeLike>::value,
+                         RangeEqualsMatcher<RangeLike, std::equal_to<>>>
+        RangeEquals( RangeLike&& range ) {
+            return { CATCH_FORWARD( range ), std::equal_to<>{} };
+        }
+
+        /**
+         * Creates a matcher that checks if all elements in a range are equal
+         * to all elements in another range.
+         *
+         * Uses to provided predicate `predicate` to do the comparisons
+         */
+        template <typename RangeLike, typename Equality>
         constexpr
         RangeEqualsMatcher<RangeLike, Equality>
-        RangeEquals( RangeLike&& range,
-                     Equality&& predicate = std::equal_to<>{} ) {
+        RangeEquals( RangeLike&& range, Equality&& predicate ) {
             return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
         }
 
         /**
          * Creates a matcher that checks if all elements in a range are equal
-         * to all elements in an initializer list.
+         * to all elements in another range, in some permutation
          *
-         * Uses the provided predicate `predicate` to do the comparisons
-         * (defaulting to `std::equal_to`)
+         * Uses `std::equal_to` to do the comparison
          */
-        template <typename T,
-                  typename Equality = decltype( std::equal_to<>{} )>
+        template <typename RangeLike>
         constexpr
-        RangeEqualsMatcher<std::initializer_list<T>, Equality>
-        RangeEquals( std::initializer_list<T> range,
-                     Equality&& predicate = std::equal_to<>{} ) {
-            return { range, CATCH_FORWARD( predicate ) };
+        std::enable_if_t<
+            !Detail::is_matcher<RangeLike>::value,
+            UnorderedRangeEqualsMatcher<RangeLike, std::equal_to<>>>
+        UnorderedRangeEquals( RangeLike&& range ) {
+            return { CATCH_FORWARD( range ), std::equal_to<>{} };
         }
 
         /**
          * Creates a matcher that checks if all elements in a range are equal
          * to all elements in another range, in some permutation.
          *
-         * Uses the provided predicate `predicate` to do the comparisons
-         * (defaulting to `std::equal_to`)
+         * Uses to provided predicate `predicate` to do the comparisons
          */
-        template <typename RangeLike,
-                  typename Equality = decltype( std::equal_to<>{} )>
+        template <typename RangeLike, typename Equality>
         constexpr
         UnorderedRangeEqualsMatcher<RangeLike, Equality>
-        UnorderedRangeEquals( RangeLike&& range,
-                              Equality&& predicate = std::equal_to<>{} ) {
+        UnorderedRangeEquals( RangeLike&& range, Equality&& predicate ) {
             return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
         }
-
-        /**
-         * Creates a matcher that checks if all elements in a range are equal
-         * to all elements in an initializer list, in some permutation.
-         *
-         * Uses the provided predicate `predicate` to do the comparisons
-         * (defaulting to `std::equal_to`)
-         */
-        template <typename T,
-                  typename Equality = decltype( std::equal_to<>{} )>
-        constexpr
-        UnorderedRangeEqualsMatcher<std::initializer_list<T>, Equality>
-        UnorderedRangeEquals( std::initializer_list<T> range,
-                              Equality&& predicate = std::equal_to<>{} ) {
-            return { range, CATCH_FORWARD( predicate ) };
-        }
     } // namespace Matchers
 } // namespace Catch
 

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()

meson.build

@@ -8,7 +8,7 @@
 project(
   'catch2',
   'cpp',
-  version: '3.8.1', # CML version placeholder, don't delete
+  version: '3.7.1', # CML version placeholder, don't delete
   license: 'BSL-1.0',
   meson_version: '>=0.54.1',
 )

meson_options.txt

@@ -1,2 +1 @@
 option('tests', type: 'boolean', value: true, description: 'Build the unit tests')
-option('install', type: 'boolean', value: true, description: 'Install the library')

src/CMakeLists.txt

@@ -40,6 +40,7 @@ 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
@@ -347,23 +348,25 @@ source_group("generated headers"
 )
 
 add_library(Catch2 ${ALL_FILES})
-if(CATCH_ENABLE_REPRODUCIBLE_BUILD)
-  add_build_reproducibility_settings(Catch2)
+if (CATCH_ENABLE_REPRODUCIBLE_BUILD)
+    add_build_reproducibility_settings(Catch2)
 endif()
 add_library(Catch2::Catch2 ALIAS Catch2)
 
-if(ANDROID)
-  target_link_libraries(Catch2 PRIVATE log)
+if (ANDROID)
+    target_link_libraries(Catch2 PRIVATE log)
 endif()
 
 set_target_properties(Catch2 PROPERTIES
-  DEBUG_POSTFIX "d"
-  VERSION ${PROJECT_VERSION}
-  SOVERSION ${PROJECT_VERSION}
-)
+                          DEBUG_POSTFIX "d"
+                                VERSION ${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"
@@ -379,97 +382,105 @@ target_include_directories(Catch2
 
 
 add_library(Catch2WithMain
-  ${SOURCES_DIR}/internal/catch_main.cpp
+    ${SOURCES_DIR}/internal/catch_main.cpp
 )
-if(CATCH_ENABLE_REPRODUCIBLE_BUILD)
-  add_build_reproducibility_settings(Catch2WithMain)
+if (CATCH_ENABLE_REPRODUCIBLE_BUILD)
+    add_build_reproducibility_settings(Catch2WithMain)
 endif()
 add_library(Catch2::Catch2WithMain ALIAS Catch2WithMain)
 target_link_libraries(Catch2WithMain PUBLIC Catch2)
 set_target_properties(Catch2WithMain
   PROPERTIES
     OUTPUT_NAME "Catch2Main"
-    VERSION ${PROJECT_VERSION}
-    SOVERSION ${PROJECT_VERSION}
+        VERSION ${PROJECT_VERSION}
+      SOVERSION ${PROJECT_VERSION}
 )
 set_target_properties(Catch2WithMain PROPERTIES DEBUG_POSTFIX "d")
 
-if(NOT_SUBPROJECT)
-  # create and install an export set for catch target as Catch2::Catch
-  install(
-    TARGETS
-      Catch2
-      Catch2WithMain
-    EXPORT
-      Catch2Targets
-    LIBRARY DESTINATION
-      ${CMAKE_INSTALL_LIBDIR}
-    ARCHIVE DESTINATION
-      ${CMAKE_INSTALL_LIBDIR}
-    RUNTIME DESTINATION
-      ${CMAKE_INSTALL_BINDIR}
-  )
+if (NOT_SUBPROJECT)
+    # create and install an export set for catch target as Catch2::Catch
+    install(
+      TARGETS
+        Catch2
+        Catch2WithMain
+      EXPORT
+        Catch2Targets
+      LIBRARY DESTINATION
+        ${CMAKE_INSTALL_LIBDIR}
+      ARCHIVE DESTINATION
+        ${CMAKE_INSTALL_LIBDIR}
+      RUNTIME DESTINATION
+        ${CMAKE_INSTALL_BINDIR}
+    )
 
-  install(
-    EXPORT
-      Catch2Targets
-    NAMESPACE
-      Catch2::
-    DESTINATION
-      ${CATCH_CMAKE_CONFIG_DESTINATION}
-  )
-  # Install the headers
-  install(
-    DIRECTORY
-      "${SOURCES_DIR}"
-      "${PROJECT_BINARY_DIR}/generated-includes/catch2" # Also install the generated header
-    DESTINATION
-      "${CMAKE_INSTALL_INCLUDEDIR}"
-    FILES_MATCHING
-      PATTERN "*.hpp"
-  )
+
+    install(
+      EXPORT
+        Catch2Targets
+      NAMESPACE
+        Catch2::
+      DESTINATION
+        ${CATCH_CMAKE_CONFIG_DESTINATION}
+    )
+    # Install the headers
+    install(
+      DIRECTORY
+        "${SOURCES_DIR}"
+        "${PROJECT_BINARY_DIR}/generated-includes/catch2" # Also install the generated header
+      DESTINATION
+        "${CMAKE_INSTALL_INCLUDEDIR}"
+      FILES_MATCHING
+        PATTERN "*.hpp"
+    )
 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)
-  add_library(Catch2_buildall_interface INTERFACE)
-  target_sources(Catch2_buildall_interface INTERFACE
-    ${ALL_FILES}
-    # Also include main entry point
-    ${SOURCES_DIR}/internal/catch_main.cpp
-  )
-  target_include_directories(Catch2_buildall_interface
-    INTERFACE
-      $<BUILD_INTERFACE:${SOURCES_DIR}/..>
-      $<BUILD_INTERFACE:${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)
+if (CATCH_BUILD_EXAMPLES OR CATCH_BUILD_EXTRA_TESTS)
+    add_library(Catch2_buildall_interface INTERFACE)
+    target_sources(Catch2_buildall_interface INTERFACE
+      ${ALL_FILES}
+      # Also include main entry point
+      ${SOURCES_DIR}/internal/catch_main.cpp
+    )
+    target_include_directories(Catch2_buildall_interface
+      INTERFACE
+        $<BUILD_INTERFACE:${SOURCES_DIR}/..>
+        $<BUILD_INTERFACE:${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
+    )
 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)
-  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 (BUILD_SHARED_LIBS)
     set_target_properties(Catch2 Catch2WithMain
       PROPERTIES
-        CXX_VISIBILITY_PRESET "default"
-        VISIBILITY_INLINES_HIDDEN OFF
+        WINDOWS_EXPORT_ALL_SYMBOLS ON
     )
-    message(WARNING "Setting Catch2's visibility to default."
-                    " Hidden visibility is not supported.")
-  endif()
+
+    get_target_property(_VisPreset Catch2 CXX_VISIBILITY_PRESET)
+    if (NOT MSVC AND _VisPreset STREQUAL "hidden")
+        set_target_properties(Catch2 Catch2WithMain
+          PROPERTIES
+            CXX_VISIBILITY_PRESET "default"
+            VISIBILITY_INLINES_HIDDEN OFF
+        )
+        message(WARNING "Setting Catch2's visibility to default."
+                        " Hidden visibility is not supported.")
+    endif()
 endif()

src/catch2/benchmark/catch_benchmark.hpp

@@ -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_v<Fun, Benchmark>, int> = 0>
+            template <typename Fun, std::enable_if_t<!Detail::is_related<Fun, Benchmark>::value, int> = 0>
                 Benchmark & operator=(Fun func) {
                 auto const* cfg = getCurrentContext().getConfig();
                 if (!cfg->skipBenchmarks()) {

src/catch2/benchmark/detail/catch_benchmark_function.hpp

@@ -21,7 +21,8 @@ namespace Catch {
     namespace Benchmark {
         namespace Detail {
             template <typename T, typename U>
-            static constexpr bool is_related_v = std::is_same<std::decay_t<T>, std::decay_t<U>>::value;
+            struct is_related
+                : std::is_same<std::decay_t<T>, std::decay_t<U>> {};
 
             /// 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
@@ -62,7 +63,7 @@ namespace Catch {
                 BenchmarkFunction();
 
                 template <typename Fun,
-                    std::enable_if_t<!is_related_v<Fun, BenchmarkFunction>, int> = 0>
+                    std::enable_if_t<!is_related<Fun, BenchmarkFunction>::value, int> = 0>
                     BenchmarkFunction(Fun&& fun)
                     : f(new model<std::decay_t<Fun>>(CATCH_FORWARD(fun))) {}
 

src/catch2/benchmark/detail/catch_estimate_clock.hpp

@@ -15,6 +15,7 @@
 #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>

src/catch2/benchmark/detail/catch_timing.hpp

@@ -13,6 +13,8 @@
 #include <catch2/benchmark/catch_clock.hpp>
 #include <catch2/benchmark/detail/catch_complete_invoke.hpp>
 
+#include <type_traits>
+
 namespace Catch {
     namespace Benchmark {
         template <typename Result>

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::Randomized;
+        TestRunOrder runOrder = TestRunOrder::Declared;
         ColourMode defaultColourMode = ColourMode::PlatformDefault;
         WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
 

src/catch2/catch_session.cpp

@@ -25,6 +25,7 @@
 #include <catch2/internal/catch_stdstreams.hpp>
 #include <catch2/internal/catch_istream.hpp>
 
+#include <algorithm>
 #include <cassert>
 #include <exception>
 #include <iomanip>

src/catch2/catch_tostring.cpp

@@ -11,6 +11,7 @@
 #include <catch2/internal/catch_context.hpp>
 #include <catch2/internal/catch_polyfills.hpp>
 
+#include <cmath>
 #include <iomanip>
 
 namespace Catch {

src/catch2/catch_tostring.hpp

@@ -64,14 +64,18 @@ namespace Catch {
           return rawMemoryToString( &object, sizeof(object) );
         }
 
-        template<typename T,typename = void>
-        static constexpr bool IsStreamInsertable_v = false;
+        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>
-        static constexpr bool IsStreamInsertable_v<
-            T,
-            decltype( void( std::declval<std::ostream&>() << std::declval<T>() ) )> =
-            true;
+            template<typename, typename>
+            static auto test(...)->std::false_type;
+
+        public:
+            static const bool value = decltype(test<std::ostream, const T&>(0))::value;
+        };
 
         template<typename E>
         std::string convertUnknownEnumToString( E e );
@@ -116,7 +120,7 @@ namespace Catch {
     struct StringMaker {
         template <typename Fake = T>
         static
-        std::enable_if_t<::Catch::Detail::IsStreamInsertable_v<Fake>, std::string>
+        std::enable_if_t<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>
             convert(const Fake& value) {
                 ReusableStringStream rss;
                 // NB: call using the function-like syntax to avoid ambiguity with
@@ -127,7 +131,7 @@ namespace Catch {
 
         template <typename Fake = T>
         static
-        std::enable_if_t<!::Catch::Detail::IsStreamInsertable_v<Fake>, std::string>
+        std::enable_if_t<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>
             convert( const Fake& value ) {
 #if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
             return Detail::convertUnstreamable(value);
@@ -519,7 +523,7 @@ namespace Catch {
     }
 
     template<typename R>
-    struct StringMaker<R, std::enable_if_t<is_range<R>::value && !::Catch::Detail::IsStreamInsertable_v<R>>> {
+    struct StringMaker<R, std::enable_if_t<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>> {
         static std::string convert( R const& range ) {
             return rangeToString( range );
         }
@@ -630,11 +634,7 @@ struct ratio_string<std::milli> {
 
 #ifdef _MSC_VER
             std::tm timeInfo = {};
-            const auto err = gmtime_s(&timeInfo, &converted);
-            if ( err ) {
-                return "gmtime from provided timepoint has failed. This "
-                       "happens e.g. with pre-1970 dates using Microsoft libc";
-            }
+            gmtime_s(&timeInfo, &converted);
 #else
             std::tm* timeInfo = std::gmtime(&converted);
 #endif

src/catch2/catch_version.cpp

@@ -36,7 +36,7 @@ namespace Catch {
     }
 
     Version const& libraryVersion() {
-        static Version version( 3, 8, 1, "", 0 );
+        static Version version( 3, 7, 1, "", 0 );
         return version;
     }
 

src/catch2/catch_version_macros.hpp

@@ -9,7 +9,7 @@
 #define CATCH_VERSION_MACROS_HPP_INCLUDED
 
 #define CATCH_VERSION_MAJOR 3
-#define CATCH_VERSION_MINOR 8
+#define CATCH_VERSION_MINOR 7
 #define CATCH_VERSION_PATCH 1
 
 #endif // CATCH_VERSION_MACROS_HPP_INCLUDED

src/catch2/interfaces/catch_interfaces_config.hpp

@@ -12,6 +12,7 @@
 #include <catch2/internal/catch_stringref.hpp>
 
 #include <chrono>
+#include <iosfwd>
 #include <string>
 #include <vector>
 

src/catch2/interfaces/catch_interfaces_reporter.hpp

@@ -20,6 +20,7 @@
 #include <map>
 #include <string>
 #include <vector>
+#include <iosfwd>
 
 namespace Catch {
 

src/catch2/internal/catch_compiler_capabilities.hpp

@@ -103,16 +103,8 @@
 #    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_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\"" )

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 accommodate these use cases, decomposer ended up rather complex.
+ * To accomodate these use cases, decomposer ended up rather complex.
  *
  * 1) These types are handled by adding SFINAE overloads to our comparison
  *    operators, checking whether `T == U` are comparable with the given
@@ -163,7 +163,7 @@ namespace Catch {
     public:
         constexpr auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
         constexpr auto getResult() const -> bool { return m_result; }
-        //! This function **has** to be overridden by the derived class.
+        //! This function **has** to be overriden by the derived class.
         virtual void streamReconstructedExpression( std::ostream& os ) const;
 
         constexpr ITransientExpression( bool isBinaryExpression, bool result )

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> // for `std::exception` in no-exception configuration
+#include <exception>
 
 namespace Catch {
 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)

src/catch2/internal/catch_exception_translator_registry.hpp

@@ -11,6 +11,7 @@
 #include <catch2/interfaces/catch_interfaces_exception.hpp>
 #include <catch2/internal/catch_unique_ptr.hpp>
 
+#include <vector>
 #include <string>
 
 namespace Catch {

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 {

src/catch2/internal/catch_istream.cpp

@@ -14,6 +14,8 @@
 
 #include <cstdio>
 #include <fstream>
+#include <sstream>
+#include <vector>
 
 namespace Catch {
 

src/catch2/internal/catch_istream.hpp

@@ -12,6 +12,8 @@
 #include <catch2/internal/catch_unique_ptr.hpp>
 
 #include <iosfwd>
+#include <cstddef>
+#include <ostream>
 #include <string>
 
 namespace Catch {

src/catch2/internal/catch_run_context.cpp

@@ -361,7 +361,7 @@ namespace Catch {
         auto& currentTracker = m_trackerContext.currentTracker();
         assert(
             currentTracker.nameAndLocation() != nameAndLoc &&
-            "Trying to create tracker for a generator that already has one" );
+            "Trying to create tracker for a genreator that already has one" );
 
         auto newTracker = Catch::Detail::make_unique<Generators::GeneratorTracker>(
             CATCH_MOVE(nameAndLoc), m_trackerContext, &currentTracker );

src/catch2/internal/catch_section.hpp

@@ -62,7 +62,7 @@ namespace Catch {
 #else
 
 // These section definitions imply that at most one section at one level
-// will be entered (because only one section's __LINE__ can be equal to
+// will be intered (because only one section's __LINE__ can be equal to
 // the dummy `catchInternalSectionHint` variable from `TEST_CASE`).
 
 namespace Catch {

src/catch2/internal/catch_sharding.hpp

@@ -9,6 +9,7 @@
 #define CATCH_SHARDING_HPP_INCLUDED
 
 #include <cassert>
+#include <cmath>
 #include <algorithm>
 
 namespace Catch {

src/catch2/internal/catch_string_manip.cpp

@@ -74,7 +74,7 @@ namespace Catch {
         std::string origStr = CATCH_MOVE(str);
         str.clear();
         // There is at least one replacement, so reserve with the best guess
-        // we can make without actually counting the number of occurrences.
+        // we can make without actually counting the number of occurences.
         str.reserve(origStr.size() - replaceThis.size() + withThis.size());
         do {
             str.append(origStr, copyBegin, i-copyBegin );

src/catch2/internal/catch_stringref.cpp

@@ -10,6 +10,7 @@
 #include <algorithm>
 #include <ostream>
 #include <cstring>
+#include <cstdint>
 
 namespace Catch {
     StringRef::StringRef( char const* rawChars ) noexcept

src/catch2/internal/catch_unreachable.cpp

@@ -0,0 +1,17 @@
+
+//              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_unreachable.hpp>
+
+namespace Catch {
+    namespace Detail {
+
+        void unreachable(){}
+
+    }
+} // end namespace Catch

src/catch2/internal/catch_unreachable.hpp

@@ -0,0 +1,21 @@
+
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#ifndef CATCH_UNREACHABLE_HPP_INCLUDED
+#define CATCH_UNREACHABLE_HPP_INCLUDED
+
+namespace Catch {
+
+    namespace Detail {
+        // TODO: explain
+        [[noreturn]] void unreachable();
+
+    }
+
+} // end namespace Catch
+
+#endif // CATCH_UNREACHABLE_HPP_INCLUDED

src/catch2/matchers/catch_matchers_container_properties.hpp

@@ -79,7 +79,7 @@ namespace Catch {
         //! Creates a matcher that accepts ranges/containers with specific size
         HasSizeMatcher SizeIs(std::size_t sz);
         template <typename Matcher>
-        std::enable_if_t<Detail::is_matcher_v<Matcher>,
+        std::enable_if_t<Detail::is_matcher<Matcher>::value,
         SizeMatchesMatcher<Matcher>> SizeIs(Matcher&& m) {
             return SizeMatchesMatcher<Matcher>{CATCH_FORWARD(m)};
         }

src/catch2/matchers/catch_matchers_contains.hpp

@@ -11,8 +11,8 @@
 #include <catch2/matchers/catch_matchers_templated.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>
 
+#include <algorithm>
 #include <functional>
-#include <type_traits>
 
 namespace Catch {
     namespace Matchers {
@@ -74,14 +74,14 @@ namespace Catch {
          * Uses `std::equal_to` to do the comparison
          */
         template <typename T>
-        std::enable_if_t<!Detail::is_matcher_v<T>,
+        std::enable_if_t<!Detail::is_matcher<T>::value,
         ContainsElementMatcher<T, std::equal_to<>>> Contains(T&& elem) {
             return { CATCH_FORWARD(elem), std::equal_to<>{} };
         }
 
         //! Creates a matcher that checks whether a range contains element matching a matcher
         template <typename Matcher>
-        std::enable_if_t<Detail::is_matcher_v<Matcher>,
+        std::enable_if_t<Detail::is_matcher<Matcher>::value,
         ContainsMatcherMatcher<Matcher>> Contains(Matcher&& matcher) {
             return { CATCH_FORWARD(matcher) };
         }

src/catch2/matchers/catch_matchers_range_equals.hpp

@@ -11,7 +11,8 @@
 #include <catch2/internal/catch_is_permutation.hpp>
 #include <catch2/matchers/catch_matchers_templated.hpp>
 
-#include <functional>
+#include <algorithm>
+#include <utility>
 
 namespace Catch {
     namespace Matchers {

src/catch2/matchers/catch_matchers_templated.hpp

@@ -58,19 +58,19 @@ namespace Matchers {
         }
 
         template<typename T>
-        static constexpr bool is_generic_matcher_v = std::is_base_of<
+        using is_generic_matcher = std::is_base_of<
             Catch::Matchers::MatcherGenericBase,
             std::remove_cv_t<std::remove_reference_t<T>>
-        >::value;
+        >;
 
         template<typename... Ts>
-        static constexpr bool are_generic_matchers_v = Catch::Detail::conjunction<std::integral_constant<bool,is_generic_matcher_v<Ts>>...>::value;
+        using are_generic_matchers = Catch::Detail::conjunction<is_generic_matcher<Ts>...>;
 
         template<typename T>
-        static constexpr bool is_matcher_v = std::is_base_of<
+        using is_matcher = std::is_base_of<
             Catch::Matchers::MatcherUntypedBase,
             std::remove_cv_t<std::remove_reference_t<T>>
-        >::value;
+        >;
 
 
         template<std::size_t N, typename Arg>
@@ -143,7 +143,7 @@ namespace Matchers {
 
             //! Avoids type nesting for `GenericAllOf && some matcher` case
             template<typename MatcherRHS>
-            friend std::enable_if_t<is_matcher_v<MatcherRHS>,
+            friend std::enable_if_t<is_matcher<MatcherRHS>::value,
             MatchAllOfGeneric<MatcherTs..., MatcherRHS>> operator && (
                     MatchAllOfGeneric<MatcherTs...>&& lhs,
                     MatcherRHS const& rhs) {
@@ -152,7 +152,7 @@ namespace Matchers {
 
             //! Avoids type nesting for `some matcher && GenericAllOf` case
             template<typename MatcherLHS>
-            friend std::enable_if_t<is_matcher_v<MatcherLHS>,
+            friend std::enable_if_t<is_matcher<MatcherLHS>::value,
             MatchAllOfGeneric<MatcherLHS, MatcherTs...>> operator && (
                     MatcherLHS const& lhs,
                     MatchAllOfGeneric<MatcherTs...>&& rhs) {
@@ -197,7 +197,7 @@ namespace Matchers {
 
             //! Avoids type nesting for `GenericAnyOf || some matcher` case
             template<typename MatcherRHS>
-            friend std::enable_if_t<is_matcher_v<MatcherRHS>,
+            friend std::enable_if_t<is_matcher<MatcherRHS>::value,
             MatchAnyOfGeneric<MatcherTs..., MatcherRHS>> operator || (
                     MatchAnyOfGeneric<MatcherTs...>&& lhs,
                     MatcherRHS const& rhs) {
@@ -206,7 +206,7 @@ namespace Matchers {
 
             //! Avoids type nesting for `some matcher || GenericAnyOf` case
             template<typename MatcherLHS>
-            friend std::enable_if_t<is_matcher_v<MatcherLHS>,
+            friend std::enable_if_t<is_matcher<MatcherLHS>::value,
             MatchAnyOfGeneric<MatcherLHS, MatcherTs...>> operator || (
                 MatcherLHS const& lhs,
                 MatchAnyOfGeneric<MatcherTs...>&& rhs) {
@@ -246,20 +246,20 @@ namespace Matchers {
 
     // compose only generic matchers
     template<typename MatcherLHS, typename MatcherRHS>
-    std::enable_if_t<Detail::are_generic_matchers_v<MatcherLHS, MatcherRHS>, Detail::MatchAllOfGeneric<MatcherLHS, MatcherRHS>>
+    std::enable_if_t<Detail::are_generic_matchers<MatcherLHS, MatcherRHS>::value, Detail::MatchAllOfGeneric<MatcherLHS, MatcherRHS>>
         operator && (MatcherLHS const& lhs, MatcherRHS const& rhs) {
         return { lhs, rhs };
     }
 
     template<typename MatcherLHS, typename MatcherRHS>
-    std::enable_if_t<Detail::are_generic_matchers_v<MatcherLHS, MatcherRHS>, Detail::MatchAnyOfGeneric<MatcherLHS, MatcherRHS>>
+    std::enable_if_t<Detail::are_generic_matchers<MatcherLHS, MatcherRHS>::value, Detail::MatchAnyOfGeneric<MatcherLHS, MatcherRHS>>
         operator || (MatcherLHS const& lhs, MatcherRHS const& rhs) {
         return { lhs, rhs };
     }
 
     //! Wrap provided generic matcher in generic negator
     template<typename MatcherT>
-    std::enable_if_t<Detail::is_generic_matcher_v<MatcherT>, Detail::MatchNotOfGeneric<MatcherT>>
+    std::enable_if_t<Detail::is_generic_matcher<MatcherT>::value, Detail::MatchNotOfGeneric<MatcherT>>
         operator ! (MatcherT const& matcher) {
         return Detail::MatchNotOfGeneric<MatcherT>{matcher};
     }
@@ -267,25 +267,25 @@ namespace Matchers {
 
     // compose mixed generic and non-generic matchers
     template<typename MatcherLHS, typename ArgRHS>
-    std::enable_if_t<Detail::is_generic_matcher_v<MatcherLHS>, Detail::MatchAllOfGeneric<MatcherLHS, MatcherBase<ArgRHS>>>
+    std::enable_if_t<Detail::is_generic_matcher<MatcherLHS>::value, Detail::MatchAllOfGeneric<MatcherLHS, MatcherBase<ArgRHS>>>
         operator && (MatcherLHS const& lhs, MatcherBase<ArgRHS> const& rhs) {
         return { lhs, rhs };
     }
 
     template<typename ArgLHS, typename MatcherRHS>
-    std::enable_if_t<Detail::is_generic_matcher_v<MatcherRHS>, Detail::MatchAllOfGeneric<MatcherBase<ArgLHS>, MatcherRHS>>
+    std::enable_if_t<Detail::is_generic_matcher<MatcherRHS>::value, Detail::MatchAllOfGeneric<MatcherBase<ArgLHS>, MatcherRHS>>
         operator && (MatcherBase<ArgLHS> const& lhs, MatcherRHS const& rhs) {
         return { lhs, rhs };
     }
 
     template<typename MatcherLHS, typename ArgRHS>
-    std::enable_if_t<Detail::is_generic_matcher_v<MatcherLHS>, Detail::MatchAnyOfGeneric<MatcherLHS, MatcherBase<ArgRHS>>>
+    std::enable_if_t<Detail::is_generic_matcher<MatcherLHS>::value, Detail::MatchAnyOfGeneric<MatcherLHS, MatcherBase<ArgRHS>>>
         operator || (MatcherLHS const& lhs, MatcherBase<ArgRHS> const& rhs) {
         return { lhs, rhs };
     }
 
     template<typename ArgLHS, typename MatcherRHS>
-    std::enable_if_t<Detail::is_generic_matcher_v<MatcherRHS>, Detail::MatchAnyOfGeneric<MatcherBase<ArgLHS>, MatcherRHS>>
+    std::enable_if_t<Detail::is_generic_matcher<MatcherRHS>::value, Detail::MatchAnyOfGeneric<MatcherBase<ArgLHS>, MatcherRHS>>
         operator || (MatcherBase<ArgLHS> const& lhs, MatcherRHS const& rhs) {
         return { lhs, rhs };
     }

src/catch2/meson.build

@@ -16,7 +16,6 @@ configure_file(
   format: 'cmake@',
   install_dir: get_option('includedir') / 'catch2',
   configuration: conf_data,
-  install: get_option('install')
 )
 
 fs = import('fs')
@@ -340,9 +339,7 @@ foreach file : headers
     endif
   endforeach
 
-  if get_option('install')
-    install_headers(file, subdir: join_paths(include_subdir, folder))
-  endif
+  install_headers(file, subdir: join_paths(include_subdir, folder))
 endforeach
 
 catch2_dependencies = []
@@ -359,7 +356,7 @@ catch2 = static_library(
   sources,
   dependencies: catch2_dependencies,
   include_directories: '..',
-  install: get_option('install'),
+  install: true,
 )
 
 catch2_dep = declare_dependency(
@@ -367,21 +364,19 @@ catch2_dep = declare_dependency(
   include_directories: '..',
 )
 
-if get_option('install')
-  pkg.generate(
-    catch2,
-    filebase: 'catch2',
-    description: 'A modern, C++-native, test framework for C++14 and above',
-    url: 'https://github.com/catchorg/Catch2',
-  )
-endif
+pkg.generate(
+  catch2,
+  filebase: 'catch2',
+  description: 'A modern, C++-native, test framework for C++14 and above',
+  url: 'https://github.com/catchorg/Catch2',
+)
 
 catch2_with_main = static_library(
   'Catch2Main',
   'internal/catch_main.cpp',
   link_with: catch2,
   include_directories: '..',
-  install: get_option('install'),
+  install: true,
 )
 
 catch2_with_main_dep = declare_dependency(
@@ -389,11 +384,9 @@ catch2_with_main_dep = declare_dependency(
   include_directories: '..',
 )
 
-if get_option('install')
-  pkg.generate(
-    catch2_with_main,
-    filebase: 'catch2-with-main',
-    description: 'A modern, C++-native, test framework for C++14 and above (links in default main)',
-    requires: 'catch2 = ' + meson.project_version(),
-  )
-endif
+pkg.generate(
+  catch2_with_main,
+  filebase: 'catch2-with-main',
+  description: 'A modern, C++-native, test framework for C++14 and above (links in default main)',
+  requires: 'catch2 = ' + meson.project_version(),
+)

tests/CMakeLists.txt

@@ -1,6 +1,6 @@
 include(CatchMiscFunctions)
 
-if(CATCH_BUILD_SURROGATES)
+if (CATCH_BUILD_SURROGATES)
   message(STATUS "Configuring targets for surrogate TUs")
 
   # If the folder does not exist before we ask for output redirect to
@@ -11,9 +11,11 @@ if(CATCH_BUILD_SURROGATES)
   # Returns the path to the generated file.
   function(createSurrogateFileTarget sourceHeader pathToFile)
     set(pathPrefix ${PROJECT_SOURCE_DIR}/src)
+
     file(RELATIVE_PATH includePath ${pathPrefix} ${sourceHeader})
 
     get_filename_component(basicFileName "${sourceHeader}" NAME_WE)
+
     set(surrogateFilePath ${CMAKE_CURRENT_BINARY_DIR}/surrogates/surrogate_${basicFileName}.cpp)
 
     add_custom_command(
@@ -39,9 +41,10 @@ if(CATCH_BUILD_SURROGATES)
     set(${OutArg} ${AllHeaders} PARENT_SCOPE)
   endfunction()
 
+
   ExtractCatch2Headers(mainHeaders)
 
-  if(NOT mainHeaders)
+  if (NOT mainHeaders)
     message(FATAL_ERROR "No headers in the main target were detected. Something is broken.")
   endif()
 
@@ -50,10 +53,12 @@ if(CATCH_BUILD_SURROGATES)
     list(APPEND surrogateFiles ${pathToGeneratedFile})
   endforeach()
 
+
   add_executable(Catch2SurrogateTarget
     ${surrogateFiles}
   )
   target_link_libraries(Catch2SurrogateTarget PRIVATE Catch2WithMain)
+
 endif()
 
 ####
@@ -61,72 +66,75 @@ endif()
 # We need to disable <UseFullPaths> property, but CMake doesn't support it
 # until 3.13 (not yet released)
 ####
-if(MSVC)
-  configure_file(${CATCH_DIR}/tools/misc/SelfTest.vcxproj.user ${CMAKE_BINARY_DIR}/tests COPYONLY)
+if (MSVC)
+configure_file(${CATCH_DIR}/tools/misc/SelfTest.vcxproj.user
+               ${CMAKE_BINARY_DIR}/tests
+               COPYONLY)
 endif() #Temporary workaround
 
+
 # define the sources of the self test
 # Please keep these ordered alphabetically
 set(TEST_SOURCES
-  ${SELF_TEST_DIR}/TestRegistrations.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/Algorithms.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/AssertionHandler.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/Clara.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/CmdLine.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/CmdLineHelpers.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/ColourImpl.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/Details.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/FloatingPoint.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/GeneratorsImpl.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/Integer.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/InternalBenchmark.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/Json.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/Parse.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/PartTracker.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/RandomNumberGeneration.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/Reporters.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/Tag.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/TestCaseInfoHasher.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/TestSpec.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/TestSpecParser.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/TextFlow.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/Sharding.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/Stream.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/String.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/StringManip.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/Xml.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/Traits.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/ToString.tests.cpp
-  ${SELF_TEST_DIR}/IntrospectiveTests/UniquePtr.tests.cpp
-  ${SELF_TEST_DIR}/helpers/parse_test_spec.cpp
-  ${SELF_TEST_DIR}/TimingTests/Sleep.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/Approx.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/BDD.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/Benchmark.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/Class.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/Compilation.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/Condition.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/Decomposition.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/EnumToString.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/Exception.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/Generators.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/Message.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/Misc.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/Skip.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/ToStringByte.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/ToStringChrono.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/ToStringGeneral.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/ToStringOptional.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/ToStringPair.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/ToStringTuple.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/ToStringVariant.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/ToStringVector.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/ToStringWhich.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/Tricky.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/VariadicMacros.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/MatchersRanges.tests.cpp
-  ${SELF_TEST_DIR}/UsageTests/Matchers.tests.cpp
-)
+        ${SELF_TEST_DIR}/TestRegistrations.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/Algorithms.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/AssertionHandler.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/Clara.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/CmdLine.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/CmdLineHelpers.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/ColourImpl.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/Details.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/FloatingPoint.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/GeneratorsImpl.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/Integer.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/InternalBenchmark.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/Json.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/Parse.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/PartTracker.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/RandomNumberGeneration.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/Reporters.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/Tag.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/TestCaseInfoHasher.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/TestSpec.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/TestSpecParser.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/TextFlow.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/Sharding.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/Stream.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/String.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/StringManip.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/Xml.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/Traits.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/ToString.tests.cpp
+        ${SELF_TEST_DIR}/IntrospectiveTests/UniquePtr.tests.cpp
+        ${SELF_TEST_DIR}/helpers/parse_test_spec.cpp
+        ${SELF_TEST_DIR}/TimingTests/Sleep.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/Approx.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/BDD.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/Benchmark.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/Class.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/Compilation.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/Condition.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/Decomposition.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/EnumToString.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/Exception.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/Generators.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/Message.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/Misc.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/Skip.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/ToStringByte.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/ToStringChrono.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/ToStringGeneral.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/ToStringOptional.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/ToStringPair.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/ToStringTuple.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/ToStringVariant.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/ToStringVector.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/ToStringWhich.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/Tricky.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/VariadicMacros.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/MatchersRanges.tests.cpp
+        ${SELF_TEST_DIR}/UsageTests/Matchers.tests.cpp
+        )
 
 set(TEST_HEADERS
   ${SELF_TEST_DIR}/helpers/parse_test_spec.hpp
@@ -134,45 +142,46 @@ set(TEST_HEADERS
   ${SELF_TEST_DIR}/helpers/type_with_lit_0_comparisons.hpp
 )
 
+
 # Specify the headers, too, so CLion recognises them as project files
 set(HEADERS
-  ${TOP_LEVEL_HEADERS}
-  ${EXTERNAL_HEADERS}
-  ${INTERNAL_HEADERS}
-  ${REPORTER_HEADERS}
-  ${BENCHMARK_HEADERS}
-  ${BENCHMARK_SOURCES}
+        ${TOP_LEVEL_HEADERS}
+        ${EXTERNAL_HEADERS}
+        ${INTERNAL_HEADERS}
+        ${REPORTER_HEADERS}
+        ${BENCHMARK_HEADERS}
+        ${BENCHMARK_SOURCES}
 )
 
 # Provide some groupings for IDEs
-#source_group("benchmark" FILES ${BENCHMARK_HEADERS} ${BENCHMARK_SOURCES})
-#source_group("Tests" FILES ${TEST_SOURCES})
+#SOURCE_GROUP("benchmark" FILES ${BENCHMARK_HEADERS} ${BENCHMARK_SOURCES})
+#SOURCE_GROUP("Tests" FILES ${TEST_SOURCES})
 
 include(CTest)
 
 add_executable(SelfTest ${TEST_SOURCES} ${TEST_HEADERS})
 target_include_directories(SelfTest PRIVATE ${SELF_TEST_DIR})
 target_link_libraries(SelfTest PRIVATE Catch2WithMain)
-if(BUILD_SHARED_LIBS AND WIN32)
-  add_custom_command(TARGET SelfTest PRE_LINK
-    COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:Catch2>
-    $<TARGET_FILE:Catch2WithMain> $<TARGET_FILE_DIR:SelfTest>
-  )
+if (BUILD_SHARED_LIBS AND WIN32)
+    add_custom_command(TARGET SelfTest PRE_LINK
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:Catch2>
+        $<TARGET_FILE:Catch2WithMain> $<TARGET_FILE_DIR:SelfTest>
+    )
 endif()
 
-if(CATCH_ENABLE_COVERAGE)
-  set(ENABLE_COVERAGE ON CACHE BOOL "Enable coverage build." FORCE)
-  find_package(codecov)
-  add_coverage(SelfTest)
-  list(APPEND LCOV_REMOVE_PATTERNS "'/usr/*'")
-  coverage_evaluate()
+if (CATCH_ENABLE_COVERAGE)
+    set(ENABLE_COVERAGE ON CACHE BOOL "Enable coverage build." FORCE)
+    find_package(codecov)
+    add_coverage(SelfTest)
+    list(APPEND LCOV_REMOVE_PATTERNS "'/usr/*'")
+    coverage_evaluate()
 endif()
 
 # configure unit tests via CTest
 add_test(NAME RunTests COMMAND $<TARGET_FILE:SelfTest> --order rand --rng-seed time)
 set_tests_properties(RunTests PROPERTIES
-  FAIL_REGULAR_EXPRESSION "Filters:"
-  COST 15
+    FAIL_REGULAR_EXPRESSION "Filters:"
+    COST 15
 )
 
 # Because CTest does not allow us to check both return code _and_ expected
@@ -180,8 +189,8 @@ set_tests_properties(RunTests PROPERTIES
 # the output, the second time we check the exit code.
 add_test(NAME List::Tests::Output COMMAND $<TARGET_FILE:SelfTest> --list-tests --verbosity high)
 set_tests_properties(List::Tests::Output PROPERTIES
-  PASS_REGULAR_EXPRESSION "[0-9]+ test cases"
-  FAIL_REGULAR_EXPRESSION "Hidden Test"
+    PASS_REGULAR_EXPRESSION "[0-9]+ test cases"
+    FAIL_REGULAR_EXPRESSION "Hidden Test"
 )
 # This should be equivalent to the old --list-test-names-only and be usable
 # with --input-file.
@@ -189,34 +198,35 @@ add_test(NAME List::Tests::Quiet COMMAND $<TARGET_FILE:SelfTest> --list-tests --
 # Sadly we cannot ask for start-of-line and end-of-line in a ctest regex,
 # so we fail if we see space/tab at the start...
 set_tests_properties(List::Tests::Quiet PROPERTIES
-  PASS_REGULAR_EXPRESSION "\"#1905 -- test spec parser properly clears internal state between compound tests\"[\r\n]"
-  FAIL_REGULAR_EXPRESSION "[ \t]\"#1905 -- test spec parser properly clears internal state between compound tests\""
+    PASS_REGULAR_EXPRESSION "\"#1905 -- test spec parser properly clears internal state between compound tests\"[\r\n]"
+    FAIL_REGULAR_EXPRESSION "[ \t]\"#1905 -- test spec parser properly clears internal state between compound tests\""
 )
 add_test(NAME List::Tests::ExitCode COMMAND $<TARGET_FILE:SelfTest> --list-tests --verbosity high)
 add_test(NAME List::Tests::XmlOutput COMMAND $<TARGET_FILE:SelfTest> --list-tests --verbosity high -r xml)
 set_tests_properties(List::Tests::XmlOutput PROPERTIES
-  PASS_REGULAR_EXPRESSION "<Line>[0-9]+</Line>"
-  FAIL_REGULAR_EXPRESSION "[0-9]+ test cases"
+    PASS_REGULAR_EXPRESSION "<Line>[0-9]+</Line>"
+    FAIL_REGULAR_EXPRESSION "[0-9]+ test cases"
 )
 
 add_test(NAME List::Tags::Output COMMAND $<TARGET_FILE:SelfTest> --list-tags)
 set_tests_properties(List::Tags::Output PROPERTIES
-  PASS_REGULAR_EXPRESSION "[0-9]+ tags"
-  FAIL_REGULAR_EXPRESSION "\\[\\.\\]")
+    PASS_REGULAR_EXPRESSION "[0-9]+ tags"
+    FAIL_REGULAR_EXPRESSION "\\[\\.\\]")
 add_test(NAME List::Tags::ExitCode COMMAND $<TARGET_FILE:SelfTest> --list-tags)
 add_test(NAME List::Tags::XmlOutput COMMAND $<TARGET_FILE:SelfTest> --list-tags -r xml)
 set_tests_properties(List::Tags::XmlOutput PROPERTIES
-  PASS_REGULAR_EXPRESSION "<Count>18</Count>"
-  FAIL_REGULAR_EXPRESSION "[0-9]+ tags"
+    PASS_REGULAR_EXPRESSION "<Count>18</Count>"
+    FAIL_REGULAR_EXPRESSION "[0-9]+ tags"
 )
 
+
 add_test(NAME List::Reporters::Output COMMAND $<TARGET_FILE:SelfTest> --list-reporters)
 set_tests_properties(List::Reporters::Output PROPERTIES PASS_REGULAR_EXPRESSION "Available reporters:")
 add_test(NAME List::Reporters::ExitCode COMMAND $<TARGET_FILE:SelfTest> --list-reporters)
 add_test(NAME List::Reporters::XmlOutput COMMAND $<TARGET_FILE:SelfTest> --list-reporters -r xml)
 set_tests_properties(List::Reporters::XmlOutput PROPERTIES
-  PASS_REGULAR_EXPRESSION "<Name>compact</Name>"
-  FAIL_REGULAR_EXPRESSION "Available reporters:"
+    PASS_REGULAR_EXPRESSION "<Name>compact</Name>"
+    FAIL_REGULAR_EXPRESSION "Available reporters:"
 )
 
 add_test(NAME List::Listeners::Output
@@ -253,8 +263,8 @@ add_test(NAME TestSpecs::CombiningMatchingAndNonMatchingIsOk-1 COMMAND $<TARGET_
 
 add_test(NAME TestSpecs::CombiningMatchingAndNonMatchingIsOk-2 COMMAND $<TARGET_FILE:SelfTest> Tracker, "___nonexistent_test___")
 set_tests_properties(TestSpecs::CombiningMatchingAndNonMatchingIsOk-2 PROPERTIES
-  PASS_REGULAR_EXPRESSION "No test cases matched '\"___nonexistent_test___\"'"
-  FAIL_REGULAR_EXPRESSION "No tests ran"
+    PASS_REGULAR_EXPRESSION "No test cases matched '\"___nonexistent_test___\"'"
+    FAIL_REGULAR_EXPRESSION "No tests ran"
 )
 
 add_test(NAME TestSpecs::NoMatchedTestsFail
@@ -273,7 +283,7 @@ add_test(NAME TestSpecs::OverrideAllSkipFailure
 )
 
 add_test(NAME TestSpecs::NonMatchingTestSpecIsRoundTrippable
-  COMMAND $<TARGET_FILE:SelfTest> Tracker, "this test does not exist" "[nor does this tag]"
+    COMMAND $<TARGET_FILE:SelfTest> Tracker, "this test does not exist" "[nor does this tag]"
 )
 set_tests_properties(TestSpecs::NonMatchingTestSpecIsRoundTrippable
   PROPERTIES
@@ -437,6 +447,7 @@ set_tests_properties("Benchmarking::SkipBenchmarkMacros"
     FAIL_REGULAR_EXPRESSION "benchmark name"
 )
 
+
 add_test(NAME "Benchmarking::FailureReporting::OptimizedOut"
   COMMAND
     $<TARGET_FILE:SelfTest> "Failing benchmarks" -c "empty" -r xml
@@ -499,7 +510,7 @@ set_tests_properties("ErrorHandling::InvalidTestSpecExitsEarly"
     FAIL_REGULAR_EXPRESSION "No tests ran"
 )
 
-if(MSVC)
+if (MSVC)
   set(_NullFile "NUL")
 else()
   set(_NullFile "/dev/null")
@@ -508,7 +519,7 @@ endif()
 # This test checks that there is nothing written out from the process,
 # but if CMake is running the tests under Valgrind or similar tool, then
 # that will write its own output to stdout and the test would fail.
-if(NOT MEMORYCHECK_COMMAND)
+if (NOT MEMORYCHECK_COMMAND)
   add_test(NAME "MultiReporter::CapturingReportersDontPropagateStdOut"
     COMMAND
       $<TARGET_FILE:SelfTest> "Sends stuff to stdout and stderr"
@@ -597,71 +608,76 @@ set_tests_properties("Reporters::JUnit::NamespacesAreNormalized"
     PASS_REGULAR_EXPRESSION "testcase classname=\"SelfTest(\.exe)?\\.A\\.B\\.TestClass\""
 )
 
-if(CATCH_ENABLE_CONFIGURE_TESTS)
-  foreach(testName "DefaultReporter" "Disable" "DisableStringification"
-                    "ExperimentalRedirect")
-    add_test(NAME "CMakeConfig::${testName}"
+if (CATCH_ENABLE_CONFIGURE_TESTS)
+    foreach(testName "DefaultReporter" "Disable" "DisableStringification"
+                     "ExperimentalRedirect")
+
+        add_test(NAME "CMakeConfig::${testName}"
+          COMMAND
+            "${PYTHON_EXECUTABLE}" "${CMAKE_CURRENT_LIST_DIR}/TestScripts/testConfigure${testName}.py" "${CATCH_DIR}" "${CMAKE_CURRENT_BINARY_DIR}"
+        )
+        set_tests_properties("CMakeConfig::${testName}"
+          PROPERTIES
+            COST 240
+            LABELS "uses-python"
+        )
+
+    endforeach()
+endif()
+
+if (CATCH_ENABLE_CMAKE_HELPER_TESTS)
+    add_test(NAME "CMakeHelper::DiscoverTests"
       COMMAND
-        "${PYTHON_EXECUTABLE}" "${CMAKE_CURRENT_LIST_DIR}/TestScripts/testConfigure${testName}.py" "${CATCH_DIR}" "${CMAKE_CURRENT_BINARY_DIR}"
+        "${PYTHON_EXECUTABLE}" "${CMAKE_CURRENT_LIST_DIR}/TestScripts/DiscoverTests/VerifyRegistration.py" "${CATCH_DIR}" "${CMAKE_CURRENT_BINARY_DIR}"
     )
-    set_tests_properties("CMakeConfig::${testName}"
+    set_tests_properties("CMakeHelper::DiscoverTests"
       PROPERTIES
         COST 240
         LABELS "uses-python"
     )
-  endforeach()
 endif()
 
-if(CATCH_ENABLE_CMAKE_HELPER_TESTS)
-  add_test(NAME "CMakeHelper::DiscoverTests"
-    COMMAND
-      "${PYTHON_EXECUTABLE}" "${CMAKE_CURRENT_LIST_DIR}/TestScripts/DiscoverTests/VerifyRegistration.py" "${CATCH_DIR}" "${CMAKE_CURRENT_BINARY_DIR}"
-  )
-  set_tests_properties("CMakeHelper::DiscoverTests"
-    PROPERTIES
-      COST 240
-      LABELS "uses-python"
-  )
-endif()
+foreach (reporterName # "Automake" - the simple .trs format does not support any kind of comments/metadata
+                      "compact"
+                      "console"
+                      "JUnit"
+                      "SonarQube"
+                      "TAP"
+                      # "TeamCity" - does not seem to support test suite-level metadata/comments
+                      "XML"
+                      "JSON")
 
-foreach(reporterName # "Automake" - the simple .trs format does not support any kind of comments/metadata
-                       "compact"
-                       "console"
-                       "JUnit"
-                       "SonarQube"
-                       "TAP"
-                     # "TeamCity" - does not seem to support test suite-level metadata/comments
-                       "XML"
-                       "JSON")
-  add_test(NAME "Reporters:Filters:${reporterName}"
-    COMMAND
-      $<TARGET_FILE:SelfTest> [comparisons][string-case] "CaseInsensitiveLess is case insensitive"
-        --reporter ${reporterName}
-  )
-  # Different regex for these two reporters, because the commas end up xml-escaped
-  if(reporterName MATCHES "JUnit|XML")
-    set(testCaseNameFormat "&quot;CaseInsensitiveLess is case insensitive&quot;")
-  elseif(reporterName MATCHES "JSON")
-    set(testCaseNameFormat "\\\\\"CaseInsensitiveLess is case insensitive\\\\\"")
-  else()
-    set(testCaseNameFormat "\"CaseInsensitiveLess is case insensitive\"")
-  endif()
-  set_tests_properties("Reporters:Filters:${reporterName}"
-    PROPERTIES
-      PASS_REGULAR_EXPRESSION "[fF]ilters.+\\[comparisons\\] \\[string-case\\] ${testCaseNameFormat}"
-  )
+    add_test(NAME "Reporters:Filters:${reporterName}"
+      COMMAND
+        $<TARGET_FILE:SelfTest> [comparisons][string-case] "CaseInsensitiveLess is case insensitive"
+          --reporter ${reporterName}
+    )
+    # Different regex for these two reporters, because the commas end up xml-escaped
+    if (reporterName MATCHES "JUnit|XML")
+      set(testCaseNameFormat "&quot;CaseInsensitiveLess is case insensitive&quot;")
+    elseif(reporterName MATCHES "JSON")
+      set(testCaseNameFormat "\\\\\"CaseInsensitiveLess is case insensitive\\\\\"")
+    else()
+      set(testCaseNameFormat "\"CaseInsensitiveLess is case insensitive\"")
+    endif()
+    set_tests_properties("Reporters:Filters:${reporterName}"
+      PROPERTIES
+        PASS_REGULAR_EXPRESSION "[fF]ilters.+\\[comparisons\\] \\[string-case\\] ${testCaseNameFormat}"
+    )
+
+    add_test(NAME "Reporters:RngSeed:${reporterName}"
+      COMMAND
+        $<TARGET_FILE:SelfTest> "Factorials are computed"
+          --reporter ${reporterName}
+          --rng-seed 18181818
+    )
+    set_tests_properties("Reporters:RngSeed:${reporterName}"
+      PROPERTIES
+        PASS_REGULAR_EXPRESSION "18181818"
+    )
 
-  add_test(NAME "Reporters:RngSeed:${reporterName}"
-    COMMAND
-      $<TARGET_FILE:SelfTest> "Factorials are computed"
-        --reporter ${reporterName}
-        --rng-seed 18181818
-  )
-  set_tests_properties("Reporters:RngSeed:${reporterName}"
-    PROPERTIES
-      PASS_REGULAR_EXPRESSION "18181818"
-  )
 endforeach()
 
+
 list(APPEND CATCH_WARNING_TARGETS SelfTest)
 set(CATCH_WARNING_TARGETS ${CATCH_WARNING_TARGETS} PARENT_SCOPE)

tests/ExtraTests/CMakeLists.txt

@@ -1,7 +1,12 @@
-cmake_minimum_required(VERSION 3.16)
-project(Catch2ExtraTests LANGUAGES CXX)
+#
+# Build extra tests.
+#
 
-message(STATUS "Extra tests included")
+cmake_minimum_required( VERSION 3.10 )
+
+project( Catch2ExtraTests LANGUAGES CXX )
+
+message( STATUS "Extra tests included" )
 
 add_test(
   NAME TestShardingIntegration
@@ -16,7 +21,8 @@ add_test(
   NAME TestSharding::OverlyLargeShardIndex
   COMMAND $<TARGET_FILE:SelfTest>  --shard-index 5 --shard-count 5
 )
-set_tests_properties(TestSharding::OverlyLargeShardIndex
+set_tests_properties(
+    TestSharding::OverlyLargeShardIndex
   PROPERTIES
     PASS_REGULAR_EXPRESSION "The shard count \\(5\\) must be greater than the shard index \\(5\\)"
 )
@@ -25,7 +31,8 @@ set_tests_properties(TestSharding::OverlyLargeShardIndex
 # they have non-trivial execution time, so they are categorized as
 # extra tests, so that they are run less.
 add_test(NAME MinDuration::SimpleThreshold COMMAND $<TARGET_FILE:SelfTest> --min-duration 0.950 [min_duration_test])
-set_tests_properties(MinDuration::SimpleThreshold
+set_tests_properties(
+    MinDuration::SimpleThreshold
   PROPERTIES
     PASS_REGULAR_EXPRESSION "s: sleep_for_1000ms"
     FAIL_REGULAR_EXPRESSION "sleep_for_100ms"
@@ -36,7 +43,8 @@ set_tests_properties(MinDuration::SimpleThreshold
 # -d yes overrides the threshold, so we should see the faster test even
 # with a ridiculous high min duration threshold
 add_test(NAME MinDuration::DurationOverrideYes COMMAND $<TARGET_FILE:SelfTest> --min-duration 1.0 -d yes [min_duration_test])
-set_tests_properties(MinDuration::DurationOverrideYes
+set_tests_properties(
+    MinDuration::DurationOverrideYes
   PROPERTIES
     PASS_REGULAR_EXPRESSION "s: sleep_for_100ms"
 )
@@ -44,24 +52,27 @@ set_tests_properties(MinDuration::DurationOverrideYes
 # -d no overrides the threshold, so we should never see any tests even
 # with ridiculously low min duration threshold
 add_test(NAME MinDuration::DurationOverrideNo COMMAND $<TARGET_FILE:SelfTest> --min-duration 0.0001 -d no [min_duration_test])
-set_tests_properties(MinDuration::DurationOverrideNo
+set_tests_properties(
+    MinDuration::DurationOverrideNo
   PROPERTIES
     FAIL_REGULAR_EXPRESSION "sleep_for_250ms"
 )
 
+
 # ------------ end of duration reporting tests
 
 # define folders used:
-set(TESTS_DIR ${CATCH_DIR}/tests/ExtraTests)
+set( TESTS_DIR   ${CATCH_DIR}/tests/ExtraTests )
 
 add_executable(PrefixedMacros ${TESTS_DIR}/X01-PrefixedMacros.cpp)
-target_compile_definitions(PrefixedMacros PRIVATE CATCH_CONFIG_PREFIX_ALL CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+target_compile_definitions( PrefixedMacros PRIVATE CATCH_CONFIG_PREFIX_ALL CATCH_CONFIG_RUNTIME_STATIC_REQUIRE )
 # Macro configuration does not touch the compiled parts, so we can link
 # it against the main library
-target_link_libraries(PrefixedMacros Catch2WithMain)
+target_link_libraries( PrefixedMacros Catch2WithMain )
 
 add_test(NAME CATCH_CONFIG_PREFIX_ALL COMMAND PrefixedMacros -s)
-set_tests_properties(CATCH_CONFIG_PREFIX_ALL
+set_tests_properties(
+    CATCH_CONFIG_PREFIX_ALL
   PROPERTIES
     PASS_REGULAR_EXPRESSION "CATCH_"
     FAIL_REGULAR_EXPRESSION
@@ -70,47 +81,51 @@ set_tests_properties(CATCH_CONFIG_PREFIX_ALL
     " REQUIRE; REQUIRE_FALSE; REQUIRE_THROWS; REQUIRE_THROWS_AS; REQUIRE_THROWS_WITH; REQUIRE_THROWS_MATCHES; REQUIRE_NOTHROW; CHECK; CHECK_FALSE; CHECKED_IF; CHECKED_ELSE; CHECK_NOFAIL; CHECK_THROWS; CHECK_THROWS_AS; CHECK_THROWS_WITH; CHECK_THROWS_MATCHES; CHECK_NOTHROW; REQUIRE_THAT; CHECK_THAT"
 )
 
+
 add_executable(DisabledMacros ${TESTS_DIR}/X02-DisabledMacros.cpp)
-target_compile_definitions(DisabledMacros PRIVATE CATCH_CONFIG_DISABLE)
+target_compile_definitions( DisabledMacros PRIVATE CATCH_CONFIG_DISABLE )
 # Macro configuration does not touch the compiled parts, so we can link
 # it against the main library
-target_link_libraries(DisabledMacros Catch2WithMain)
+target_link_libraries( DisabledMacros Catch2WithMain )
 
 add_test(NAME CATCH_CONFIG_DISABLE-1 COMMAND DisabledMacros -s)
-set_tests_properties(CATCH_CONFIG_DISABLE-1
+set_tests_properties(
+    CATCH_CONFIG_DISABLE-1
   PROPERTIES
     PASS_REGULAR_EXPRESSION "No tests ran"
     FAIL_REGULAR_EXPRESSION "This should not happen"
 )
 add_test(NAME CATCH_CONFIG_DISABLE-2 COMMAND DisabledMacros --list-tests)
-set_tests_properties(CATCH_CONFIG_DISABLE-2
+set_tests_properties(
+    CATCH_CONFIG_DISABLE-2
   PROPERTIES
     PASS_REGULAR_EXPRESSION "0 test cases"
 )
 
-add_executable(DisabledExceptions-DefaultHandler ${TESTS_DIR}/X03-DisabledExceptions-DefaultHandler.cpp)
-add_executable(DisabledExceptions-CustomHandler ${TESTS_DIR}/X04-DisabledExceptions-CustomHandler.cpp)
+add_executable( DisabledExceptions-DefaultHandler ${TESTS_DIR}/X03-DisabledExceptions-DefaultHandler.cpp )
+add_executable( DisabledExceptions-CustomHandler ${TESTS_DIR}/X04-DisabledExceptions-CustomHandler.cpp )
 
 foreach(target DisabledExceptions-DefaultHandler DisabledExceptions-CustomHandler)
-  target_compile_options(${target}
+  target_compile_options( ${target}
     PUBLIC
       $<$<CXX_COMPILER_ID:MSVC>:/EHs-c-;/D_HAS_EXCEPTIONS=0>
       $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:GNU>,$<CXX_COMPILER_ID:AppleClang>>:-fno-exceptions>
   )
   target_link_libraries(${target} Catch2_buildall_interface)
 endforeach()
-target_compile_definitions(DisabledExceptions-CustomHandler PUBLIC CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
+target_compile_definitions( DisabledExceptions-CustomHandler PUBLIC CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER )
 
 
 add_test(NAME CATCH_CONFIG_DISABLE_EXCEPTIONS-1 COMMAND DisabledExceptions-DefaultHandler "Tests that run")
-set_tests_properties(CATCH_CONFIG_DISABLE_EXCEPTIONS-1
+set_tests_properties(
+    CATCH_CONFIG_DISABLE_EXCEPTIONS-1
   PROPERTIES
     PASS_REGULAR_EXPRESSION "assertions: 4 \| 2 passed \| 2 failed"
     FAIL_REGULAR_EXPRESSION "abort;terminate;fatal"
 )
 
-add_executable(BazelReporter ${TESTS_DIR}/X30-BazelReporter.cpp)
-target_compile_definitions(BazelReporter PRIVATE CATCH_CONFIG_BAZEL_SUPPORT)
+add_executable( BazelReporter ${TESTS_DIR}/X30-BazelReporter.cpp )
+target_compile_definitions( BazelReporter PRIVATE CATCH_CONFIG_BAZEL_SUPPORT )
 target_link_libraries(BazelReporter Catch2_buildall_interface)
 add_test(NAME CATCH_CONFIG_BAZEL_REPORTER-1
   COMMAND
@@ -122,7 +137,7 @@ set_tests_properties(CATCH_CONFIG_BAZEL_REPORTER-1
 )
 
 # We must now test this works without the build flag.
-add_executable(BazelReporterNoCatchConfig ${TESTS_DIR}/X30-BazelReporter.cpp)
+add_executable( BazelReporterNoCatchConfig ${TESTS_DIR}/X30-BazelReporter.cpp )
 target_link_libraries(BazelReporterNoCatchConfig Catch2WithMain)
 add_test(NAME NO_CATCH_CONFIG_BAZEL_REPORTER-1
   COMMAND
@@ -144,6 +159,7 @@ set_tests_properties(BazelEnv::TESTBRIDGE_TEST_ONLY
     PASS_REGULAR_EXPRESSION "All tests passed \\(1 assertion in 1 test case\\)"
 )
 
+
 add_test(NAME BazelEnv::Sharding
   COMMAND
     "${PYTHON_EXECUTABLE}" "${CATCH_DIR}/tests/TestScripts/testBazelSharding.py"
@@ -155,69 +171,82 @@ set_tests_properties(BazelEnv::Sharding
     LABELS "uses-python"
 )
 
+
 # The default handler on Windows leads to the just-in-time debugger firing,
 # which makes this test unsuitable for CI and headless runs, as it opens
 # up an interactive dialog.
-if(NOT WIN32)
+if (NOT WIN32)
   add_test(NAME CATCH_CONFIG_DISABLE_EXCEPTIONS-2 COMMAND DisabledExceptions-DefaultHandler "Tests that abort")
-  set_tests_properties(CATCH_CONFIG_DISABLE_EXCEPTIONS-2
+  set_tests_properties(
+      CATCH_CONFIG_DISABLE_EXCEPTIONS-2
     PROPERTIES
       PASS_REGULAR_EXPRESSION "Catch will terminate"
   )
 endif()
 
+
 add_test(NAME CATCH_CONFIG_DISABLE_EXCEPTIONS-3 COMMAND DisabledExceptions-CustomHandler "Tests that run")
-set_tests_properties(CATCH_CONFIG_DISABLE_EXCEPTIONS-3
+set_tests_properties(
+    CATCH_CONFIG_DISABLE_EXCEPTIONS-3
   PROPERTIES
     PASS_REGULAR_EXPRESSION "assertions: 4 \| 2 passed \| 2 failed"
     FAIL_REGULAR_EXPRESSION "====== CUSTOM HANDLER ======"
 )
 
 add_test(NAME CATCH_CONFIG_DISABLE_EXCEPTIONS-4 COMMAND DisabledExceptions-CustomHandler "Tests that abort")
-set_tests_properties(CATCH_CONFIG_DISABLE_EXCEPTIONS-4
+set_tests_properties(
+    CATCH_CONFIG_DISABLE_EXCEPTIONS-4
   PROPERTIES
     PASS_REGULAR_EXPRESSION "====== CUSTOM HANDLER ======"
 )
 
+
 add_executable(DeferredStaticChecks ${TESTS_DIR}/X05-DeferredStaticChecks.cpp)
 target_link_libraries(DeferredStaticChecks PRIVATE Catch2WithMain)
 target_compile_definitions(DeferredStaticChecks PRIVATE "CATCH_CONFIG_RUNTIME_STATIC_REQUIRE")
 
 add_test(NAME DeferredStaticChecks COMMAND DeferredStaticChecks -r compact)
-set_tests_properties(DeferredStaticChecks
+set_tests_properties(
+    DeferredStaticChecks
   PROPERTIES
     PASS_REGULAR_EXPRESSION "test cases: 1 \\| 1 failed\nassertions: 3 \\| 3 failed"
 )
 
+
 add_executable(FallbackStringifier ${TESTS_DIR}/X10-FallbackStringifier.cpp)
-target_compile_definitions(FallbackStringifier PRIVATE CATCH_CONFIG_FALLBACK_STRINGIFIER=fallbackStringifier)
-target_link_libraries(FallbackStringifier Catch2WithMain)
+target_compile_definitions( FallbackStringifier PRIVATE CATCH_CONFIG_FALLBACK_STRINGIFIER=fallbackStringifier )
+target_link_libraries( FallbackStringifier Catch2WithMain )
 
 add_test(NAME FallbackStringifier COMMAND FallbackStringifier -r compact -s)
-set_tests_properties(FallbackStringifier
+set_tests_properties(
+    FallbackStringifier
   PROPERTIES
     PASS_REGULAR_EXPRESSION "foo{} for: { !!! }"
 )
 
+
 add_executable(DisableStringification ${TESTS_DIR}/X11-DisableStringification.cpp)
-target_compile_definitions(DisableStringification PRIVATE CATCH_CONFIG_DISABLE_STRINGIFICATION)
+target_compile_definitions( DisableStringification PRIVATE CATCH_CONFIG_DISABLE_STRINGIFICATION )
 target_link_libraries(DisableStringification Catch2WithMain)
 add_test(NAME CATCH_CONFIG_DISABLE_STRINGIFICATION COMMAND DisableStringification -r compact -s)
-set_tests_properties(CATCH_CONFIG_DISABLE_STRINGIFICATION
+set_tests_properties(
+    CATCH_CONFIG_DISABLE_STRINGIFICATION
   PROPERTIES
     PASS_REGULAR_EXPRESSION "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
     FAIL_REGULAR_EXPRESSION  "Hidden{} == Hidden{}"
 )
 
+
 # This test touches windows.h, so it should only be compiled under msvc
-if(MSVC)
-  # This test fails if it does not compile and succeeds otherwise
-  add_executable(WindowsHeader ${TESTS_DIR}/X90-WindowsHeaderInclusion.cpp)
-  target_link_libraries(WindowsHeader Catch2WithMain)
-  add_test(NAME WindowsHeader COMMAND WindowsHeader -r compact)
-  list(APPEND CATCH_WARNING_TARGETS ${EXTRA_TEST_BINARIES} WindowsHeader)
+if (MSVC)
+    # This test fails if it does not compile and succeeds otherwise
+    add_executable(WindowsHeader ${TESTS_DIR}/X90-WindowsHeaderInclusion.cpp)
+    target_link_libraries( WindowsHeader Catch2WithMain )
+    add_test(NAME WindowsHeader COMMAND WindowsHeader -r compact)
+    list(APPEND CATCH_WARNING_TARGETS ${EXTRA_TEST_BINARIES} WindowsHeader)
 endif()
 
+
 add_executable(PartialTestCaseEvents ${TESTS_DIR}/X21-PartialTestCaseEvents.cpp)
 target_link_libraries(PartialTestCaseEvents PRIVATE Catch2WithMain)
 add_test(
@@ -235,19 +264,22 @@ add_test(
   NAME BenchmarksInCumulativeReporter
   COMMAND BenchmarksInCumulativeReporter --reporter testReporter
 )
-set_tests_properties(BenchmarksInCumulativeReporter
+set_tests_properties(
+    BenchmarksInCumulativeReporter
   PROPERTIES
     PASS_REGULAR_EXPRESSION "1\n2\n3\n4\n5\n"
     COST 30
 )
 
+
 add_executable(CasingInReporterNames ${TESTS_DIR}/X23-CasingInReporterNames.cpp)
 target_link_libraries(CasingInReporterNames PRIVATE Catch2::Catch2WithMain)
 add_test(
   NAME Reporters::registration-is-case-preserving
   COMMAND CasingInReporterNames --list-reporters
 )
-set_tests_properties(Reporters::registration-is-case-preserving
+set_tests_properties(
+    Reporters::registration-is-case-preserving
   PROPERTIES
     PASS_REGULAR_EXPRESSION "testReporterCASED"
 )
@@ -255,7 +287,8 @@ add_test(
   NAME Reporters::selection-is-case-insensitive
   COMMAND  CasingInReporterNames -r testReportercased
 )
-set_tests_properties(Reporters::selection-is-case-insensitive
+set_tests_properties(
+    Reporters::selection-is-case-insensitive
   PROPERTIES
     PASS_REGULAR_EXPRESSION "TestReporter constructed"
 )
@@ -267,13 +300,15 @@ add_test(
   COMMAND CapturedStdoutInTestCaseEvents
     --reporter test-reporter
 )
-set_tests_properties(Reporters::CapturedStdOutInEvents
+set_tests_properties(
+    Reporters::CapturedStdOutInEvents
   PROPERTIES
     PASS_REGULAR_EXPRESSION "X27 - TestReporter constructed"
     FAIL_REGULAR_EXPRESSION "X27 ERROR"
 )
 
-if(MSVC)
+
+if (MSVC)
   set(_NullFile "NUL")
 else()
   set(_NullFile "/dev/null")
@@ -285,7 +320,7 @@ target_link_libraries(ListenerStdoutCaptureInMultireporter PRIVATE Catch2::Catch
 # This test checks that there is nothing written out from the process,
 # but if CMake is running the tests under Valgrind or similar tool, then
 # that will write its own output to stdout and the test would fail.
-if(NOT MEMORYCHECK_COMMAND)
+if (NOT MEMORYCHECK_COMMAND)
   add_test(
     NAME MultiReporter::NoncapturingListenerDoesntCauseStdoutPassThrough
     COMMAND ListenerStdoutCaptureInMultireporter
@@ -293,13 +328,15 @@ if(NOT MEMORYCHECK_COMMAND)
       --reporter junit::out=${_NullFile}
   )
 
-  set_tests_properties(MultiReporter::NoncapturingListenerDoesntCauseStdoutPassThrough
+  set_tests_properties(
+      MultiReporter::NoncapturingListenerDoesntCauseStdoutPassThrough
     PROPERTIES
       PASS_REGULAR_EXPRESSION "X24 - NonCapturingListener initialized"
       FAIL_REGULAR_EXPRESSION "X24 - FooBarBaz"
   )
 endif()
 
+
 add_executable(ListenerCanAskForCapturedStdout ${TESTS_DIR}/X25-ListenerCanAskForCapturedStdout.cpp)
 target_link_libraries(ListenerCanAskForCapturedStdout PRIVATE Catch2::Catch2WithMain)
 add_test(
@@ -308,7 +345,8 @@ add_test(
     --reporter compact::out=${_NullFile}
     --reporter console::out=${_NullFile}
 )
-set_tests_properties(MultiReporter::CapturingListenerCausesStdoutCapture
+set_tests_properties(
+    MultiReporter::CapturingListenerCausesStdoutCapture
   PROPERTIES
     PASS_REGULAR_EXPRESSION "CapturingListener initialized"
     FAIL_REGULAR_EXPRESSION "X25 - ERROR"
@@ -321,7 +359,8 @@ add_test(
   COMMAND ReporterPreferencesForPassingAssertionsIsRespected
     --reporter test-reporter
 )
-set_tests_properties(Reporters::PreferencesForPassingAssertionsIsRespected
+set_tests_properties(
+    Reporters::PreferencesForPassingAssertionsIsRespected
   PROPERTIES
     PASS_REGULAR_EXPRESSION "X26 - TestReporter constructed"
     FAIL_REGULAR_EXPRESSION "X26 - assertionEnded"
@@ -332,7 +371,8 @@ add_test(
     --reporter test-reporter
     --reporter console::out=${_NullFile}
 )
-set_tests_properties(MultiReporter::PreferencesForPassingAssertionsIsRespected
+set_tests_properties(
+    MultiReporter::PreferencesForPassingAssertionsIsRespected
   PROPERTIES
     PASS_REGULAR_EXPRESSION "X26 - TestReporter constructed"
     FAIL_REGULAR_EXPRESSION "X26 - assertionEnded"
@@ -344,7 +384,8 @@ add_test(
   NAME ListenersGetEventsBeforeReporters
   COMMAND ListenersGetEventsBeforeReporters --reporter test-reporter
 )
-set_tests_properties(ListenersGetEventsBeforeReporters
+set_tests_properties(
+    ListenersGetEventsBeforeReporters
   PROPERTIES
     PASS_REGULAR_EXPRESSION "X28 - TestReporter constructed"
     FAIL_REGULAR_EXPRESSION "X28 - ERROR"
@@ -357,18 +398,21 @@ add_test(
   COMMAND CustomArgumentsForReporters
     --reporter "test-reporter::Xa b=c 1::Xz:e = 1234"
 )
-set_tests_properties(CustomArgumentsForReporters
+set_tests_properties(
+    CustomArgumentsForReporters
   PROPERTIES
     PASS_REGULAR_EXPRESSION "Xa b=c 1::Xz:e = 1234"
 )
 
+
 add_executable(DuplicatedTestCases-SameNameAndTags ${TESTS_DIR}/X31-DuplicatedTestCases.cpp)
 target_link_libraries(DuplicatedTestCases-SameNameAndTags PRIVATE Catch2::Catch2WithMain)
 add_test(
   NAME DuplicatedTestCases::SameNameAndTags
   COMMAND $<TARGET_FILE:DuplicatedTestCases-SameNameAndTags>
 )
-set_tests_properties(DuplicatedTestCases::SameNameAndTags
+set_tests_properties(
+    DuplicatedTestCases::SameNameAndTags
   PROPERTIES
      PASS_REGULAR_EXPRESSION "error: .* already defined\\."
 )
@@ -379,7 +423,8 @@ add_test(
   NAME DuplicatedTestCases::SameNameDifferentTags
   COMMAND $<TARGET_FILE:DuplicatedTestCases-SameNameDifferentTags>
 )
-set_tests_properties(DuplicatedTestCases::SameNameDifferentTags
+set_tests_properties(
+    DuplicatedTestCases::SameNameDifferentTags
   PROPERTIES
      FAIL_REGULAR_EXPRESSION "error: .* already defined\\."
 )
@@ -390,7 +435,8 @@ add_test(
   NAME DuplicatedTestCases::DuplicatedTestCaseMethods
   COMMAND $<TARGET_FILE:DuplicatedTestCases-DuplicatedTestCaseMethods>
 )
-set_tests_properties(DuplicatedTestCases::DuplicatedTestCaseMethods
+set_tests_properties(
+    DuplicatedTestCases::DuplicatedTestCaseMethods
   PROPERTIES
      PASS_REGULAR_EXPRESSION "error: .* already defined\\."
 )
@@ -401,18 +447,21 @@ add_test(
   NAME DuplicatedTestCases::DuplicatedTestCaseMethodsDifferentFixtures
   COMMAND $<TARGET_FILE:DuplicatedTestCases-DifferentFixtures>
 )
-set_tests_properties(DuplicatedTestCases::DuplicatedTestCaseMethodsDifferentFixtures
+set_tests_properties(
+    DuplicatedTestCases::DuplicatedTestCaseMethodsDifferentFixtures
   PROPERTIES
     FAIL_REGULAR_EXPRESSION "error: .* already defined\\."
 )
 
+
 add_executable(DuplicatedReporters ${TESTS_DIR}/X35-DuplicatedReporterNames.cpp)
 target_link_libraries(DuplicatedReporters PRIVATE Catch2::Catch2WithMain)
 add_test(
   NAME Reporters::RegistrationErrorsAreCaught
   COMMAND $<TARGET_FILE:DuplicatedReporters>
 )
-set_tests_properties(Reporters::RegistrationErrorsAreCaught
+set_tests_properties(
+    Reporters::RegistrationErrorsAreCaught
   PROPERTIES
     PASS_REGULAR_EXPRESSION "Errors occurred during startup!"
 )
@@ -423,7 +472,8 @@ add_test(
   NAME Reporters::CrashInJunitReporter
   COMMAND ${CMAKE_COMMAND} -E env $<TARGET_FILE:ReportingCrashWithJunitReporter> --reporter JUnit
 )
-set_tests_properties(Reporters::CrashInJunitReporter
+set_tests_properties(
+    Reporters::CrashInJunitReporter
   PROPERTIES
     PASS_REGULAR_EXPRESSION "</testsuites>"
     LABELS "uses-signals"
@@ -443,7 +493,8 @@ add_test(
 #add_executable(DebugBreakMacros ${TESTS_DIR}/X12-CustomDebugBreakMacro.cpp)
 #target_link_libraries(DebugBreakMacros Catch2)
 #add_test(NAME DebugBreakMacros COMMAND DebugBreakMacros --break)
-#set_tests_properties(DebugBreakMacros
+#set_tests_properties(
+#    DebugBreakMacros
 #  PROPERTIES
 #    PASS_REGULAR_EXPRESSION "Pretty please, break into debugger"
 #)
@@ -470,6 +521,7 @@ add_test(
   COMMAND $<TARGET_FILE:NoTests> --list-listeners
 )
 
+
 add_executable(AllSkipped ${TESTS_DIR}/X93-AllSkipped.cpp)
 target_link_libraries(AllSkipped PRIVATE Catch2::Catch2WithMain)
 
@@ -482,21 +534,21 @@ set_tests_properties(TestSpecs::SkippingAllTestsFails
     WILL_FAIL ON
 )
 
-set(EXTRA_TEST_BINARIES
-  AllSkipped
-  PrefixedMacros
-  DisabledMacros
-  DisabledExceptions-DefaultHandler
-  DisabledExceptions-CustomHandler
-  FallbackStringifier
-  DisableStringification
-  PartialTestCaseEvents
-  DuplicatedTestCases-SameNameAndTags
-  DuplicatedTestCases-SameNameDifferentTags
-  DuplicatedTestCases-DuplicatedTestCaseMethods
-  NoTests
-  ListenersGetEventsBeforeReporters
-#  DebugBreakMacros
+set( EXTRA_TEST_BINARIES
+    AllSkipped
+    PrefixedMacros
+    DisabledMacros
+    DisabledExceptions-DefaultHandler
+    DisabledExceptions-CustomHandler
+    FallbackStringifier
+    DisableStringification
+    PartialTestCaseEvents
+    DuplicatedTestCases-SameNameAndTags
+    DuplicatedTestCases-SameNameDifferentTags
+    DuplicatedTestCases-DuplicatedTestCaseMethods
+    NoTests
+    ListenersGetEventsBeforeReporters
+#    DebugBreakMacros
 )
 
 # Notice that we are modifying EXTRA_TEST_BINARIES destructively, do not
@@ -505,6 +557,7 @@ list(FILTER EXTRA_TEST_BINARIES EXCLUDE REGEX "DisabledExceptions.*")
 list(APPEND CATCH_WARNING_TARGETS ${EXTRA_TEST_BINARIES})
 set(CATCH_WARNING_TARGETS ${CATCH_WARNING_TARGETS} PARENT_SCOPE)
 
+
 # This sets up a one-off executable that compiles against the amalgamated
 # files, and then runs it for a super simple check that the amalgamated
 # files are usable.
@@ -517,7 +570,8 @@ target_include_directories(AmalgamatedTestCompilation PRIVATE ${CATCH_DIR}/extra
 target_compile_features(AmalgamatedTestCompilation PRIVATE cxx_std_14)
 
 add_test(NAME AmalgamatedFileTest COMMAND AmalgamatedTestCompilation)
-set_tests_properties(AmalgamatedFileTest
+set_tests_properties(
+    AmalgamatedFileTest
   PROPERTIES
     PASS_REGULAR_EXPRESSION "All tests passed \\(14 assertions in 3 test cases\\)"
 )

tests/SelfTest/Baselines/automake.sw.approved.txt

@@ -175,7 +175,7 @@ Nor would this
 :test-result: XFAIL Inequality checks that should fail
 :test-result: PASS Inequality checks that should succeed
 :test-result: PASS JsonWriter
-:test-result: PASS JsonWriter escapes characters in strings properly
+:test-result: PASS JsonWriter escapes charaters in strings properly
 :test-result: PASS Lambdas in assertions
 :test-result: PASS Less-than inequalities with different epsilons
 :test-result: PASS ManuallyRegistered

tests/SelfTest/Baselines/automake.sw.multi.approved.txt

@@ -173,7 +173,7 @@
 :test-result: XFAIL Inequality checks that should fail
 :test-result: PASS Inequality checks that should succeed
 :test-result: PASS JsonWriter
-:test-result: PASS JsonWriter escapes characters in strings properly
+:test-result: PASS JsonWriter escapes charaters in strings properly
 :test-result: PASS Lambdas in assertions
 :test-result: PASS Less-than inequalities with different epsilons
 :test-result: PASS ManuallyRegistered

tests/SelfTest/Baselines/console.sw.approved.txt

@@ -7652,7 +7652,7 @@ with expansion:
   ""custom"" == ""custom""
 
 -------------------------------------------------------------------------------
-JsonWriter escapes characters in strings properly
+JsonWriter escapes charaters in strings properly
   Quote in a string is escaped
 -------------------------------------------------------------------------------
 Json.tests.cpp:<line number>
@@ -7664,7 +7664,7 @@ with expansion:
   ""\""" == ""\"""
 
 -------------------------------------------------------------------------------
-JsonWriter escapes characters in strings properly
+JsonWriter escapes charaters in strings properly
   Backslash in a string is escaped
 -------------------------------------------------------------------------------
 Json.tests.cpp:<line number>
@@ -7676,7 +7676,7 @@ with expansion:
   ""\\"" == ""\\""
 
 -------------------------------------------------------------------------------
-JsonWriter escapes characters in strings properly
+JsonWriter escapes charaters in strings properly
   Forward slash in a string is **not** escaped
 -------------------------------------------------------------------------------
 Json.tests.cpp:<line number>
@@ -7688,7 +7688,7 @@ with expansion:
   ""/"" == ""/""
 
 -------------------------------------------------------------------------------
-JsonWriter escapes characters in strings properly
+JsonWriter escapes charaters in strings properly
   Backspace in a string is escaped
 -------------------------------------------------------------------------------
 Json.tests.cpp:<line number>
@@ -7700,7 +7700,7 @@ with expansion:
   ""\b"" == ""\b""
 
 -------------------------------------------------------------------------------
-JsonWriter escapes characters in strings properly
+JsonWriter escapes charaters in strings properly
   Formfeed in a string is escaped
 -------------------------------------------------------------------------------
 Json.tests.cpp:<line number>
@@ -7712,7 +7712,7 @@ with expansion:
   ""\f"" == ""\f""
 
 -------------------------------------------------------------------------------
-JsonWriter escapes characters in strings properly
+JsonWriter escapes charaters in strings properly
   linefeed in a string is escaped
 -------------------------------------------------------------------------------
 Json.tests.cpp:<line number>
@@ -7724,7 +7724,7 @@ with expansion:
   ""\n"" == ""\n""
 
 -------------------------------------------------------------------------------
-JsonWriter escapes characters in strings properly
+JsonWriter escapes charaters in strings properly
   carriage return in a string is escaped
 -------------------------------------------------------------------------------
 Json.tests.cpp:<line number>
@@ -7736,7 +7736,7 @@ with expansion:
   ""\r"" == ""\r""
 
 -------------------------------------------------------------------------------
-JsonWriter escapes characters in strings properly
+JsonWriter escapes charaters in strings properly
   tab in a string is escaped
 -------------------------------------------------------------------------------
 Json.tests.cpp:<line number>
@@ -7748,7 +7748,7 @@ with expansion:
   ""\t"" == ""\t""
 
 -------------------------------------------------------------------------------
-JsonWriter escapes characters in strings properly
+JsonWriter escapes charaters in strings properly
   combination of characters is escaped
 -------------------------------------------------------------------------------
 Json.tests.cpp:<line number>

tests/SelfTest/Baselines/console.sw.multi.approved.txt

@@ -7650,7 +7650,7 @@ with expansion:
   ""custom"" == ""custom""
 
 -------------------------------------------------------------------------------
-JsonWriter escapes characters in strings properly
+JsonWriter escapes charaters in strings properly
   Quote in a string is escaped
 -------------------------------------------------------------------------------
 Json.tests.cpp:<line number>
@@ -7662,7 +7662,7 @@ with expansion:
   ""\""" == ""\"""
 
 -------------------------------------------------------------------------------
-JsonWriter escapes characters in strings properly
+JsonWriter escapes charaters in strings properly
   Backslash in a string is escaped
 -------------------------------------------------------------------------------
 Json.tests.cpp:<line number>
@@ -7674,7 +7674,7 @@ with expansion:
   ""\\"" == ""\\""
 
 -------------------------------------------------------------------------------
-JsonWriter escapes characters in strings properly
+JsonWriter escapes charaters in strings properly
   Forward slash in a string is **not** escaped
 -------------------------------------------------------------------------------
 Json.tests.cpp:<line number>
@@ -7686,7 +7686,7 @@ with expansion:
   ""/"" == ""/""
 
 -------------------------------------------------------------------------------
-JsonWriter escapes characters in strings properly
+JsonWriter escapes charaters in strings properly
   Backspace in a string is escaped
 -------------------------------------------------------------------------------
 Json.tests.cpp:<line number>
@@ -7698,7 +7698,7 @@ with expansion:
   ""\b"" == ""\b""
 
 -------------------------------------------------------------------------------
-JsonWriter escapes characters in strings properly
+JsonWriter escapes charaters in strings properly
   Formfeed in a string is escaped
 -------------------------------------------------------------------------------
 Json.tests.cpp:<line number>
@@ -7710,7 +7710,7 @@ with expansion:
   ""\f"" == ""\f""
 
 -------------------------------------------------------------------------------
-JsonWriter escapes characters in strings properly
+JsonWriter escapes charaters in strings properly
   linefeed in a string is escaped
 -------------------------------------------------------------------------------
 Json.tests.cpp:<line number>
@@ -7722,7 +7722,7 @@ with expansion:
   ""\n"" == ""\n""
 
 -------------------------------------------------------------------------------
-JsonWriter escapes characters in strings properly
+JsonWriter escapes charaters in strings properly
   carriage return in a string is escaped
 -------------------------------------------------------------------------------
 Json.tests.cpp:<line number>
@@ -7734,7 +7734,7 @@ with expansion:
   ""\r"" == ""\r""
 
 -------------------------------------------------------------------------------
-JsonWriter escapes characters in strings properly
+JsonWriter escapes charaters in strings properly
   tab in a string is escaped
 -------------------------------------------------------------------------------
 Json.tests.cpp:<line number>
@@ -7746,7 +7746,7 @@ with expansion:
   ""\t"" == ""\t""
 
 -------------------------------------------------------------------------------
-JsonWriter escapes characters in strings properly
+JsonWriter escapes charaters in strings properly
   combination of characters is escaped
 -------------------------------------------------------------------------------
 Json.tests.cpp:<line number>

tests/SelfTest/Baselines/junit.sw.approved.txt

@@ -929,16 +929,16 @@ at Condition.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="JsonWriter/Moved from JsonObjectWriter shall not insert superfluous brace" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="JsonWriter/Moved from JsonArrayWriter shall not insert superfluous bracket" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="JsonWriter/Custom class shall be quoted" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="JsonWriter escapes characters in strings properly" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="JsonWriter escapes characters in strings properly/Quote in a string is escaped" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="JsonWriter escapes characters in strings properly/Backslash in a string is escaped" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="JsonWriter escapes characters in strings properly/Forward slash in a string is **not** escaped" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="JsonWriter escapes characters in strings properly/Backspace in a string is escaped" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="JsonWriter escapes characters in strings properly/Formfeed in a string is escaped" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="JsonWriter escapes characters in strings properly/linefeed in a string is escaped" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="JsonWriter escapes characters in strings properly/carriage return in a string is escaped" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="JsonWriter escapes characters in strings properly/tab in a string is escaped" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="JsonWriter escapes characters in strings properly/combination of characters is escaped" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/Quote in a string is escaped" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/Backslash in a string is escaped" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/Forward slash in a string is **not** escaped" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/Backspace in a string is escaped" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/Formfeed in a string is escaped" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/linefeed in a string is escaped" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/carriage return in a string is escaped" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/tab in a string is escaped" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/combination of characters is escaped" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Lambdas in assertions" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Less-than inequalities with different epsilons" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="ManuallyRegistered" time="{duration}" status="run"/>

tests/SelfTest/Baselines/junit.sw.multi.approved.txt

@@ -928,16 +928,16 @@ at Condition.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="JsonWriter/Moved from JsonObjectWriter shall not insert superfluous brace" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="JsonWriter/Moved from JsonArrayWriter shall not insert superfluous bracket" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="JsonWriter/Custom class shall be quoted" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="JsonWriter escapes characters in strings properly" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="JsonWriter escapes characters in strings properly/Quote in a string is escaped" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="JsonWriter escapes characters in strings properly/Backslash in a string is escaped" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="JsonWriter escapes characters in strings properly/Forward slash in a string is **not** escaped" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="JsonWriter escapes characters in strings properly/Backspace in a string is escaped" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="JsonWriter escapes characters in strings properly/Formfeed in a string is escaped" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="JsonWriter escapes characters in strings properly/linefeed in a string is escaped" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="JsonWriter escapes characters in strings properly/carriage return in a string is escaped" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="JsonWriter escapes characters in strings properly/tab in a string is escaped" time="{duration}" status="run"/>
-    <testcase classname="<exe-name>.global" name="JsonWriter escapes characters in strings properly/combination of characters is escaped" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/Quote in a string is escaped" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/Backslash in a string is escaped" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/Forward slash in a string is **not** escaped" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/Backspace in a string is escaped" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/Formfeed in a string is escaped" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/linefeed in a string is escaped" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/carriage return in a string is escaped" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/tab in a string is escaped" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="JsonWriter escapes charaters in strings properly/combination of characters is escaped" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Lambdas in assertions" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Less-than inequalities with different epsilons" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="ManuallyRegistered" time="{duration}" status="run"/>

tests/SelfTest/Baselines/sonarqube.sw.approved.txt

@@ -173,16 +173,16 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="JsonWriter/Moved from JsonObjectWriter shall not insert superfluous brace" duration="{duration}"/>
     <testCase name="JsonWriter/Moved from JsonArrayWriter shall not insert superfluous bracket" duration="{duration}"/>
     <testCase name="JsonWriter/Custom class shall be quoted" duration="{duration}"/>
-    <testCase name="JsonWriter escapes characters in strings properly" duration="{duration}"/>
-    <testCase name="JsonWriter escapes characters in strings properly/Quote in a string is escaped" duration="{duration}"/>
-    <testCase name="JsonWriter escapes characters in strings properly/Backslash in a string is escaped" duration="{duration}"/>
-    <testCase name="JsonWriter escapes characters in strings properly/Forward slash in a string is **not** escaped" duration="{duration}"/>
-    <testCase name="JsonWriter escapes characters in strings properly/Backspace in a string is escaped" duration="{duration}"/>
-    <testCase name="JsonWriter escapes characters in strings properly/Formfeed in a string is escaped" duration="{duration}"/>
-    <testCase name="JsonWriter escapes characters in strings properly/linefeed in a string is escaped" duration="{duration}"/>
-    <testCase name="JsonWriter escapes characters in strings properly/carriage return in a string is escaped" duration="{duration}"/>
-    <testCase name="JsonWriter escapes characters in strings properly/tab in a string is escaped" duration="{duration}"/>
-    <testCase name="JsonWriter escapes characters in strings properly/combination of characters is escaped" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly/Quote in a string is escaped" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly/Backslash in a string is escaped" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly/Forward slash in a string is **not** escaped" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly/Backspace in a string is escaped" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly/Formfeed in a string is escaped" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly/linefeed in a string is escaped" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly/carriage return in a string is escaped" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly/tab in a string is escaped" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly/combination of characters is escaped" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp">
     <testCase name="Parse uints" duration="{duration}"/>

tests/SelfTest/Baselines/sonarqube.sw.multi.approved.txt

@@ -172,16 +172,16 @@ at AssertionHandler.tests.cpp:<line number>
     <testCase name="JsonWriter/Moved from JsonObjectWriter shall not insert superfluous brace" duration="{duration}"/>
     <testCase name="JsonWriter/Moved from JsonArrayWriter shall not insert superfluous bracket" duration="{duration}"/>
     <testCase name="JsonWriter/Custom class shall be quoted" duration="{duration}"/>
-    <testCase name="JsonWriter escapes characters in strings properly" duration="{duration}"/>
-    <testCase name="JsonWriter escapes characters in strings properly/Quote in a string is escaped" duration="{duration}"/>
-    <testCase name="JsonWriter escapes characters in strings properly/Backslash in a string is escaped" duration="{duration}"/>
-    <testCase name="JsonWriter escapes characters in strings properly/Forward slash in a string is **not** escaped" duration="{duration}"/>
-    <testCase name="JsonWriter escapes characters in strings properly/Backspace in a string is escaped" duration="{duration}"/>
-    <testCase name="JsonWriter escapes characters in strings properly/Formfeed in a string is escaped" duration="{duration}"/>
-    <testCase name="JsonWriter escapes characters in strings properly/linefeed in a string is escaped" duration="{duration}"/>
-    <testCase name="JsonWriter escapes characters in strings properly/carriage return in a string is escaped" duration="{duration}"/>
-    <testCase name="JsonWriter escapes characters in strings properly/tab in a string is escaped" duration="{duration}"/>
-    <testCase name="JsonWriter escapes characters in strings properly/combination of characters is escaped" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly/Quote in a string is escaped" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly/Backslash in a string is escaped" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly/Forward slash in a string is **not** escaped" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly/Backspace in a string is escaped" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly/Formfeed in a string is escaped" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly/linefeed in a string is escaped" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly/carriage return in a string is escaped" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly/tab in a string is escaped" duration="{duration}"/>
+    <testCase name="JsonWriter escapes charaters in strings properly/combination of characters is escaped" duration="{duration}"/>
   </file>
   <file path="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp">
     <testCase name="Parse uints" duration="{duration}"/>

tests/SelfTest/Baselines/tap.sw.approved.txt

@@ -1904,23 +1904,23 @@ ok {test-number} - stream.str() == "{\n}" for: "{ }" == "{ }"
 ok {test-number} - stream.str() == "[\n]" for: "[ ]" == "[ ]"
 # JsonWriter
 ok {test-number} - stream.str() == "\"custom\"" for: ""custom"" == ""custom""
-# JsonWriter escapes characters in strings properly
+# JsonWriter escapes charaters in strings properly
 ok {test-number} - sstream.str() == "\"\\\"\"" for: ""\""" == ""\"""
-# JsonWriter escapes characters in strings properly
+# JsonWriter escapes charaters in strings properly
 ok {test-number} - sstream.str() == "\"\\\\\"" for: ""\\"" == ""\\""
-# JsonWriter escapes characters in strings properly
+# JsonWriter escapes charaters in strings properly
 ok {test-number} - sstream.str() == "\"/\"" for: ""/"" == ""/""
-# JsonWriter escapes characters in strings properly
+# JsonWriter escapes charaters in strings properly
 ok {test-number} - sstream.str() == "\"\\b\"" for: ""\b"" == ""\b""
-# JsonWriter escapes characters in strings properly
+# JsonWriter escapes charaters in strings properly
 ok {test-number} - sstream.str() == "\"\\f\"" for: ""\f"" == ""\f""
-# JsonWriter escapes characters in strings properly
+# JsonWriter escapes charaters in strings properly
 ok {test-number} - sstream.str() == "\"\\n\"" for: ""\n"" == ""\n""
-# JsonWriter escapes characters in strings properly
+# JsonWriter escapes charaters in strings properly
 ok {test-number} - sstream.str() == "\"\\r\"" for: ""\r"" == ""\r""
-# JsonWriter escapes characters in strings properly
+# JsonWriter escapes charaters in strings properly
 ok {test-number} - sstream.str() == "\"\\t\"" for: ""\t"" == ""\t""
-# JsonWriter escapes characters in strings properly
+# JsonWriter escapes charaters in strings properly
 ok {test-number} - sstream.str() == "\"\\\\/\\t\\r\\n\"" for: ""\\/\t\r\n"" == ""\\/\t\r\n""
 # Lambdas in assertions
 ok {test-number} - []() { return true; }() for: true

tests/SelfTest/Baselines/tap.sw.multi.approved.txt

@@ -1902,23 +1902,23 @@ ok {test-number} - stream.str() == "{\n}" for: "{ }" == "{ }"
 ok {test-number} - stream.str() == "[\n]" for: "[ ]" == "[ ]"
 # JsonWriter
 ok {test-number} - stream.str() == "\"custom\"" for: ""custom"" == ""custom""
-# JsonWriter escapes characters in strings properly
+# JsonWriter escapes charaters in strings properly
 ok {test-number} - sstream.str() == "\"\\\"\"" for: ""\""" == ""\"""
-# JsonWriter escapes characters in strings properly
+# JsonWriter escapes charaters in strings properly
 ok {test-number} - sstream.str() == "\"\\\\\"" for: ""\\"" == ""\\""
-# JsonWriter escapes characters in strings properly
+# JsonWriter escapes charaters in strings properly
 ok {test-number} - sstream.str() == "\"/\"" for: ""/"" == ""/""
-# JsonWriter escapes characters in strings properly
+# JsonWriter escapes charaters in strings properly
 ok {test-number} - sstream.str() == "\"\\b\"" for: ""\b"" == ""\b""
-# JsonWriter escapes characters in strings properly
+# JsonWriter escapes charaters in strings properly
 ok {test-number} - sstream.str() == "\"\\f\"" for: ""\f"" == ""\f""
-# JsonWriter escapes characters in strings properly
+# JsonWriter escapes charaters in strings properly
 ok {test-number} - sstream.str() == "\"\\n\"" for: ""\n"" == ""\n""
-# JsonWriter escapes characters in strings properly
+# JsonWriter escapes charaters in strings properly
 ok {test-number} - sstream.str() == "\"\\r\"" for: ""\r"" == ""\r""
-# JsonWriter escapes characters in strings properly
+# JsonWriter escapes charaters in strings properly
 ok {test-number} - sstream.str() == "\"\\t\"" for: ""\t"" == ""\t""
-# JsonWriter escapes characters in strings properly
+# JsonWriter escapes charaters in strings properly
 ok {test-number} - sstream.str() == "\"\\\\/\\t\\r\\n\"" for: ""\\/\t\r\n"" == ""\\/\t\r\n""
 # Lambdas in assertions
 ok {test-number} - []() { return true; }() for: true

tests/SelfTest/Baselines/teamcity.sw.approved.txt

@@ -431,8 +431,8 @@
 ##teamcity[testFinished name='Inequality checks that should succeed' duration="{duration}"]
 ##teamcity[testStarted name='JsonWriter']
 ##teamcity[testFinished name='JsonWriter' duration="{duration}"]
-##teamcity[testStarted name='JsonWriter escapes characters in strings properly']
-##teamcity[testFinished name='JsonWriter escapes characters in strings properly' duration="{duration}"]
+##teamcity[testStarted name='JsonWriter escapes charaters in strings properly']
+##teamcity[testFinished name='JsonWriter escapes charaters in strings properly' duration="{duration}"]
 ##teamcity[testStarted name='Lambdas in assertions']
 ##teamcity[testFinished name='Lambdas in assertions' duration="{duration}"]
 ##teamcity[testStarted name='Less-than inequalities with different epsilons']

tests/SelfTest/Baselines/teamcity.sw.multi.approved.txt

@@ -431,8 +431,8 @@
 ##teamcity[testFinished name='Inequality checks that should succeed' duration="{duration}"]
 ##teamcity[testStarted name='JsonWriter']
 ##teamcity[testFinished name='JsonWriter' duration="{duration}"]
-##teamcity[testStarted name='JsonWriter escapes characters in strings properly']
-##teamcity[testFinished name='JsonWriter escapes characters in strings properly' duration="{duration}"]
+##teamcity[testStarted name='JsonWriter escapes charaters in strings properly']
+##teamcity[testFinished name='JsonWriter escapes charaters in strings properly' duration="{duration}"]
 ##teamcity[testStarted name='Lambdas in assertions']
 ##teamcity[testFinished name='Lambdas in assertions' duration="{duration}"]
 ##teamcity[testStarted name='Less-than inequalities with different epsilons']

tests/SelfTest/Baselines/xml.sw.approved.txt

@@ -9158,7 +9158,7 @@ Approx( 3.14150000000000018 )
     </Section>
     <OverallResult success="true" skips="0"/>
   </TestCase>
-  <TestCase name="JsonWriter escapes characters in strings properly" tags="[JsonWriter]" filename="tests/<exe-name>/IntrospectiveTests/Json.tests.cpp" >
+  <TestCase name="JsonWriter escapes charaters in strings properly" tags="[JsonWriter]" filename="tests/<exe-name>/IntrospectiveTests/Json.tests.cpp" >
     <Section name="Quote in a string is escaped" filename="tests/<exe-name>/IntrospectiveTests/Json.tests.cpp" >
       <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Json.tests.cpp" >
         <Original>

tests/SelfTest/Baselines/xml.sw.multi.approved.txt

@@ -9158,7 +9158,7 @@ Approx( 3.14150000000000018 )
     </Section>
     <OverallResult success="true" skips="0"/>
   </TestCase>
-  <TestCase name="JsonWriter escapes characters in strings properly" tags="[JsonWriter]" filename="tests/<exe-name>/IntrospectiveTests/Json.tests.cpp" >
+  <TestCase name="JsonWriter escapes charaters in strings properly" tags="[JsonWriter]" filename="tests/<exe-name>/IntrospectiveTests/Json.tests.cpp" >
     <Section name="Quote in a string is escaped" filename="tests/<exe-name>/IntrospectiveTests/Json.tests.cpp" >
       <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Json.tests.cpp" >
         <Original>

tests/SelfTest/IntrospectiveTests/Integer.tests.cpp

@@ -22,7 +22,7 @@ namespace {
                ExtendedMultResult<Int>{ upper_result, lower_result } );
     }
 
-    // Simple (and slow) implementation of extended multiplication for tests
+    // Simple (and slow) implmentation of extended multiplication for tests
     constexpr Catch::Detail::ExtendedMultResult<std::uint64_t>
     extendedMultNaive( std::uint64_t lhs, std::uint64_t rhs ) {
         // This is a simple long multiplication, where we split lhs and rhs

tests/SelfTest/IntrospectiveTests/Json.tests.cpp

@@ -111,7 +111,7 @@ TEST_CASE( "JsonWriter", "[JSON][JsonWriter]" ) {
     }
 }
 
-TEST_CASE( "JsonWriter escapes characters in strings properly", "[JsonWriter]" ) {
+TEST_CASE( "JsonWriter escapes charaters in strings properly", "[JsonWriter]" ) {
     std::stringstream sstream;
     SECTION( "Quote in a string is escaped" ) {
         Catch::JsonValueWriter{ sstream }.write( "\"" );

tests/SelfTest/IntrospectiveTests/RandomNumberGeneration.tests.cpp

@@ -151,7 +151,7 @@ TEMPLATE_TEST_CASE( "uniform_integer_distribution can handle unit ranges",
     Catch::SimplePcg32 pcg( seed );
 
     // We check unitary ranges of 3 different values, min for type, max for type,
-    // some value in between just to make sure
+    // some value inbetween just to make sure
     SECTION("lowest value") {
         constexpr auto lowest = std::numeric_limits<TestType>::min();
         Catch::uniform_integer_distribution<TestType> dist( lowest, lowest );
@@ -180,7 +180,7 @@ TEST_CASE( "uniform_integer_distribution can handle boolean unit ranges",
     Catch::SimplePcg32 pcg( seed );
 
     // We check unitary ranges of 3 different values, min for type, max for
-    // type, some value in between just to make sure
+    // type, some value inbetween just to make sure
     SECTION( "lowest value" ) {
         Catch::uniform_integer_distribution<bool> dist( false, false );
         CheckReturnValue( dist, pcg, false );

tests/SelfTest/IntrospectiveTests/ToString.tests.cpp

@@ -7,13 +7,10 @@
 // SPDX-License-Identifier: BSL-1.0
 
 #include <catch2/internal/catch_enum_values_registry.hpp>
-#include <catch2/matchers/catch_matchers_string.hpp>
 #include <catch2/matchers/catch_matchers_vector.hpp>
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/catch_template_test_macros.hpp>
 
-#include <chrono>
-
 enum class EnumClass3 { Value1, Value2, Value3, Value4 };
 
 struct UsesSentinel {
@@ -98,23 +95,3 @@ TEMPLATE_TEST_CASE( "Stringifying char arrays with statically known sizes",
     TestType no_null_terminator[3] = { 'a', 'b', 'c' };
     CHECK( ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s );
 }
-
-TEST_CASE( "#2944 - Stringifying dates before 1970 should not crash", "[.approvals]" ) {
-    using Catch::Matchers::Equals;
-    using Days = std::chrono::duration<int32_t, std::ratio<86400>>;
-    using SysDays = std::chrono::time_point<std::chrono::system_clock, Days>;
-    Catch::StringMaker<std::chrono::system_clock::time_point> sm;
-
-    // Check simple date first
-    const SysDays post1970{ Days{ 1 } };
-    auto converted_post = sm.convert( post1970 );
-    REQUIRE( converted_post == "1970-01-02T00:00:00Z" );
-
-    const SysDays pre1970{ Days{ -1 } };
-    auto converted_pre = sm.convert( pre1970 );
-    REQUIRE_THAT(
-        converted_pre,
-        Equals( "1969-12-31T00:00:00Z" ) ||
-            Equals( "gmtime from provided timepoint has failed. This "
-                    "happens e.g. with pre-1970 dates using Microsoft libc" ) );
-}

tests/TestScripts/ConfigureTestsCommon.py

@@ -15,7 +15,7 @@ import subprocess
 def configure_and_build(source_path: str, project_path: str, options: List[Tuple[str, str]]):
     base_configure_cmd = ['cmake',
                           '-B{}'.format(project_path),
-                          '-S{}'.format(source_path),
+                          '-H{}'.format(source_path),
                           '-DCMAKE_BUILD_TYPE=Debug',
                           '-DCATCH_DEVELOPMENT_BUILD=ON']
     for option, value in options:

tests/TestScripts/DiscoverTests/CMakeLists.txt

@@ -1,23 +1,22 @@
-cmake_minimum_required(VERSION 3.16)
-project(discover-tests-test LANGUAGES CXX)
+cmake_minimum_required(VERSION 3.10)
+
+project(discover-tests-test
+  LANGUAGES CXX
+)
+
+add_executable(tests
+  register-tests.cpp
+)
 
-add_executable(tests register-tests.cpp)
 add_subdirectory(${CATCH2_PATH} catch2-build)
 target_link_libraries(tests PRIVATE Catch2::Catch2WithMain)
 
 enable_testing()
 include(Catch)
 set(extra_args)
-if(CMAKE_VERSION GREATER_EQUAL 3.27)
-  list(APPEND extra_args
-    DL_PATHS "${CMAKE_CURRENT_LIST_DIR};${CMAKE_CURRENT_LIST_DIR}/.."
-  )
-endif()
-catch_discover_tests(
-  tests
-  ADD_TAGS_AS_LABELS
-  DISCOVERY_MODE PRE_TEST
-  ${extra_args}
-)
-
-# DISCOVERY_MODE <POST_BUILD|PRE_TEST>
+if (CMAKE_VERSION GREATER_EQUAL 3.27)
+    list(APPEND extra_args
+            DL_PATHS "${CMAKE_CURRENT_LIST_DIR};${CMAKE_CURRENT_LIST_DIR}/.."
+    )
+endif ()
+catch_discover_tests(tests ${extra_args})

tests/TestScripts/DiscoverTests/VerifyRegistration.py

@@ -12,10 +12,6 @@ import subprocess
 import sys
 import re
 import json
-from collections import namedtuple
-from typing import List
-
-TestInfo = namedtuple('TestInfo', ['name', 'tags'])
 
 cmake_version_regex = re.compile('cmake version (\d+)\.(\d+)\.(\d+)')
 
@@ -65,7 +61,7 @@ def build_project(sources_dir, output_base_path, catch2_path):
 
 
 
-def get_test_names(build_path: str) -> List[TestInfo]:
+def get_test_names(build_path):
     # For now we assume that Windows builds are done using MSBuild under
     # Debug configuration. This means that we need to add "Debug" folder
     # to the path when constructing it. On Linux, we don't add anything.
@@ -73,23 +69,15 @@ def get_test_names(build_path: str) -> List[TestInfo]:
     full_path = os.path.join(build_path, config_path, 'tests')
 
 
-    cmd = [full_path, '--reporter', 'json', '--list-tests']
+    cmd = [full_path, '--reporter', 'xml', '--list-tests']
     result = subprocess.run(cmd,
                             capture_output = True,
                             check = True,
                             text = True)
 
-    test_listing = json.loads(result.stdout)
-
-    assert test_listing['version'] == 1
-
-    tests = []
-    for test in test_listing['listings']['tests']:
-        test_name = test['name']
-        tags = test['tags']
-        tests.append(TestInfo(test_name, tags))
-
-    return tests
+    import xml.etree.ElementTree as ET
+    root = ET.fromstring(result.stdout)
+    return [tc.text for tc in root.findall('TestCase/Name')]
 
 def get_ctest_listing(build_path):
     old_path = os.getcwd()
@@ -103,25 +91,20 @@ def get_ctest_listing(build_path):
     os.chdir(old_path)
     return result.stdout
 
-def extract_tests_from_ctest(ctest_output) -> List[TestInfo]:
+def extract_tests_from_ctest(ctest_output):
     ctest_response = json.loads(ctest_output)
     tests = ctest_response['tests']
-    test_infos = []
+    test_names = []
     for test in tests:
         test_command = test['command']
         # First part of the command is the binary, second is the filter.
         # If there are less, registration has failed. If there are more,
         # registration has changed and the script needs updating.
         assert len(test_command) == 2
+        test_names.append(test_command[1])
         test_name = test_command[1]
-        labels = []
-        for prop in test['properties']:
-            if prop['name'] == 'LABELS':
-                labels = prop['value']
 
-        test_infos.append(TestInfo(test_name, labels))
-
-    return test_infos
+    return test_names
 
 def check_DL_PATHS(ctest_output):
     ctest_response = json.loads(ctest_output)
@@ -132,14 +115,10 @@ def check_DL_PATHS(ctest_output):
             if property['name'] == 'ENVIRONMENT_MODIFICATION':
                 assert len(property['value']) == 2, f"The test provides 2 arguments to DL_PATHS, but instead found {len(property['value'])}"
 
-def escape_catch2_test_names(infos: List[TestInfo]):
-    escaped = []
-    for info in infos:
-      name = info.name
-      for char in ('\\', ',', '[', ']'):
-          name = name.replace(char, f"\\{char}")
-      escaped.append(TestInfo(name, info.tags))
-    return escaped
+def escape_catch2_test_name(name):
+    for char in ('\\', ',', '[', ']'):
+        name = name.replace(char, f"\\{char}")
+    return name
 
 if __name__ == '__main__':
     if len(sys.argv) != 3:
@@ -151,7 +130,7 @@ if __name__ == '__main__':
 
     build_path = build_project(sources_dir, output_base_path, catch2_path)
 
-    catch_test_names = escape_catch2_test_names(get_test_names(build_path))
+    catch_test_names = [escape_catch2_test_name(name) for name in get_test_names(build_path)]
     ctest_output = get_ctest_listing(build_path)
     ctest_test_names = extract_tests_from_ctest(ctest_output)
 
@@ -168,7 +147,6 @@ if __name__ == '__main__':
     if mismatched:
         print(f"Found {mismatched} mismatched tests catch test names and ctest test commands!")
         exit(1)
-    print(f"{len(catch_test_names)} tests matched")
 
     cmake_version = get_cmake_version()
     if cmake_version >= (3, 27):

tests/TestScripts/DiscoverTests/register-tests.cpp

@@ -14,10 +14,3 @@ TEST_CASE( "Let's have a test case with a long name. Longer. No, even longer. "
            "Really looooooooooooong. Even longer than that. Multiple lines "
            "worth of test name. Yep, like this." ) {}
 TEST_CASE( "And now a test case with weird tags.", "[tl;dr][tl;dw][foo,bar]" ) {}
-// Also check that we handle tests on class, which have name in output as 'class-name', not 'name'.
-class TestCaseFixture {
-public:
-    int m_a;
-};
-
-TEST_CASE_METHOD(TestCaseFixture, "A test case as method", "[tagstagstags]") {}

tests/TestScripts/testBazelSharding.py

@@ -46,15 +46,10 @@ env["TEST_SHARD_INDEX"] = "0"
 env["TEST_TOTAL_SHARDS"] = "2"
 env["TEST_SHARD_STATUS_FILE"] = info_file_path
 
-cmd = [
-  bin_path,
-  # We rely on the test order being deterministic
-  '--order', 'decl'
-]
 
 try:
     ret = subprocess.run(
-        cmd,
+        bin_path,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
         check=True,

tools/misc/CMakeLists.txt

@@ -1,8 +1,11 @@
-cmake_minimum_required(VERSION 3.16)
-project(CatchCoverageHelper LANGUAGES CXX)
+cmake_minimum_required(VERSION 3.0)
+
+project(CatchCoverageHelper)
 
 add_executable(CoverageHelper coverage-helper.cpp)
-target_compile_features(CoverageHelper PRIVATE cxx_std_11)
-if(MSVC)
-  target_compile_options(CoverageHelper PRIVATE /W4 /w44265 /WX /w44061 /w44062)
+set_property(TARGET CoverageHelper PROPERTY CXX_STANDARD 11)
+set_property(TARGET CoverageHelper PROPERTY CXX_STANDARD_REQUIRED ON)
+set_property(TARGET CoverageHelper PROPERTY CXX_EXTENSIONS OFF)
+if (MSVC)
+    target_compile_options( CoverageHelper PRIVATE /W4 /w44265 /WX /w44061 /w44062 )
 endif()

tools/misc/appveyorBuildConfigurationScript.bat

@@ -8,14 +8,14 @@ SETLOCAL EnableDelayedExpansion
 if "%CONFIGURATION%"=="Debug" (
   if "%coverage%"=="1" (
     @REM # coverage needs to build the special helper as well as the main
-    cmake -Stools/misc -Bbuild-misc -A%PLATFORM% || exit /b !ERRORLEVEL!
+    cmake -Htools/misc -Bbuild-misc -A%PLATFORM% || exit /b !ERRORLEVEL!
     cmake --build build-misc || exit /b !ERRORLEVEL!
-    cmake -S. -BBuild -A%PLATFORM% -DCATCH_TEST_USE_WMAIN=%wmain% -DMEMORYCHECK_COMMAND=build-misc\Debug\CoverageHelper.exe -DMEMORYCHECK_COMMAND_OPTIONS=--sep-- -DMEMORYCHECK_TYPE=Valgrind -DCATCH_BUILD_EXAMPLES=%examples% -DCATCH_BUILD_EXTRA_TESTS=%examples% -DCATCH_ENABLE_CONFIGURE_TESTS=%configure_tests% -DCATCH_DEVELOPMENT_BUILD=ON || exit /b !ERRORLEVEL!
+    cmake -H. -BBuild -A%PLATFORM% -DCATCH_TEST_USE_WMAIN=%wmain% -DMEMORYCHECK_COMMAND=build-misc\Debug\CoverageHelper.exe -DMEMORYCHECK_COMMAND_OPTIONS=--sep-- -DMEMORYCHECK_TYPE=Valgrind -DCATCH_BUILD_EXAMPLES=%examples% -DCATCH_BUILD_EXTRA_TESTS=%examples% -DCATCH_ENABLE_CONFIGURE_TESTS=%configure_tests% -DCATCH_DEVELOPMENT_BUILD=ON || exit /b !ERRORLEVEL!
   ) else (
     @REM # We know that coverage is 0
-    cmake -S. -BBuild -A%PLATFORM% -DCATCH_TEST_USE_WMAIN=%wmain% -DCATCH_BUILD_EXAMPLES=%examples% -DCATCH_BUILD_EXTRA_TESTS=%examples% -DCATCH_BUILD_SURROGATES=%surrogates% -DCATCH_DEVELOPMENT_BUILD=ON -DCATCH_ENABLE_CONFIGURE_TESTS=%configure_tests% || exit /b !ERRORLEVEL!
+    cmake -H. -BBuild -A%PLATFORM% -DCATCH_TEST_USE_WMAIN=%wmain% -DCATCH_BUILD_EXAMPLES=%examples% -DCATCH_BUILD_EXTRA_TESTS=%examples% -DCATCH_BUILD_SURROGATES=%surrogates% -DCATCH_DEVELOPMENT_BUILD=ON -DCATCH_ENABLE_CONFIGURE_TESTS=%configure_tests% || exit /b !ERRORLEVEL!
   )
 )
 if "%CONFIGURATION%"=="Release" (
-  cmake -S. -BBuild -A%PLATFORM% -DCATCH_TEST_USE_WMAIN=%wmain% -DCATCH_DEVELOPMENT_BUILD=ON || exit /b !ERRORLEVEL!
+  cmake -H. -BBuild -A%PLATFORM% -DCATCH_TEST_USE_WMAIN=%wmain% -DCATCH_DEVELOPMENT_BUILD=ON || exit /b !ERRORLEVEL!
 )