Use std::string_view

Use std::optional
Upgrade to C++17
2025-09-23 21:15:39 +02:00 · 2025-09-22 11:50:44 -06:00 · 2025-09-22 11:35:23 -06:00 · 2025-09-22 11:35:22 -06:00 · 2025-09-21 21:43:51 -06:00 · 2025-09-17 20:25:26 +02:00
208 changed files with 2099 additions and 4852 deletions
--- a/.clang-format
+++ b/.clang-format
@@ -1,6 +1,6 @@
 ---
 Language: Cpp
-Standard: c++14
+Standard: c++17

 # Note that we cannot use IncludeIsMainRegex functionality, because it
 # does not support includes in angle brackets (<>)
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -28,13 +28,12 @@ Checks: >-
  -modernize-concat-nested-namespaces,
  -modernize-use-nodiscard,
  -modernize-use-default-member-init,
-  -modernize-type-traits,# we need to support C++14,
  -modernize-deprecated-headers,
  ,# There's a lot of these and most of them are probably not useful,
  -modernize-pass-by-value,

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

  portability-*,

--- a/.github/workflows/linux-meson-builds.yml
+++ b/.github/workflows/linux-meson-builds.yml
@@ -4,7 +4,7 @@ on: [push, pull_request]

 jobs:
  build:
-    name: meson ${{matrix.cxx}}, C++${{matrix.std}}, ${{matrix.build_type}}
+    name: meson ${{matrix.cxx}}, ${{matrix.build_type}}
    runs-on: ubuntu-22.04
    strategy:
      fail-fast: false
@@ -13,7 +13,6 @@ jobs:
          - g++-11
          - clang++-11
        build_type: [debug, release]
-        std: [14, 17]
        include:
          - cxx: clang++-11
            other_pkgs: clang-11
@@ -29,7 +28,7 @@ jobs:
    - name: Configure
      env:
        CXX: ${{matrix.cxx}}
-        CXXFLAGS: -std=c++${{matrix.std}} ${{matrix.cxxflags}}
+        CXXFLAGS: -std=c++17 ${{matrix.cxxflags}}
      # Note: $GITHUB_WORKSPACE is distinct from ${{runner.workspace}}.
      #       This is important
      run: |
--- a/.github/workflows/linux-other-builds.yml
+++ b/.github/workflows/linux-other-builds.yml
@@ -7,7 +7,7 @@ on: [push, pull_request]

 jobs:
  build:
-    name: ${{matrix.build_description}}, ${{matrix.cxx}}, C++${{matrix.std}} ${{matrix.build_type}}
+    name: ${{matrix.build_description}}, ${{matrix.cxx}}, ${{matrix.build_type}}
    runs-on: ubuntu-22.04
    strategy:
      fail-fast: false
@@ -20,7 +20,6 @@ jobs:
          - cxx: clang++-14
            build_description: Surrogates build
            build_type: Debug
-            std: 14
            other_pkgs: clang-14
            cmake_configurations: -DCATCH_BUILD_SURROGATES=ON

@@ -28,13 +27,11 @@ jobs:
          - cxx: g++-11
            build_description: Extras + Examples
            build_type: Debug
-            std: 14
            other_pkgs: g++-11
            cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON
          - cxx: g++-11
            build_description: Extras + Examples
            build_type: Release
-            std: 14
            other_pkgs: g++-11
            cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON

@@ -42,29 +39,18 @@ jobs:
          - cxx: clang++-14
            build_description: Extras + Examples
            build_type: Debug
-            std: 17
            other_pkgs: clang-14
            cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON
          - cxx: clang++-14
            build_description: Extras + Examples
            build_type: Release
-            std: 17
            other_pkgs: clang-14
            cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON

-          # Configure tests with Clang-14
-          - cxx: clang++-14
-            build_description: CMake configuration tests
-            build_type: Debug
-            std: 14
-            other_pkgs: clang-14
-            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
@@ -83,7 +69,6 @@ jobs:
        cmake --preset basic-tests -GNinja \
              -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
              -DCMAKE_CXX_COMPILER=${{matrix.cxx}} \
-              -DCMAKE_CXX_STANDARD=${{matrix.std}} \
              ${{matrix.cmake_configurations}}

    - name: Build
@@ -116,7 +101,6 @@ jobs:
              -DCMAKE_CXX_COMPILER_LAUNCHER=/usr/bin/true \
              -DCMAKE_CXX_COMPILER=clang++-15 \
              -DCMAKE_CXX_LINK_EXECUTABLE=/usr/bin/true \
-              -DCMAKE_CXX_STANDARD=17 \
              -DCMAKE_RANLIB=/usr/bin/true \
              -DCATCH_BUILD_EXAMPLES=ON \
              -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON
--- a/.github/workflows/linux-simple-builds.yml
+++ b/.github/workflows/linux-simple-builds.yml
@@ -14,7 +14,6 @@ jobs:
          - g++-10
          - g++-11
          - g++-12
-          - clang++-6.0
          - clang++-7
          - clang++-8
          - clang++-9
@@ -24,7 +23,7 @@ jobs:
          - clang++-13
          - clang++-14
        build_type: [Debug, Release]
-        std: [14]
+        std: [17]
        include:
          - cxx: g++-9
            other_pkgs: g++-9
@@ -34,8 +33,6 @@ jobs:
            other_pkgs: g++-11
          - cxx: g++-12
            other_pkgs: g++-12
-          - cxx: clang++-6.0
-            other_pkgs: clang-6.0
          - cxx: clang++-7
            other_pkgs: clang-7
          - cxx: clang++-8
@@ -52,15 +49,6 @@ jobs:
            other_pkgs: clang-13
          - cxx: clang++-14
            other_pkgs: clang-14
-          # Clang 14 + C++17
-          - cxx: clang++-14
-            build_type: Debug
-            std: 17
-            other_pkgs: clang-14
-          - cxx: clang++-14
-            build_type: Release
-            std: 17
-            other_pkgs: clang-14
          - cxx: clang++-14
            build_type: Debug
            std: 20
--- a/.github/workflows/mac-builds.yml
+++ b/.github/workflows/mac-builds.yml
@@ -12,7 +12,6 @@ jobs:
      matrix:
        image: [macos-13, macos-14, macos-15]
        build_type: [Debug, Release]
-        std: [14, 17]

    steps:
    - uses: actions/checkout@v4
@@ -21,7 +20,6 @@ jobs:
      run: |
        cmake --preset basic-tests -GNinja \
              -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
-              -DCMAKE_CXX_STANDARD=${{matrix.std}} \
              -DCATCH_BUILD_EXAMPLES=ON \
              -DCATCH_BUILD_EXTRA_TESTS=ON

--- a/.github/workflows/windows-simple-builds.yml
+++ b/.github/workflows/windows-simple-builds.yml
@@ -4,7 +4,7 @@ on: [push, pull_request]

 jobs:
  build:
-    name: ${{matrix.os}}, ${{matrix.std}}, ${{matrix.build_type}}, ${{matrix.platform}}
+    name: ${{matrix.os}}, ${{matrix.build_type}}, ${{matrix.platform}}
    runs-on: ${{matrix.os}}
    strategy:
      fail-fast: false
@@ -12,7 +12,6 @@ jobs:
        os: [windows-2022, windows-2025]
        platform: [Win32, x64]
        build_type: [Debug, Release]
-        std: [14, 17]
    steps:
      - uses: actions/checkout@v4

@@ -20,7 +19,6 @@ jobs:
        run: |
          cmake --preset all-tests `
                -A ${{matrix.platform}} `
-                -DCMAKE_CXX_STANDARD=${{matrix.std}} `

      - name: Build tests
        run: cmake --build build --config ${{matrix.build_type}} --parallel %NUMBER_OF_PROCESSORS%
--- a/BUILD.bazel
+++ b/BUILD.bazel
@@ -27,11 +27,6 @@ expand_template(
        "#cmakedefine CATCH_CONFIG_COLOUR_WIN32": "",
        "#cmakedefine CATCH_CONFIG_COUNTER": "",
        "#cmakedefine CATCH_CONFIG_CPP11_TO_STRING": "",
-        "#cmakedefine CATCH_CONFIG_CPP17_BYTE": "",
-        "#cmakedefine CATCH_CONFIG_CPP17_OPTIONAL": "",
-        "#cmakedefine CATCH_CONFIG_CPP17_STRING_VIEW": "",
-        "#cmakedefine CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS": "",
-        "#cmakedefine CATCH_CONFIG_CPP17_VARIANT": "",
        "#cmakedefine CATCH_CONFIG_DEPRECATION_ANNOTATIONS": "",
        "#cmakedefine CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER": "",
        "#cmakedefine CATCH_CONFIG_DISABLE_EXCEPTIONS": "",
@@ -51,11 +46,6 @@ expand_template(
        "#cmakedefine CATCH_CONFIG_NO_COLOUR_WIN32": "",
        "#cmakedefine CATCH_CONFIG_NO_COUNTER": "",
        "#cmakedefine CATCH_CONFIG_NO_CPP11_TO_STRING": "",
-        "#cmakedefine CATCH_CONFIG_NO_CPP17_BYTE": "",
-        "#cmakedefine CATCH_CONFIG_NO_CPP17_OPTIONAL": "",
-        "#cmakedefine CATCH_CONFIG_NO_CPP17_STRING_VIEW": "",
-        "#cmakedefine CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS": "",
-        "#cmakedefine CATCH_CONFIG_NO_CPP17_VARIANT": "",
        "#cmakedefine CATCH_CONFIG_NO_DEPRECATION_ANNOTATIONS": "",
        "#cmakedefine CATCH_CONFIG_NO_GETENV": "",
        "#cmakedefine CATCH_CONFIG_NO_GLOBAL_NEXTAFTER": "",
--- a/CMake/CatchConfigOptions.cmake
+++ b/CMake/CatchConfigOptions.cmake
@@ -31,11 +31,6 @@ set(_OverridableOptions
  "COLOUR_WIN32"
  "COUNTER"
  "CPP11_TO_STRING"
-  "CPP17_BYTE"
-  "CPP17_OPTIONAL"
-  "CPP17_STRING_VIEW"
-  "CPP17_UNCAUGHT_EXCEPTIONS"
-  "CPP17_VARIANT"
  "GLOBAL_NEXTAFTER"
  "POSIX_SIGNALS"
  "USE_ASYNC"
--- a/CMake/catch2-with-main.pc.in
+++ b/CMake/catch2-with-main.pc.in
@@ -3,7 +3,7 @@ libdir=${prefix}/@lib_dir@
 pkg_version=@Catch2_VERSION@

 Name: Catch2 with main function
-Description: A modern, C++-native test framework for C++14 and above (links in default main)
+Description: A modern, C++-native test framework for C++17 and above (links in default main)
 URL: https://github.com/catchorg/Catch2
 Version: ${pkg_version}
 Requires: catch2 = ${pkg_version}
--- a/CMake/catch2.pc.in
+++ b/CMake/catch2.pc.in
@@ -4,7 +4,7 @@ includedir=${prefix}/@include_dir@
 libdir=${prefix}/@lib_dir@

 Name: Catch2
-Description: A modern, C++-native, test framework for C++14 and above
+Description: A modern, C++-native, test framework for C++17 and above
 URL: https://github.com/catchorg/Catch2
 Version: @Catch2_VERSION@
 Cflags: -I${includedir}
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -34,7 +34,7 @@ if(CMAKE_BINARY_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
 endif()

 project(Catch2
-  VERSION 3.9.1 # CML version placeholder, don't delete
+  VERSION 3.10.0 # CML version placeholder, don't delete
  LANGUAGES CXX
  HOMEPAGE_URL "https://github.com/catchorg/Catch2"
  DESCRIPTION "A modern, C++-native, unit test framework."
@@ -195,17 +195,23 @@ if(NOT_SUBPROJECT)
       "set(include_dir \"${CMAKE_INSTALL_INCLUDEDIR}\")"
       "set(lib_dir \"${CMAKE_INSTALL_LIBDIR}\")"
       [[
+         message(STATUS "DESTDIR: $ENV{DESTDIR}")
+         set(DESTDIR_PREFIX "")
+         if (DEFINED ENV{DESTDIR})
+           set(DESTDIR_PREFIX "$ENV{DESTDIR}")
+         endif ()
+         message(STATUS "PREFIX: ${DESTDIR_PREFIX}")
         set(lib_name "$<TARGET_FILE_BASE_NAME:Catch2>")
         configure_file(
           "${impl_pc_file}"
-           "${CMAKE_INSTALL_PREFIX}/${install_pkgconfdir}/catch2.pc"
+           "${DESTDIR_PREFIX}${CMAKE_INSTALL_PREFIX}/${install_pkgconfdir}/catch2.pc"
           @ONLY
         )

         set(lib_name "$<TARGET_FILE_BASE_NAME:Catch2WithMain>")
         configure_file(
           "${main_pc_file}"
-           "${CMAKE_INSTALL_PREFIX}/${install_pkgconfdir}/catch2-with-main.pc"
+           "${DESTDIR_PREFIX}${CMAKE_INSTALL_PREFIX}/${install_pkgconfdir}/catch2-with-main.pc"
           @ONLY
         )
       ]]
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -11,7 +11,8 @@
                "CMAKE_CXX_EXTENSIONS": "OFF",
                "CMAKE_CXX_STANDARD_REQUIRED": "ON",
                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
-                "CATCH_DEVELOPMENT_BUILD": "ON"
+                "CATCH_DEVELOPMENT_BUILD": "ON",
+                "CATCH_ENABLE_REPRODUCIBLE_BUILD": "OFF"
            }
        },
        {
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -10,7 +10,6 @@
 [Default reporter](#default-reporter)<br>
 [Bazel support](#bazel-support)<br>
 [C++11 toggles](#c11-toggles)<br>
-[C++17 toggles](#c17-toggles)<br>
 [Other toggles](#other-toggles)<br>
 [Enabling stringification](#enabling-stringification)<br>
 [Disabling exceptions](#disabling-exceptions)<br>
@@ -128,23 +127,6 @@ Catch's selection, by defining either `CATCH_CONFIG_CPP11_TO_STRING` or
 `CATCH_CONFIG_NO_CPP11_TO_STRING`.


-## C++17 toggles
-
-    CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS  // Override std::uncaught_exceptions (instead of std::uncaught_exception) support detection
-    CATCH_CONFIG_CPP17_STRING_VIEW          // Override std::string_view support detection (Catch provides a StringMaker specialization by default)
-    CATCH_CONFIG_CPP17_VARIANT              // Override std::variant support detection (checked by CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER)
-    CATCH_CONFIG_CPP17_OPTIONAL             // Override std::optional support detection (checked by CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER)
-    CATCH_CONFIG_CPP17_BYTE                 // Override std::byte support detection (Catch provides a StringMaker specialization by default)
-
-> `CATCH_CONFIG_CPP17_STRING_VIEW` was [introduced](https://github.com/catchorg/Catch2/issues/1376) in Catch2 2.4.1.
-
-Catch contains basic compiler/standard detection and attempts to use
-some C++17 features whenever appropriate. This automatic detection
-can be manually overridden in both directions, that is, a feature
-can be enabled by defining the macro in the table above, and disabled
-by using `_NO_` in the macro, e.g. `CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS`.
-
-
 ## Other toggles

    CATCH_CONFIG_COUNTER                    // Use __COUNTER__ to generate unique names for test cases
@@ -221,8 +203,8 @@ By default, Catch does not stringify some types from the standard library. This

    CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER     // Provide StringMaker specialization for std::pair
    CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER    // Provide StringMaker specialization for std::tuple
-    CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER  // Provide StringMaker specialization for std::variant, std::monostate (on C++17)
-    CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER // Provide StringMaker specialization for std::optional (on C++17)
+    CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER  // Provide StringMaker specialization for std::variant, std::monostate
+    CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER // Provide StringMaker specialization for std::optional
    CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS     // Defines all of the above

 > `CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER` was [introduced](https://github.com/catchorg/Catch2/issues/1380) in Catch2 2.4.1.
--- a/docs/contributing.md
+++ b/docs/contributing.md
@@ -211,16 +211,10 @@ and so on.

 ### C++ standard version

-Catch2 currently targets C++14 as the minimum supported C++ version.
+Catch2 currently targets C++17 as the minimum supported C++ version.
 Features from higher language versions should be used only sparingly,
 when the benefits from using them outweigh the maintenance overhead.

-Example of good use of polyfilling features is our use of `conjunction`,
-where if available we use `std::conjunction` and otherwise provide our
-own implementation. The reason it is good is that the surface area for
-maintenance is quite small, and `std::conjunction` can directly use
-compiler built-ins, thus providing significant compilation benefits.
-
 Example of bad use of polyfilling features would be to keep around two
 sets of metaprogramming in the stringification implementation, once
 using C++14 compliant TMP and once using C++17's `if constexpr`. While
--- a/docs/other-macros.md
+++ b/docs/other-macros.md
@@ -72,8 +72,8 @@ including the Catch2 header.
 Example:
 ```cpp
 TEST_CASE("STATIC_REQUIRE showcase", "[traits]") {
-    STATIC_REQUIRE( std::is_void<void>::value );
-    STATIC_REQUIRE_FALSE( std::is_void<int>::value );
+    STATIC_REQUIRE( std::is_void_v<void> );
+    STATIC_REQUIRE_FALSE( std::is_void_v<int> );
 }
 ```

@@ -86,8 +86,8 @@ becomes equivalent to `CHECK` instead of `REQUIRE`.
 Example:
 ```cpp
 TEST_CASE("STATIC_CHECK showcase", "[traits]") {
-    STATIC_CHECK( std::is_void<void>::value );
-    STATIC_CHECK_FALSE( std::is_void<int>::value );
+    STATIC_CHECK( std::is_void_v<void> );
+    STATIC_CHECK_FALSE( std::is_void_v<int> );
 }
 ```

--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -2,6 +2,7 @@

 # Release notes
 **Contents**<br>
+[3.10.0](#3100)<br>
 [3.9.1](#391)<br>
 [3.9.0](#390)<br>
 [3.8.1](#381)<br>
@@ -69,6 +70,19 @@
 [Even Older versions](#even-older-versions)<br>


+## 3.10.0
+
+### Fixes
+* pkg-config files will take `DESTDIR` env var into account when selecting install destination (#3006, #3019)
+* Changed `filter` to store the provided predicate by value (#3002, #3005)
+  * This is done to avoid dangling-by-default behaviour when `filter` is used inside `GENERATE_COPY`/`GENERATE_REF`.
+
+### Improvements
+* Escaping XML and JSON output is faster when the strings do not need escaping.
+  * The improvement starts at about 3x throughput, up to 10x for long strings.
+* Message macros (`INFO`, `CAPTURE`, `WARN`, `SUCCEED`, etc) are now thread safe.
+
+
 ## 3.9.1

 ### Fixes
--- a/docs/reporter-events.md
+++ b/docs/reporter-events.md
@@ -109,10 +109,10 @@ and then `assertionEnded` event is emitted.
 > [Introduced](https://github.com/catchorg/Catch2/issues/1616) in Catch2 2.9.0.

 ```cpp
-void benchmarkPreparing( StringRef name ) override;
+void benchmarkPreparing( std::string_view name ) override;
 void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
 void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
-void benchmarkFailed( StringRef error ) override;
+void benchmarkFailed( std::string_view error ) override;
 ```

 Due to the benchmark lifecycle being bit more complicated, the benchmarking
@@ -153,9 +153,9 @@ void listTags( std::vector<TagInfo> const& tagInfos );
 ## Miscellaneous events

 ```cpp
-void reportInvalidTestSpec( StringRef unmatchedSpec );
-void fatalErrorEncountered( StringRef error );
-void noMatchingTestCases( StringRef unmatchedSpec );
+void reportInvalidTestSpec( std::string_view unmatchedSpec );
+void fatalErrorEncountered( std::string_view error );
+void noMatchingTestCases( std::string_view unmatchedSpec );
 ```

 These are one-off events that do not neatly fit into other categories.
--- a/docs/test-cases-and-sections.md
+++ b/docs/test-cases-and-sections.md
@@ -264,7 +264,7 @@ You can also have different arities in the _template-arg_ packs:
 ```cpp
 TEMPLATE_PRODUCT_TEST_CASE("Product with differing arities", "[template][product]", std::tuple, (int, (int, double), (int, double, float))) {
    TestType x;
-    REQUIRE(std::tuple_size<TestType>::value >= 1);
+    REQUIRE(std::tuple_size_v<TestType> >= 1);
 }
 ```

--- a/docs/thread-safety.md
+++ b/docs/thread-safety.md
@@ -2,7 +2,9 @@
 # Thread safety in Catch2

 **Contents**<br>
-[Using assertion macros from multiple threads](#using-assertion-macros-from-multiple-threads)<br>
+[Using assertion macros from spawned threads](#using-assertion-macros-from-spawned-threads)<br>
+[Assertion-like message macros and spawned threads](#assertion-like-message-macros-and-spawned-threads)<br>
+[Message macros and spawned threads](#message-macros-and-spawned-threads)<br>
 [examples](#examples)<br>
 [`STATIC_REQUIRE` and `STATIC_CHECK`](#static_require-and-static_check)<br>
 [Fatal errors and multiple threads](#fatal-errors-and-multiple-threads)<br>
@@ -10,17 +12,18 @@

 > Thread safe assertions were introduced in Catch2 3.9.0

-Thread safety in Catch2 is currently limited to all the assertion macros.
-Interacting with benchmark macros, message macros (e.g. `INFO` or `CAPTURE`),
-sections macros, generator macros, or test case macros is not thread-safe.
-The message macros are likely to be made thread-safe in the future, but
-the way sections define test runs is incompatible with user being able
-to spawn threads arbitrarily, thus that limitation is here to stay.
+Thread safety in Catch2 is currently limited to all the assertion macros,
+and to message or message-adjacent macros (e.g. `INFO` or `WARN`).
+
+Interacting with benchmark macros, sections macros, generator macros, or
+test case macros is not thread-safe. The way sections define paths through
+the test is incompatible with user spawning threads arbitrarily, so this
+limitation is here to stay.

 **Important: thread safety in Catch2 is [opt-in](configuration.md#experimental-thread-safety)**


-## Using assertion macros from multiple threads
+## Using assertion macros from spawned threads

 The full set of Catch2's runtime assertion macros is thread-safe. However,
 it is important to keep in mind that their semantics might not support
@@ -30,7 +33,7 @@ Specifically, the `REQUIRE` family of assertion macros have semantics
 of stopping the test execution on failure. This is done by throwing
 an exception, but since the user-spawned thread will not have the test-level
 try-catch block ready to catch the test failure exception, failing a
-`REQUIRE` assertion inside this thread will terminate the process.
+`REQUIRE` assertion inside user-spawned thread will terminate the process.

 The `CHECK` family of assertions does not have this issue, because it
 does not try to stop the test execution.
@@ -38,16 +41,36 @@ does not try to stop the test execution.
 Note that `CHECKED_IF` and `CHECKED_ELSE` are also thread safe (internally
 they are assertion macro + an if).

-**`SKIP()`, `FAIL()`, `SUCCEED()` are not assertion macros, and are not
-thread-safe.**
+
+## Assertion-like message macros and spawned threads
+
+> Assertion-like messages were made thread safe in Catch2 3.10.0
+
+Similarly to assertion macros, not all assertion-like message macros can
+be used from spawned thread.
+
+`SKIP` and `FAIL` macros stop the test execution. Just like with `REQUIRE`,
+this means that they cannot be used inside user-spawned threads. `SUCCEED`,
+`FAIL_CHECK` and `WARN` do not attempt to stop the test execution and
+thus can be used from any thread.
+
+
+## Message macros and spawned threads
+
+> Message macros were made thread safe in Catch2 3.10.0
+
+Macros that add extra messages to following assertion, such as `INFO`
+or `CAPTURE`, are all thread safe and can be used in any thread. Note
+that these messages are per-thread, and thus `INFO` inside a user-spawned
+thread will not be seen by the main thread, and vice versa.


 ## examples

-### `REQUIRE` from main thread, `CHECK` from spawned threads
+### `REQUIRE` from the main thread, `CHECK` from spawned threads

 ```cpp
-TEST_CASE( "Failed REQUIRE in main thread is fine" ) {
+TEST_CASE( "Failed REQUIRE in the main thread is fine" ) {
    std::vector<std::jthread> threads;
    for ( size_t t = 0; t < 16; ++t) {
        threads.emplace_back( []() {
@@ -85,7 +108,7 @@ TEST_CASE( "Successful REQUIRE in spawned thread is fine" ) {
 This will also work as expected, because the `REQUIRE` is successful.

 ```cpp
-TEST_CASE( "Failed REQUIRE in spawned thread is fine" ) {
+TEST_CASE( "Failed REQUIRE in spawned thread kills the process" ) {
    std::vector<std::jthread> threads;
    for ( size_t t = 0; t < 16; ++t) {
        threads.emplace_back( []() {
@@ -99,12 +122,88 @@ TEST_CASE( "Failed REQUIRE in spawned thread is fine" ) {
 This will fail catastrophically and terminate the process.


+### INFO across threads
+
+```cpp
+TEST_CASE( "messages don't cross threads" ) {
+    std::jthread t1( [&]() {
+        for ( size_t i = 0; i < 100; ++i ) {
+            INFO( "spawned thread #1" );
+            CHECK( 1 == 1 );
+        }
+    } );
+
+    std::thread t2( [&]() {
+        for (size_t i = 0; i < 100; ++i) {
+            UNSCOPED_INFO( "spawned thread #2" );
+        }
+    } );
+
+    for (size_t i = 0; i < 100; ++i) {
+        CHECK( 1 == 2 );
+    }
+}
+```
+None of the failed checks will show the "spawned thread #1" message, as
+that message is for the `t1` thread. If the reporter shows passing
+assertions (e.g. due to the tests being run with `-s`), you will see the
+"spawned thread #1" message alongside the passing `CHECK( 1 == 1 )` assertion.
+
+The message "spawned thread #2" will never be shown, because there are no
+assertions in `t2`.
+
+
+### FAIL/SKIP from the main thread
+
+```cpp
+TEST_CASE( "FAIL in the main thread is fine" ) {
+    std::vector<std::jthread> threads;
+    for ( size_t t = 0; t < 16; ++t) {
+        threads.emplace_back( []() {
+            for (size_t i = 0; i < 10; ++i) {
+                CHECK( true );
+                CHECK( false );
+            }
+        } );
+    }
+
+    FAIL();
+}
+```
+
+This will work as expected, that is, the process will finish running
+normally, the test case will fail and there will be 321 total assertions,
+160 passing and 161 failing (`FAIL` counts as failed assertion).
+
+However, when the main thread hits `FAIL`, it will wait for the other
+threads to finish due to `std::jthread`'s destructor joining the spawned
+thread. Due to this, using `SKIP` is not recommended once more threads
+are spawned; while the main thread will bail from the test execution,
+the spawned threads will keep running and may fail the test case.
+
+
+### FAIL/SKIP from spawned threads
+
+```cpp
+TEST_CASE( "FAIL/SKIP in spawned thread kills the process" ) {
+    std::vector<std::jthread> threads;
+    for ( size_t t = 0; t < 16; ++t) {
+        threads.emplace_back( []() {
+            for (size_t i = 0; i < 10'000; ++i) {
+                FAIL();
+            }
+        } );
+    }
+}
+```
+As with failing `REQUIRE`, both `FAIL` and `SKIP` in spawned threads
+terminate the process.
+
+
 ## `STATIC_REQUIRE` and `STATIC_CHECK`

-None of `STATIC_REQUIRE`, `STATIC_REQUIRE_FALSE`, `STATIC_CHECK`, and
-`STATIC_CHECK_FALSE` are currently thread safe. This might be surprising
-given that they are a compile-time checks, but they also rely on the
-message macros to register the result with reporter at runtime.
+All of `STATIC_REQUIRE`, `STATIC_REQUIRE_FALSE`, `STATIC_CHECK`, and
+`STATIC_CHECK_FALSE` are thread safe in the delayed evaluation configuration.


 ## Fatal errors and multiple threads
--- a/docs/why-catch.md
+++ b/docs/why-catch.md
@@ -15,7 +15,7 @@ So what does Catch2 bring to the party that differentiates it from these? Apart
 ## Key Features

 * Quick and easy to get started. Just download two files, add them into your project and you're away.
-* No external dependencies. As long as you can compile C++14 and have the C++ standard library available.
+* No external dependencies. As long as you can compile C++17 and have the C++ standard library available.
 * Write test cases as, self-registering, functions (or methods, if you prefer).
 * Divide test cases into sections, each of which is run in isolation (eliminates the need for fixtures).
 * Use BDD-style Given-When-Then sections as well as traditional unit test cases.
--- a/examples/010-TestCase.cpp
+++ b/examples/010-TestCase.cpp
@@ -27,7 +27,7 @@ TEST_CASE( "Factorials of 1 and higher are computed (pass)", "[single-file]" ) {
 }

 // Compile & run:
-// - g++ -std=c++14 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 010-TestCase 010-TestCase.cpp && 010-TestCase --success
+// - g++ -std=c++17 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 010-TestCase 010-TestCase.cpp && 010-TestCase --success
 // - cl -EHsc -I%CATCH_SINGLE_INCLUDE% 010-TestCase.cpp && 010-TestCase --success

 // Expected compact output (all assertions):
--- a/examples/020-TestCase-1.cpp
+++ b/examples/020-TestCase-1.cpp
@@ -18,8 +18,8 @@ TEST_CASE( "1: All test cases reside in other .cpp files (empty)", "[multi-file:
 // Here just to show there are two source files via option --list-tests.

 // Compile & run:
-// - g++ -std=c++14 -Wall -I$(CATCH_SINGLE_INCLUDE) -c 020-TestCase-1.cpp
-// - g++ -std=c++14 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 020-TestCase TestCase-1.o 020-TestCase-2.cpp && 020-TestCase --success
+// - g++ -std=c++17 -Wall -I$(CATCH_SINGLE_INCLUDE) -c 020-TestCase-1.cpp
+// - g++ -std=c++17 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 020-TestCase TestCase-1.o 020-TestCase-2.cpp && 020-TestCase --success
 //
 // - cl -EHsc -I%CATCH_SINGLE_INCLUDE% -c 020-TestCase-1.cpp
 // - cl -EHsc -I%CATCH_SINGLE_INCLUDE% -Fe020-TestCase.exe 020-TestCase-1.obj 020-TestCase-2.cpp && 020-TestCase --success
--- a/examples/030-Asn-Require-Check.cpp
+++ b/examples/030-Asn-Require-Check.cpp
@@ -61,7 +61,7 @@ TEST_CASE( "Assert that something is false (continue after failure)", "[check-fa
 }

 // Compile & run:
-// - g++ -std=c++14 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 030-Asn-Require-Check 030-Asn-Require-Check.cpp && 030-Asn-Require-Check --success
+// - g++ -std=c++17 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 030-Asn-Require-Check 030-Asn-Require-Check.cpp && 030-Asn-Require-Check --success
 // - cl -EHsc -I%CATCH_SINGLE_INCLUDE% 030-Asn-Require-Check.cpp && 030-Asn-Require-Check --success

 // Expected compact output (all assertions):
--- a/examples/100-Fix-Section.cpp
+++ b/examples/100-Fix-Section.cpp
@@ -53,7 +53,7 @@ TEST_CASE( "vectors can be sized and resized", "[vector]" ) {
 }

 // Compile & run:
-// - g++ -std=c++14 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 100-Fix-Section 100-Fix-Section.cpp && 100-Fix-Section --success
+// - g++ -std=c++17 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 100-Fix-Section 100-Fix-Section.cpp && 100-Fix-Section --success
 // - cl -EHsc -I%CATCH_SINGLE_INCLUDE% 100-Fix-Section.cpp && 100-Fix-Section --success

 // Expected compact output (all assertions):
--- a/examples/110-Fix-ClassFixture.cpp
+++ b/examples/110-Fix-ClassFixture.cpp
@@ -60,11 +60,11 @@ TEST_CASE_METHOD( UniqueTestsFixture, "Create Employee/Normal", "[create]" ) {
 }

 // Compile & run:
-// - g++ -std=c++14 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 110-Fix-ClassFixture 110-Fix-ClassFixture.cpp && 110-Fix-ClassFixture --success
+// - g++ -std=c++17 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 110-Fix-ClassFixture 110-Fix-ClassFixture.cpp && 110-Fix-ClassFixture --success
 // - cl -EHsc -I%CATCH_SINGLE_INCLUDE% 110-Fix-ClassFixture.cpp && 110-Fix-ClassFixture --success
 //
 // Compile with pkg-config:
-// - g++ -std=c++14 -Wall $(pkg-config catch2-with-main --cflags)  -o 110-Fix-ClassFixture 110-Fix-ClassFixture.cpp $(pkg-config catch2-with-main --libs)
+// - g++ -std=c++17 -Wall $(pkg-config catch2-with-main --cflags)  -o 110-Fix-ClassFixture 110-Fix-ClassFixture.cpp $(pkg-config catch2-with-main --libs)

 // Expected compact output (all assertions):
 //
--- a/examples/120-Bdd-ScenarioGivenWhenThen.cpp
+++ b/examples/120-Bdd-ScenarioGivenWhenThen.cpp
@@ -56,7 +56,7 @@ SCENARIO( "vectors can be sized and resized", "[vector]" ) {
 }

 // Compile & run:
-// - g++ -std=c++14 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 120-Bdd-ScenarioGivenWhenThen 120-Bdd-ScenarioGivenWhenThen.cpp && 120-Bdd-ScenarioGivenWhenThen --success
+// - g++ -std=c++17 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 120-Bdd-ScenarioGivenWhenThen 120-Bdd-ScenarioGivenWhenThen.cpp && 120-Bdd-ScenarioGivenWhenThen --success
 // - cl -EHsc -I%CATCH_SINGLE_INCLUDE% 120-Bdd-ScenarioGivenWhenThen.cpp && 120-Bdd-ScenarioGivenWhenThen --success

 // Expected compact output (all assertions):
--- a/examples/210-Evt-EventListeners.cpp
+++ b/examples/210-Evt-EventListeners.cpp
@@ -131,7 +131,7 @@ void print( std::ostream& os, int const level, std::string const& title, Catch::
 }

 //    struct Tag {
-//        StringRef original, lowerCased;
+//        std::string_view original, lowerCased;
 //    };
 //
 //
@@ -221,9 +221,9 @@ void print( std::ostream& os, int const level, std::string const& title, Catch::

 // struct AssertionInfo
 // {
-//     StringRef macroName;
+//     std::string_view macroName;
 //     SourceLineInfo lineInfo;
-//     StringRef capturedExpression;
+//     std::string_view capturedExpression;
 //     ResultDisposition::Flags resultDisposition;
 // };

@@ -427,7 +427,7 @@ TEST_CASE_METHOD( Fixture, "3: Testcase with class-based fixture", "[tag-C][tag-
 }

 // Compile & run:
-// - g++ -std=c++14 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 210-Evt-EventListeners 210-Evt-EventListeners.cpp && 210-Evt-EventListeners --success
+// - g++ -std=c++17 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 210-Evt-EventListeners 210-Evt-EventListeners.cpp && 210-Evt-EventListeners --success
 // - cl -EHsc -I%CATCH_SINGLE_INCLUDE% 210-Evt-EventListeners.cpp && 210-Evt-EventListeners --success

 // Expected compact output (all assertions):
--- a/examples/302-Gen-Table.cpp
+++ b/examples/302-Gen-Table.cpp
@@ -22,24 +22,21 @@ struct TestSubject {


 TEST_CASE("Table allows pre-computed test inputs and outputs", "[example][generator]") {
-    using std::make_tuple;
    // do setup here as normal
    TestSubject subj;

    SECTION("This section is run for each row in the table") {
-        std::string test_input;
-        size_t expected_output;
-        std::tie( test_input, expected_output ) =
+        const auto [test_input, expected_output] =
            GENERATE( table<std::string, size_t>(
                { /* In this case one of the parameters to our test case is the
                   * expected output, but this is not required. There could be
                   * multiple expected values in the table, which can have any
                   * (fixed) number of columns.
                   */
-                  make_tuple( "one", 3 ),
-                  make_tuple( "two", 3 ),
-                  make_tuple( "three", 5 ),
-                  make_tuple( "four", 4 ) } ) );
+                  { "one", 3 },
+                  { "two", 3 },
+                  { "three", 5 },
+                  { "four", 4 } } ) );

        // run the test
        auto result = subj.GetLength(test_input);
@@ -50,14 +47,4 @@ TEST_CASE("Table allows pre-computed test inputs and outputs", "[example][genera
    }   // end section
 }

-/* Possible simplifications where less legacy toolchain support is needed:
- *
- * - With libstdc++6 or newer, the make_tuple() calls can be omitted
- * (technically C++17 but does not require -std in GCC/Clang). See
- *   https://stackoverflow.com/questions/12436586/tuple-vector-and-initializer-list
- *
- * - In C++17 mode std::tie() and the preceding variable declarations can be
- * replaced by structured bindings: auto [test_input, expected] = GENERATE(
- * table<std::string, size_t>({ ...
- */
 // Compiling and running this file will result in 4 successful assertions
--- a/extras/catch_amalgamated.cpp
+++ b/extras/catch_amalgamated.cpp
@@ -6,8 +6,8 @@

 // SPDX-License-Identifier: BSL-1.0

-//  Catch v3.9.1
-//  Generated: 2025-08-09 00:29:21.552225
+//  Catch v3.10.0
+//  Generated: 2025-08-24 16:18:04.775778
 //  ----------------------------------------------------------
 //  This file is an amalgamation of multiple different files.
 //  You probably shouldn't edit it directly.
@@ -1057,8 +1057,9 @@ namespace Catch {
    }
    Capturer::~Capturer() {
        assert( m_captured == m_messages.size() );
-        for ( size_t i = 0; i < m_captured; ++i )
+        for ( size_t i = 0; i < m_captured; ++i ) {
            m_resultCapture.popScopedMessage( m_messages[i] );
+        }
    }

    void Capturer::captureValue( size_t index, std::string const& value ) {
@@ -2278,7 +2279,7 @@ namespace Catch {
    }

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

@@ -3514,7 +3515,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 ) || defined( __GLIBC__ ) || defined(__FreeBSD__)
 #    define CATCH_INTERNAL_HAS_ISATTY
 #    include <unistd.h>
 #endif
@@ -4458,6 +4459,33 @@ namespace Detail {


 namespace Catch {
+
+    namespace {
+        static bool needsEscape( char c ) {
+            return c == '"' || c == '\\' || c == '\b' || c == '\f' ||
+                   c == '\n' || c == '\r' || c == '\t';
+        }
+
+        static Catch::StringRef makeEscapeStringRef( char c ) {
+            if ( c == '"' ) {
+                return "\\\""_sr;
+            } else if ( c == '\\' ) {
+                return "\\\\"_sr;
+            } else if ( c == '\b' ) {
+                return "\\b"_sr;
+            } else if ( c == '\f' ) {
+                return "\\f"_sr;
+            } else if ( c == '\n' ) {
+                return "\\n"_sr;
+            } else if ( c == '\r' ) {
+                return "\\r"_sr;
+            } else if ( c == '\t' ) {
+                return "\\t"_sr;
+            }
+            Catch::Detail::Unreachable();
+        }
+    } // namespace
+
    void JsonUtils::indent( std::ostream& os, std::uint64_t level ) {
        for ( std::uint64_t i = 0; i < level; ++i ) {
            os << "  ";
@@ -4567,30 +4595,19 @@ namespace Catch {

    void JsonValueWriter::writeImpl( Catch::StringRef value, bool quote ) {
        if ( quote ) { m_os << '"'; }
-        for (char c : value) {
-            // Escape list taken from https://www.json.org/json-en.html,
-            // string definition.
-            // Note that while forward slash _can_ be escaped, it does
-            // not have to be, if JSON is not further embedded somewhere
-            // where forward slash is meaningful.
-            if ( c == '"' ) {
-                m_os << "\\\"";
-            } else if ( c == '\\' ) {
-                m_os << "\\\\";
-            } else if ( c == '\b' ) {
-                m_os << "\\b";
-            } else if ( c == '\f' ) {
-                m_os << "\\f";
-            } else if ( c == '\n' ) {
-                m_os << "\\n";
-            } else if ( c == '\r' ) {
-                m_os << "\\r";
-            } else if ( c == '\t' ) {
-                m_os << "\\t";
-            } else {
-                m_os << c;
+        size_t current_start = 0;
+        for ( size_t i = 0; i < value.size(); ++i ) {
+            if ( needsEscape( value[i] ) ) {
+                if ( current_start < i ) {
+                    m_os << value.substr( current_start, i - current_start );
+                }
+                m_os << makeEscapeStringRef( value[i] );
+                current_start = i + 1;
            }
        }
+        if ( current_start < value.size() ) {
+            m_os << value.substr( current_start, value.size() - current_start );
+        }
        if ( quote ) { m_os << '"'; }
    }

@@ -4787,17 +4804,18 @@ int main (int argc, char * argv[]) {

 namespace Catch {

-    MessageInfo::MessageInfo(   StringRef _macroName,
-                                SourceLineInfo const& _lineInfo,
-                                ResultWas::OfType _type )
+    MessageInfo::MessageInfo( StringRef _macroName,
+                              SourceLineInfo const& _lineInfo,
+                              ResultWas::OfType _type )
    :   macroName( _macroName ),
        lineInfo( _lineInfo ),
        type( _type ),
        sequence( ++globalCount )
    {}

-    // This may need protecting if threading support is added
-    unsigned int MessageInfo::globalCount = 0;
+    // Messages are owned by their individual threads, so the counter should be thread-local as well.
+    // Alternative consideration: atomic, so threads don't share IDs and things are easier to debug.
+    thread_local unsigned int MessageInfo::globalCount = 0;

 } // end namespace Catch

@@ -5556,8 +5574,10 @@ namespace Catch {
        std::vector<Detail::unique_ptr<std::ostringstream>> m_streams;
        std::vector<std::size_t> m_unused;
        std::ostringstream m_referenceStream; // Used for copy state/ flags from
+        Detail::Mutex m_mutex;

        auto add() -> std::size_t {
+            Detail::LockGuard _( m_mutex );
            if( m_unused.empty() ) {
                m_streams.push_back( Detail::make_unique<std::ostringstream>() );
                return m_streams.size()-1;
@@ -5569,9 +5589,13 @@ namespace Catch {
            }
        }

-        void release( std::size_t index ) {
-            m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
-            m_unused.push_back(index);
+        void release( std::size_t index, std::ostream* originalPtr ) {
+            assert( originalPtr );
+            originalPtr->copyfmt( m_referenceStream );  // Restore initial flags and other state
+
+            Detail::LockGuard _( m_mutex );
+            assert( originalPtr == m_streams[index].get() && "Mismatch between release index and stream ptr" );
+            m_unused.push_back( index );
        }
    };

@@ -5583,7 +5607,7 @@ namespace Catch {
    ReusableStringStream::~ReusableStringStream() {
        static_cast<std::ostringstream*>( m_oss )->str("");
        m_oss->clear();
-        Singleton<StringStreams>::getMutable().release( m_index );
+        Singleton<StringStreams>::getMutable().release( m_index, m_oss );
    }

    std::string ReusableStringStream::str() const {
@@ -5750,9 +5774,6 @@ namespace Catch {
        // This also implies that messages are owned by their respective
        // threads, and should not be shared across different threads.
        //
-        // For simplicity, we disallow messages in multi-threaded contexts,
-        // but in the future we can enable them under this logic.
-        //
        // This implies that various pieces of metadata referring to last
        // assertion result/source location/message handling, etc
        // should also be thread local. For now we just use naked globals
@@ -5761,15 +5782,27 @@ namespace Catch {

        // This is used for the "if" part of CHECKED_IF/CHECKED_ELSE
        static thread_local bool g_lastAssertionPassed = false;
-        // Should we clear message scopes before sending off the messages to
-        // reporter? Set in `assertionPassedFastPath` to avoid doing the full
-        // clear there for performance reasons.
-        static thread_local bool g_clearMessageScopes = false;
+
        // This is the source location for last encountered macro. It is
        // used to provide the users with more precise location of error
        // when an unexpected exception/fatal error happens.
        static thread_local SourceLineInfo g_lastKnownLineInfo("DummyLocation", static_cast<size_t>(-1));
-    }
+
+        // Should we clear message scopes before sending off the messages to
+        // reporter? Set in `assertionPassedFastPath` to avoid doing the full
+        // clear there for performance reasons.
+        static thread_local bool g_clearMessageScopes = false;
+
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+        // Actual messages to be provided to the reporter
+        static thread_local std::vector<MessageInfo> g_messages;
+
+        // Owners for the UNSCOPED_X information macro
+        static thread_local std::vector<ScopedMessage> g_messageScopes;
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+    } // namespace Detail

    RunContext::RunContext(IConfig const* _config, IEventListenerPtr&& reporter)
    :   m_runInfo(_config->name()),
@@ -5905,20 +5938,21 @@ namespace Catch {
            Detail::g_lastAssertionPassed = true;
        }

+        if ( Detail::g_clearMessageScopes ) {
+            Detail::g_messageScopes.clear();
+            Detail::g_clearMessageScopes = false;
+        }
+
        // From here, we are touching shared state and need mutex.
        Detail::LockGuard lock( m_assertionMutex );
        {
-            if ( Detail::g_clearMessageScopes ) {
-                m_messageScopes.clear();
-                Detail::g_clearMessageScopes = false;
-            }
            auto _ = scopedDeactivate( *m_outputRedirect );
            updateTotalsFromAtomics();
-            m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) );
+            m_reporter->assertionEnded( AssertionStats( result, Detail::g_messages, m_totals ) );
        }

        if ( result.getResultType() != ResultWas::Warning ) {
-            m_messageScopes.clear();
+            Detail::g_messageScopes.clear();
        }

        // Reset working state. assertion info will be reset after
@@ -6051,8 +6085,8 @@ namespace Catch {
        m_reporter->benchmarkFailed( error );
    }

-    void RunContext::pushScopedMessage(MessageInfo const & message) {
-        m_messages.push_back(message);
+    void RunContext::pushScopedMessage( MessageInfo const& message ) {
+        Detail::g_messages.push_back( message );
    }

    void RunContext::popScopedMessage( MessageInfo const& message ) {
@@ -6061,16 +6095,16 @@ namespace Catch {
        //       messages than low single digits, so the optimization is tiny,
        //       and we would have to hand-write the loop to avoid terrible
        //       codegen of reverse iterators in debug mode.
-        m_messages.erase(
-            std::find_if( m_messages.begin(),
-                          m_messages.end(),
+        Detail::g_messages.erase(
+            std::find_if( Detail::g_messages.begin(),
+                          Detail::g_messages.end(),
                          [id = message.sequence]( MessageInfo const& msg ) {
                              return msg.sequence == id;
                          } ) );
    }

    void RunContext::emplaceUnscopedMessage( MessageBuilder&& builder ) {
-        m_messageScopes.emplace_back( CATCH_MOVE(builder) );
+        Detail::g_messageScopes.emplace_back( CATCH_MOVE(builder) );
    }

    std::string RunContext::getCurrentTestName() const {
@@ -6229,10 +6263,10 @@ namespace Catch {

        m_testCaseTracker->close();
        handleUnfinishedSections();
-        m_messageScopes.clear();
+        Detail::g_messageScopes.clear();
        // TBD: At this point, m_messages should be empty. Do we want to
        //      assert that this is true, or keep the defensive clear call?
-        m_messages.clear();
+        Detail::g_messages.clear();

        SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, duration, missingAssertions);
        m_reporter->sectionEnded(testCaseSectionStats);
@@ -7971,7 +8005,7 @@ namespace {

    void hexEscapeChar(std::ostream& os, unsigned char c) {
        std::ios_base::fmtflags f(os.flags());
-        os << "\\x"
+        os << "\\x"_sr
            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
            << static_cast<int>(c);
        os.flags(f);
@@ -7990,95 +8024,111 @@ namespace {
    void XmlEncode::encodeTo( std::ostream& os ) const {
        // Apostrophe escaping not necessary if we always use " to write attributes
        // (see: http://www.w3.org/TR/xml/#syntax)
+        size_t last_start = 0;
+        auto write_to = [&]( size_t idx ) {
+            if ( last_start < idx ) {
+                os << m_str.substr( last_start, idx - last_start );
+            }
+            last_start = idx + 1;
+        };

-        for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
-            unsigned char c = static_cast<unsigned char>(m_str[idx]);
-            switch (c) {
-            case '<':   os << "&lt;"; break;
-            case '&':   os << "&amp;"; break;
+        for ( std::size_t idx = 0; idx < m_str.size(); ++idx ) {
+            unsigned char c = static_cast<unsigned char>( m_str[idx] );
+            switch ( c ) {
+            case '<':
+                write_to( idx );
+                os << "&lt;"_sr;
+                break;
+            case '&':
+                write_to( idx );
+                os << "&amp;"_sr;
+                break;

            case '>':
                // See: http://www.w3.org/TR/xml/#syntax
-                if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
-                    os << "&gt;";
-                else
-                    os << c;
+                if ( idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']' ) {
+                    write_to( idx );
+                    os << "&gt;"_sr;
+                }
                break;

            case '\"':
-                if (m_forWhat == ForAttributes)
-                    os << "&quot;";
-                else
-                    os << c;
+                if ( m_forWhat == ForAttributes ) {
+                    write_to( idx );
+                    os << "&quot;"_sr;
+                }
                break;

            default:
                // Check for control characters and invalid utf-8

                // Escape control characters in standard ascii
-                // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
-                if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
-                    hexEscapeChar(os, c);
+                // see
+                // http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
+                if ( c < 0x09 || ( c > 0x0D && c < 0x20 ) || c == 0x7F ) {
+                    write_to( idx );
+                    hexEscapeChar( os, c );
                    break;
                }

                // Plain ASCII: Write it to stream
-                if (c < 0x7F) {
-                    os << c;
+                if ( c < 0x7F ) {
                    break;
                }

                // UTF-8 territory
-                // Check if the encoding is valid and if it is not, hex escape bytes.
-                // Important: We do not check the exact decoded values for validity, only the encoding format
-                // First check that this bytes is a valid lead byte:
-                // This means that it is not encoded as 1111 1XXX
+                // Check if the encoding is valid and if it is not, hex escape
+                // bytes. Important: We do not check the exact decoded values for
+                // validity, only the encoding format First check that this bytes is
+                // a valid lead byte: This means that it is not encoded as 1111 1XXX
                // Or as 10XX XXXX
-                if (c <  0xC0 ||
-                    c >= 0xF8) {
-                    hexEscapeChar(os, c);
+                if ( c < 0xC0 || c >= 0xF8 ) {
+                    write_to( idx );
+                    hexEscapeChar( os, c );
                    break;
                }

-                auto encBytes = trailingBytes(c);
-                // Are there enough bytes left to avoid accessing out-of-bounds memory?
-                if (idx + encBytes - 1 >= m_str.size()) {
-                    hexEscapeChar(os, c);
+                auto encBytes = trailingBytes( c );
+                // Are there enough bytes left to avoid accessing out-of-bounds
+                // memory?
+                if ( idx + encBytes - 1 >= m_str.size() ) {
+                    write_to( idx );
+                    hexEscapeChar( os, c );
                    break;
                }
                // The header is valid, check data
                // The next encBytes bytes must together be a valid utf-8
-                // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
+                // This means: bitpattern 10XX XXXX and the extracted value is sane
+                // (ish)
                bool valid = true;
-                uint32_t value = headerValue(c);
-                for (std::size_t n = 1; n < encBytes; ++n) {
-                    unsigned char nc = static_cast<unsigned char>(m_str[idx + n]);
-                    valid &= ((nc & 0xC0) == 0x80);
-                    value = (value << 6) | (nc & 0x3F);
+                uint32_t value = headerValue( c );
+                for ( std::size_t n = 1; n < encBytes; ++n ) {
+                    unsigned char nc = static_cast<unsigned char>( m_str[idx + n] );
+                    valid &= ( ( nc & 0xC0 ) == 0x80 );
+                    value = ( value << 6 ) | ( nc & 0x3F );
                }

                if (
                    // Wrong bit pattern of following bytes
-                    (!valid) ||
+                    ( !valid ) ||
                    // Overlong encodings
-                    (value < 0x80) ||
-                    (0x80 <= value && value < 0x800   && encBytes > 2) ||
-                    (0x800 < value && value < 0x10000 && encBytes > 3) ||
+                    ( value < 0x80 ) ||
+                    ( 0x80 <= value && value < 0x800 && encBytes > 2 ) ||
+                    ( 0x800 < value && value < 0x10000 && encBytes > 3 ) ||
                    // Encoded value out of range
-                    (value >= 0x110000)
-                    ) {
-                    hexEscapeChar(os, c);
+                    ( value >= 0x110000 ) ) {
+                    write_to( idx );
+                    hexEscapeChar( os, c );
                    break;
                }

                // If we got here, this is in fact a valid(ish) utf-8 sequence
-                for (std::size_t n = 0; n < encBytes; ++n) {
-                    os << m_str[idx + n];
-                }
                idx += encBytes - 1;
                break;
            }
        }
+
+        write_to( m_str.size() );
    }

    std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
--- a/extras/catch_amalgamated.hpp
+++ b/extras/catch_amalgamated.hpp
@@ -6,8 +6,8 @@

 // SPDX-License-Identifier: BSL-1.0

-//  Catch v3.9.1
-//  Generated: 2025-08-09 00:29:20.303175
+//  Catch v3.10.0
+//  Generated: 2025-08-24 16:18:04.055916
 //  ----------------------------------------------------------
 //  This file is an amalgamation of multiple different files.
 //  You probably shouldn't edit it directly.
@@ -3972,7 +3972,7 @@ namespace Catch {
            return sequence < other.sequence;
        }
    private:
-        static unsigned int globalCount;
+        static thread_local unsigned int globalCount;
    };

 } // end namespace Catch
@@ -7466,8 +7466,8 @@ namespace Catch {
 #define CATCH_VERSION_MACROS_HPP_INCLUDED

 #define CATCH_VERSION_MAJOR 3
-#define CATCH_VERSION_MINOR 9
-#define CATCH_VERSION_PATCH 1
+#define CATCH_VERSION_MINOR 10
+#define CATCH_VERSION_PATCH 0

 #endif // CATCH_VERSION_MACROS_HPP_INCLUDED

@@ -10773,9 +10773,6 @@ namespace Catch {
        Totals m_totals;
        Detail::AtomicCounts m_atomicAssertionCount;
        IEventListenerPtr m_reporter;
-        std::vector<MessageInfo> m_messages;
-        // Owners for the UNSCOPED_X information macro
-        std::vector<ScopedMessage> m_messageScopes;
        std::vector<SectionEndInfo> m_unfinishedSections;
        std::vector<ITracker*> m_activeSections;
        TrackerContext m_trackerContext;
--- a/meson.build
+++ b/meson.build
@@ -8,7 +8,7 @@
 project(
  'catch2',
  'cpp',
-  version: '3.9.1', # CML version placeholder, don't delete
+  version: '3.10.0', # CML version placeholder, don't delete
  license: 'BSL-1.0',
  meson_version: '>=0.54.1',
 )
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -76,11 +76,9 @@ set(IMPL_HEADERS
  ${SOURCES_DIR}/internal/catch_config_counter.hpp
  ${SOURCES_DIR}/internal/catch_config_prefix_messages.hpp
  ${SOURCES_DIR}/internal/catch_config_static_analysis_support.hpp
-  ${SOURCES_DIR}/internal/catch_config_uncaught_exceptions.hpp
  ${SOURCES_DIR}/internal/catch_config_wchar.hpp
  ${SOURCES_DIR}/internal/catch_console_colour.hpp
  ${SOURCES_DIR}/internal/catch_console_width.hpp
-  ${SOURCES_DIR}/internal/catch_container_nonmembers.hpp
  ${SOURCES_DIR}/internal/catch_context.hpp
  ${SOURCES_DIR}/internal/catch_debug_console.hpp
  ${SOURCES_DIR}/internal/catch_debugger.hpp
@@ -99,12 +97,10 @@ set(IMPL_HEADERS
  ${SOURCES_DIR}/internal/catch_lazy_expr.hpp
  ${SOURCES_DIR}/internal/catch_leak_detector.hpp
  ${SOURCES_DIR}/internal/catch_list.hpp
-  ${SOURCES_DIR}/internal/catch_logical_traits.hpp
  ${SOURCES_DIR}/internal/catch_message_info.hpp
  ${SOURCES_DIR}/internal/catch_meta.hpp
  ${SOURCES_DIR}/internal/catch_move_and_forward.hpp
  ${SOURCES_DIR}/internal/catch_noncopyable.hpp
-  ${SOURCES_DIR}/internal/catch_optional.hpp
  ${SOURCES_DIR}/internal/catch_output_redirect.hpp
  ${SOURCES_DIR}/internal/catch_parse_numbers.hpp
  ${SOURCES_DIR}/internal/catch_platform.hpp
@@ -128,7 +124,6 @@ set(IMPL_HEADERS
  ${SOURCES_DIR}/internal/catch_stdstreams.hpp
  ${SOURCES_DIR}/internal/catch_stream_end_stop.hpp
  ${SOURCES_DIR}/internal/catch_string_manip.hpp
-  ${SOURCES_DIR}/internal/catch_stringref.hpp
  ${SOURCES_DIR}/internal/catch_tag_alias_registry.hpp
  ${SOURCES_DIR}/internal/catch_template_test_registry.hpp
  ${SOURCES_DIR}/internal/catch_test_case_info_hasher.hpp
@@ -205,7 +200,6 @@ set(IMPL_SOURCES
  ${SOURCES_DIR}/internal/catch_startup_exception_registry.cpp
  ${SOURCES_DIR}/internal/catch_stdstreams.cpp
  ${SOURCES_DIR}/internal/catch_string_manip.cpp
-  ${SOURCES_DIR}/internal/catch_stringref.cpp
  ${SOURCES_DIR}/internal/catch_tag_alias_registry.cpp
  ${SOURCES_DIR}/internal/catch_test_case_info_hasher.cpp
  ${SOURCES_DIR}/internal/catch_test_case_registry_impl.cpp
@@ -365,8 +359,8 @@ set_target_properties(Catch2 PROPERTIES
  SOVERSION ${PROJECT_VERSION}
 )

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

 configure_file(
  "${SOURCES_DIR}/catch_user_config.hpp.in"
@@ -450,7 +444,7 @@ if(CATCH_BUILD_EXAMPLES OR CATCH_BUILD_EXTRA_TESTS)
      $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
  )
  target_compile_definitions(Catch2_buildall_interface INTERFACE CATCH_CONFIG_STATIC)
-  target_compile_features(Catch2_buildall_interface INTERFACE cxx_std_14)
+  target_compile_features(Catch2_buildall_interface INTERFACE cxx_std_17)
 endif()

 list(APPEND CATCH_IMPL_TARGETS Catch2 Catch2WithMain)
--- a/src/catch2/benchmark/catch_optimizer.hpp
+++ b/src/catch2/benchmark/catch_optimizer.hpp
@@ -64,12 +64,12 @@ namespace Catch {
        }

        template <typename Fn, typename... Args>
-        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t<!std::is_same<void, decltype(fn(args...))>::value> {
+        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t<!std::is_same_v<void, decltype(fn(args...))>> {
            deoptimize_value(CATCH_FORWARD(fn) (CATCH_FORWARD(args)...));
        }

        template <typename Fn, typename... Args>
-        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t<std::is_same<void, decltype(fn(args...))>::value> {
+        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t<std::is_same_v<void, decltype(fn(args...))>> {
            CATCH_FORWARD((fn)) (CATCH_FORWARD(args)...);
        }
    } // namespace Benchmark
--- a/src/catch2/benchmark/detail/catch_analyse.cpp
+++ b/src/catch2/benchmark/detail/catch_analyse.cpp
@@ -46,7 +46,7 @@ namespace Catch {
                    std::vector<FDuration> samples2;
                    samples2.reserve(samples.size());
                    for (auto s : samples) {
-                        samples2.push_back( FDuration( s ) );
+                        samples2.emplace_back( s );
                    }

                    return {
--- a/src/catch2/benchmark/detail/catch_benchmark_function.hpp
+++ b/src/catch2/benchmark/detail/catch_benchmark_function.hpp
@@ -21,7 +21,7 @@ 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;
+            static constexpr bool is_related_v = std::is_same_v<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
--- a/src/catch2/catch_all.hpp
+++ b/src/catch2/catch_all.hpp
@@ -57,11 +57,9 @@
 #include <catch2/internal/catch_config_counter.hpp>
 #include <catch2/internal/catch_config_prefix_messages.hpp>
 #include <catch2/internal/catch_config_static_analysis_support.hpp>
-#include <catch2/internal/catch_config_uncaught_exceptions.hpp>
 #include <catch2/internal/catch_config_wchar.hpp>
 #include <catch2/internal/catch_console_colour.hpp>
 #include <catch2/internal/catch_console_width.hpp>
-#include <catch2/internal/catch_container_nonmembers.hpp>
 #include <catch2/internal/catch_context.hpp>
 #include <catch2/internal/catch_debug_console.hpp>
 #include <catch2/internal/catch_debugger.hpp>
@@ -80,12 +78,10 @@
 #include <catch2/internal/catch_lazy_expr.hpp>
 #include <catch2/internal/catch_leak_detector.hpp>
 #include <catch2/internal/catch_list.hpp>
-#include <catch2/internal/catch_logical_traits.hpp>
 #include <catch2/internal/catch_message_info.hpp>
 #include <catch2/internal/catch_meta.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>
 #include <catch2/internal/catch_noncopyable.hpp>
-#include <catch2/internal/catch_optional.hpp>
 #include <catch2/internal/catch_output_redirect.hpp>
 #include <catch2/internal/catch_parse_numbers.hpp>
 #include <catch2/internal/catch_platform.hpp>
@@ -110,7 +106,6 @@
 #include <catch2/internal/catch_stdstreams.hpp>
 #include <catch2/internal/catch_stream_end_stop.hpp>
 #include <catch2/internal/catch_string_manip.hpp>
-#include <catch2/internal/catch_stringref.hpp>
 #include <catch2/internal/catch_tag_alias_registry.hpp>
 #include <catch2/internal/catch_template_test_registry.hpp>
 #include <catch2/internal/catch_test_case_info_hasher.hpp>
--- a/src/catch2/catch_approx.hpp
+++ b/src/catch2/catch_approx.hpp
@@ -29,7 +29,7 @@ namespace Catch {

        Approx operator-() const;

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

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


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

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

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

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

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

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

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

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

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

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

-        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+        template <typename T, typename = std::enable_if_t<std::is_constructible_v<double, T>>>
        Approx& scale( T const& newScale ) {
            m_scale = static_cast<double>(newScale);
            return *this;
--- a/src/catch2/catch_assertion_info.hpp
+++ b/src/catch2/catch_assertion_info.hpp
@@ -10,16 +10,17 @@

 #include <catch2/internal/catch_result_type.hpp>
 #include <catch2/internal/catch_source_line_info.hpp>
-#include <catch2/internal/catch_stringref.hpp>
+
+#include <string_view>

 namespace Catch {

    struct AssertionInfo {
        // AssertionInfo() = delete;

-        StringRef macroName;
+        std::string_view macroName;
        SourceLineInfo lineInfo;
-        StringRef capturedExpression;
+        std::string_view capturedExpression;
        ResultDisposition::Flags resultDisposition;
    };

--- a/src/catch2/catch_assertion_result.cpp
+++ b/src/catch2/catch_assertion_result.cpp
@@ -91,14 +91,14 @@ namespace Catch {
                : expr;
    }

-    StringRef AssertionResult::getMessage() const {
+    std::string_view AssertionResult::getMessage() const {
        return m_resultData.message;
    }
    SourceLineInfo AssertionResult::getSourceInfo() const {
        return m_info.lineInfo;
    }

-    StringRef AssertionResult::getTestMacroName() const {
+    std::string_view AssertionResult::getTestMacroName() const {
        return m_info.macroName;
    }

--- a/src/catch2/catch_assertion_result.hpp
+++ b/src/catch2/catch_assertion_result.hpp
@@ -11,7 +11,6 @@
 #include <catch2/catch_assertion_info.hpp>
 #include <catch2/internal/catch_result_type.hpp>
 #include <catch2/internal/catch_source_line_info.hpp>
-#include <catch2/internal/catch_stringref.hpp>
 #include <catch2/internal/catch_lazy_expr.hpp>

 #include <string>
@@ -46,9 +45,9 @@ namespace Catch {
        std::string getExpressionInMacro() const;
        bool hasExpandedExpression() const;
        std::string getExpandedExpression() const;
-        StringRef getMessage() const;
+        std::string_view getMessage() const;
        SourceLineInfo getSourceInfo() const;
-        StringRef getTestMacroName() const;
+        std::string_view getTestMacroName() const;

    //protected:
        AssertionInfo m_info;
--- a/src/catch2/catch_config.cpp
+++ b/src/catch2/catch_config.cpp
@@ -10,13 +10,13 @@
 #include <catch2/internal/catch_enforce.hpp>
 #include <catch2/internal/catch_parse_numbers.hpp>
 #include <catch2/internal/catch_stdstreams.hpp>
-#include <catch2/internal/catch_stringref.hpp>
 #include <catch2/internal/catch_string_manip.hpp>
 #include <catch2/internal/catch_test_spec_parser.hpp>
 #include <catch2/interfaces/catch_interfaces_tag_alias_registry.hpp>
 #include <catch2/internal/catch_getenv.hpp>

 #include <fstream>
+#include <optional>

 namespace Catch {

@@ -34,7 +34,7 @@ namespace Catch {
            std::string shardFilePath;
        };

-        static Optional<bazelShardingOptions> readBazelShardingOptions() {
+        static std::optional<bazelShardingOptions> readBazelShardingOptions() {
            const auto bazelShardIndex = Detail::getEnv( "TEST_SHARD_INDEX" );
            const auto bazelShardTotal = Detail::getEnv( "TEST_TOTAL_SHARDS" );
            const auto bazelShardInfoFile = Detail::getEnv( "TEST_SHARD_STATUS_FILE" );
@@ -142,7 +142,7 @@ namespace Catch {
            // We do the default-output check separately, while always
            // using the default output below to make the code simpler
            // and avoid superfluous copies.
-            if ( reporterSpec.outputFile().none() ) {
+            if ( !reporterSpec.outputFile() ) {
                CATCH_ENFORCE( !defaultOutputUsed,
                               "Internal error: cannot use default output for "
                               "multiple reporters" );
@@ -153,7 +153,7 @@ namespace Catch {
                reporterSpec.name(),
                reporterSpec.outputFile() ? *reporterSpec.outputFile()
                                          : data.defaultOutputFilename,
-                reporterSpec.colourMode().valueOr( data.defaultColourMode ),
+                reporterSpec.colourMode().value_or( data.defaultColourMode ),
                reporterSpec.customOptions() } );
        }
    }
@@ -185,7 +185,7 @@ namespace Catch {

    // IConfig interface
    bool Config::allowThrows() const                   { return !m_data.noThrow; }
-    StringRef Config::name() const { return m_data.name.empty() ? m_data.processName : m_data.name; }
+    std::string_view Config::name() const { return m_data.name.empty() ? m_data.processName : m_data.name; }
    bool Config::includeSuccessfulResults() const      { return m_data.showSuccessfulTests; }
    bool Config::warnAboutMissingAssertions() const {
        return !!( m_data.warnings & WarnAbout::NoAssertions );
--- a/src/catch2/catch_config.hpp
+++ b/src/catch2/catch_config.hpp
@@ -11,8 +11,6 @@
 #include <catch2/catch_test_spec.hpp>
 #include <catch2/interfaces/catch_interfaces_config.hpp>
 #include <catch2/internal/catch_unique_ptr.hpp>
-#include <catch2/internal/catch_optional.hpp>
-#include <catch2/internal/catch_stringref.hpp>
 #include <catch2/internal/catch_random_seed_generation.hpp>
 #include <catch2/internal/catch_reporter_spec_parser.hpp>

@@ -116,7 +114,7 @@ namespace Catch {

        // IConfig interface
        bool allowThrows() const override;
-        StringRef name() const override;
+        std::string_view name() const override;
        bool includeSuccessfulResults() const override;
        bool warnAboutMissingAssertions() const override;
        bool warnAboutUnmatchedTestSpecs() const override;
--- a/src/catch2/catch_message.cpp
+++ b/src/catch2/catch_message.cpp
@@ -19,27 +19,26 @@ namespace Catch {


    ScopedMessage::ScopedMessage( MessageBuilder&& builder ):
-        m_info( CATCH_MOVE(builder.m_info) ) {
-        m_info.message = builder.m_stream.str();
-        getResultCapture().pushScopedMessage( m_info );
+        m_messageId( builder.m_info.sequence ) {
+        MessageInfo info( CATCH_MOVE( builder.m_info ) );
+        info.message = builder.m_stream.str();
+        getResultCapture().pushScopedMessage( CATCH_MOVE(info) );
    }

    ScopedMessage::ScopedMessage( ScopedMessage&& old ) noexcept:
-        m_info( CATCH_MOVE( old.m_info ) ) {
+        m_messageId( old.m_messageId ) {
        old.m_moved = true;
    }

    ScopedMessage::~ScopedMessage() {
-        if ( !m_moved ){
-            getResultCapture().popScopedMessage(m_info);
-        }
+        if ( !m_moved ) { getResultCapture().popScopedMessage( m_messageId ); }
    }


-    Capturer::Capturer( StringRef macroName,
+    Capturer::Capturer( std::string_view macroName,
                        SourceLineInfo const& lineInfo,
                        ResultWas::OfType resultType,
-                        StringRef names ):
+                        std::string_view names ):
        m_resultCapture( getResultCapture() ) {
        auto trimmed = [&] (size_t start, size_t end) {
            while (names[start] == ',' || isspace(static_cast<unsigned char>(names[start]))) {
@@ -86,7 +85,7 @@ namespace Catch {
            case ',':
                if (start != pos && openings.empty()) {
                    m_messages.emplace_back(macroName, lineInfo, resultType);
-                    m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
+                    m_messages.back().message += trimmed(start, pos);
                    m_messages.back().message += " := ";
                    start = pos;
                }
@@ -96,19 +95,20 @@ namespace Catch {
        }
        assert(openings.empty() && "Mismatched openings");
        m_messages.emplace_back(macroName, lineInfo, resultType);
-        m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
+        m_messages.back().message += trimmed(start, names.size() - 1);
        m_messages.back().message += " := ";
    }
    Capturer::~Capturer() {
        assert( m_captured == m_messages.size() );
-        for ( size_t i = 0; i < m_captured; ++i )
-            m_resultCapture.popScopedMessage( m_messages[i] );
+        for (auto const& message : m_messages) {
+            m_resultCapture.popScopedMessage( message.sequence );
+        }
    }

    void Capturer::captureValue( size_t index, std::string const& value ) {
        assert( index < m_messages.size() );
        m_messages[index].message += value;
-        m_resultCapture.pushScopedMessage( m_messages[index] );
+        m_resultCapture.pushScopedMessage( CATCH_MOVE(m_messages[index]) );
        m_captured++;
    }

--- a/src/catch2/catch_message.hpp
+++ b/src/catch2/catch_message.hpp
@@ -36,7 +36,7 @@ namespace Catch {
    };

    struct MessageBuilder : MessageStream {
-        MessageBuilder( StringRef macroName,
+        MessageBuilder( std::string_view macroName,
                        SourceLineInfo const& lineInfo,
                        ResultWas::OfType type ):
            m_info(macroName, lineInfo, type) {}
@@ -57,7 +57,7 @@ namespace Catch {
        ScopedMessage( ScopedMessage&& old ) noexcept;
        ~ScopedMessage();

-        MessageInfo m_info;
+        unsigned int m_messageId;
        bool m_moved = false;
    };

@@ -66,7 +66,7 @@ namespace Catch {
        IResultCapture& m_resultCapture;
        size_t m_captured = 0;
    public:
-        Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
+        Capturer( std::string_view macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, std::string_view names );

        Capturer(Capturer const&) = delete;
        Capturer& operator=(Capturer const&) = delete;
@@ -92,26 +92,26 @@ namespace Catch {
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
    do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
+        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, std::string_view(), resultDisposition ); \
        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
        catchAssertionHandler.complete(); \
    } while( false )

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

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

 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
-    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
+    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )


 #if defined(CATCH_CONFIG_PREFIX_MESSAGES) && !defined(CATCH_CONFIG_DISABLE)
--- a/src/catch2/catch_section_info.hpp
+++ b/src/catch2/catch_section_info.hpp
@@ -10,7 +10,6 @@

 #include <catch2/internal/catch_move_and_forward.hpp>
 #include <catch2/internal/catch_source_line_info.hpp>
-#include <catch2/internal/catch_stringref.hpp>
 #include <catch2/catch_totals.hpp>

 #include <string>
--- a/src/catch2/catch_session.hpp
+++ b/src/catch2/catch_session.hpp
@@ -16,7 +16,6 @@

 namespace Catch {

-    // TODO: Use C++17 `inline` variables
    constexpr int UnspecifiedErrorExitCode = 1;
    constexpr int NoTestsRunExitCode = 2;
    constexpr int UnmatchedTestSpecExitCode = 3;
--- a/src/catch2/catch_test_case_info.cpp
+++ b/src/catch2/catch_test_case_info.cpp
@@ -14,6 +14,7 @@
 #include <cassert>
 #include <cctype>
 #include <algorithm>
+#include <string_view>

 namespace Catch {

@@ -47,28 +48,28 @@ namespace Catch {
            return tcp != TestCaseProperties::None;
        }

-        TestCaseProperties parseSpecialTag( StringRef tag ) {
+        TestCaseProperties parseSpecialTag( std::string_view tag ) {
            if( !tag.empty() && tag[0] == '.' )
                return TestCaseProperties::IsHidden;
-            else if( tag == "!throws"_sr )
+            else if( tag == "!throws" )
                return TestCaseProperties::Throws;
-            else if( tag == "!shouldfail"_sr )
+            else if( tag == "!shouldfail" )
                return TestCaseProperties::ShouldFail;
-            else if( tag == "!mayfail"_sr )
+            else if( tag == "!mayfail" )
                return TestCaseProperties::MayFail;
-            else if( tag == "!nonportable"_sr )
+            else if( tag == "!nonportable" )
                return TestCaseProperties::NonPortable;
-            else if( tag == "!benchmark"_sr )
+            else if( tag == "!benchmark" )
                return TestCaseProperties::Benchmark | TestCaseProperties::IsHidden;
            else
                return TestCaseProperties::None;
        }
-        bool isReservedTag( StringRef tag ) {
+        bool isReservedTag( std::string_view tag ) {
            return parseSpecialTag( tag ) == TestCaseProperties::None
                && tag.size() > 0
                && !std::isalnum( static_cast<unsigned char>(tag[0]) );
        }
-        void enforceNotReservedTag( StringRef tag, SourceLineInfo const& _lineInfo ) {
+        void enforceNotReservedTag( std::string_view tag, SourceLineInfo const& _lineInfo ) {
            CATCH_ENFORCE( !isReservedTag(tag),
                          "Tag name: [" << tag << "] is not allowed.\n"
                          << "Tag names starting with non alphanumeric characters are reserved\n"
@@ -80,13 +81,13 @@ namespace Catch {
            return "Anonymous test case " + std::to_string(++counter);
        }

-        constexpr StringRef extractFilenamePart(StringRef filename) {
+        constexpr std::string_view extractFilenamePart(std::string_view filename) {
            size_t lastDot = filename.size();
            while (lastDot > 0 && filename[lastDot - 1] != '.') {
                --lastDot;
            }
            // In theory we could have filename without any extension in it
-            if ( lastDot == 0 ) { return StringRef(); }
+            if ( lastDot == 0 ) { return std::string_view(); }

            --lastDot;
            size_t nameStart = lastDot;
@@ -98,7 +99,7 @@ namespace Catch {
        }

        // Returns the upper bound on size of extra tags ([#file]+[.])
-        constexpr size_t sizeOfExtraTags(StringRef filepath) {
+        constexpr size_t sizeOfExtraTags(std::string_view filepath) {
            // [.] is 3, [#] is another 3
            const size_t extras = 3 + 3;
            return extractFilenamePart(filepath).size() + extras;
@@ -115,20 +116,20 @@ namespace Catch {
    }

    Detail::unique_ptr<TestCaseInfo>
-        makeTestCaseInfo(StringRef _className,
+        makeTestCaseInfo(std::string_view _className,
                         NameAndTags const& nameAndTags,
                         SourceLineInfo const& _lineInfo ) {
        return Detail::make_unique<TestCaseInfo>(_className, nameAndTags, _lineInfo);
    }

-    TestCaseInfo::TestCaseInfo(StringRef _className,
+    TestCaseInfo::TestCaseInfo(std::string_view _className,
                               NameAndTags const& _nameAndTags,
                               SourceLineInfo const& _lineInfo):
        name( _nameAndTags.name.empty() ? makeDefaultName() : _nameAndTags.name ),
        className( _className ),
        lineInfo( _lineInfo )
    {
-        StringRef originalTags = _nameAndTags.tags;
+        std::string_view originalTags = _nameAndTags.tags;
        // We need to reserve enough space to store all of the tags
        // (including optional hidden tag and filename tag)
        auto requiredSize = originalTags.size() + sizeOfExtraTags(_lineInfo.file);
@@ -163,7 +164,7 @@ namespace Catch {
                // We need to check the tag for special meanings, copy
                // it over to backing storage and actually reference the
                // backing storage in the saved tags
-                StringRef tagStr = originalTags.substr(tagStart+1, tagEnd - tagStart - 1);
+                std::string_view tagStr = originalTags.substr(tagStart+1, tagEnd - tagStart - 1);
                CATCH_ENFORCE( !tagStr.empty(),
                               "Found an empty tag while registering test case '"
                                   << _nameAndTags.name << "' at "
@@ -190,7 +191,7 @@ namespace Catch {

        // Add [.] if relevant
        if (isHidden()) {
-            internalAppendTag("."_sr);
+            internalAppendTag(".");
        }

        // Sort and prepare tags
@@ -235,13 +236,13 @@ namespace Catch {
        return ret;
    }

-    void TestCaseInfo::internalAppendTag(StringRef tagStr) {
+    void TestCaseInfo::internalAppendTag(std::string_view tagStr) {
        backingTags += '[';
        const auto backingStart = backingTags.size();
        backingTags += tagStr;
        const auto backingEnd = backingTags.size();
        backingTags += ']';
-        tags.emplace_back(StringRef(backingTags.c_str() + backingStart, backingEnd - backingStart));
+        tags.emplace_back(std::string_view(backingTags.c_str() + backingStart, backingEnd - backingStart));
    }

    bool operator<( TestCaseInfo const& lhs, TestCaseInfo const& rhs ) {
--- a/src/catch2/catch_test_case_info.hpp
+++ b/src/catch2/catch_test_case_info.hpp
@@ -11,12 +11,12 @@
 #include <catch2/interfaces/catch_interfaces_test_invoker.hpp>
 #include <catch2/internal/catch_source_line_info.hpp>
 #include <catch2/internal/catch_noncopyable.hpp>
-#include <catch2/internal/catch_stringref.hpp>
 #include <catch2/internal/catch_unique_ptr.hpp>


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

 #ifdef __clang__
@@ -34,10 +34,10 @@ namespace Catch {
     * as "cool-tag" internally.
     */
    struct Tag {
-        constexpr Tag(StringRef original_):
+        constexpr Tag(std::string_view original_):
            original(original_)
        {}
-        StringRef original;
+        std::string_view original;

        friend bool operator< ( Tag const& lhs, Tag const& rhs );
        friend bool operator==( Tag const& lhs, Tag const& rhs );
@@ -67,7 +67,7 @@ namespace Catch {
     */
    struct TestCaseInfo : Detail::NonCopyable {

-        TestCaseInfo(StringRef _className,
+        TestCaseInfo(std::string_view _className,
                     NameAndTags const& _nameAndTags,
                     SourceLineInfo const& _lineInfo);

@@ -87,12 +87,12 @@ namespace Catch {
        std::string tagsAsString() const;

        std::string name;
-        StringRef className;
+        std::string_view className;
    private:
        std::string backingTags;
        // Internally we copy tags to the backing storage and then add
        // refs to this storage to the tags vector.
-        void internalAppendTag(StringRef tagString);
+        void internalAppendTag(std::string_view tagString);
    public:
        std::vector<Tag> tags;
        SourceLineInfo lineInfo;
@@ -130,7 +130,7 @@ namespace Catch {
    };

    Detail::unique_ptr<TestCaseInfo>
-    makeTestCaseInfo( StringRef className,
+    makeTestCaseInfo( std::string_view className,
                      NameAndTags const& nameAndTags,
                      SourceLineInfo const& lineInfo );
 }
--- a/src/catch2/catch_test_run_info.hpp
+++ b/src/catch2/catch_test_run_info.hpp
@@ -8,13 +8,13 @@
 #ifndef CATCH_TEST_RUN_INFO_HPP_INCLUDED
 #define CATCH_TEST_RUN_INFO_HPP_INCLUDED

-#include <catch2/internal/catch_stringref.hpp>
+#include <string_view>

 namespace Catch {

    struct TestRunInfo {
-        constexpr TestRunInfo(StringRef _name) : name(_name) {}
-        StringRef name;
+        constexpr TestRunInfo(std::string_view _name) : name(_name) {}
+        std::string_view name;
    };

 } // end namespace Catch
--- a/src/catch2/catch_tostring.cpp
+++ b/src/catch2/catch_tostring.cpp
@@ -13,6 +13,7 @@
 #include <catch2/internal/catch_polyfills.hpp>

 #include <iomanip>
+#include <cstddef>

 namespace Catch {

@@ -57,7 +58,7 @@ namespace Detail {
        }
    } // end unnamed namespace

-    std::string convertIntoString(StringRef string, bool escapeInvisibles) {
+    std::string convertIntoString(std::string_view string, bool escapeInvisibles) {
        std::string ret;
        // This is enough for the "don't escape invisibles" case, and a good
        // lower bound on the "escape invisibles" case.
@@ -95,7 +96,7 @@ namespace Detail {
        return ret;
    }

-    std::string convertIntoString(StringRef string) {
+    std::string convertIntoString(std::string_view string) {
        return convertIntoString(string, getCurrentContext().getConfig()->showInvisibles());
    }

@@ -135,11 +136,9 @@ std::string StringMaker<std::string>::convert(const std::string& str) {
    return Detail::convertIntoString( str );
 }

-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
 std::string StringMaker<std::string_view>::convert(std::string_view str) {
-    return Detail::convertIntoString( StringRef( str.data(), str.size() ) );
+    return Detail::convertIntoString( std::string_view( str.data(), str.size() ) );
 }
-#endif

 std::string StringMaker<char const*>::convert(char const* str) {
    if (str) {
@@ -166,11 +165,9 @@ std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
    return ::Catch::Detail::stringify(s);
 }

-# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
 std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
    return StringMaker<std::wstring>::convert(std::wstring(str));
 }
-# endif

 std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
    if (str) {
@@ -188,12 +185,9 @@ std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
 }
 #endif

-#if defined(CATCH_CONFIG_CPP17_BYTE)
-#include <cstddef>
 std::string StringMaker<std::byte>::convert(std::byte value) {
    return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
 }
-#endif // defined(CATCH_CONFIG_CPP17_BYTE)

 std::string StringMaker<int>::convert(int value) {
    return ::Catch::Detail::stringify(static_cast<long long>(value));
--- a/src/catch2/catch_tostring.hpp
+++ b/src/catch2/catch_tostring.hpp
@@ -20,9 +20,7 @@
 #include <catch2/internal/catch_void_type.hpp>
 #include <catch2/interfaces/catch_interfaces_enum_values_registry.hpp>

-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
 #include <string_view>
-#endif

 #ifdef _MSC_VER
 #pragma warning(push)
@@ -48,14 +46,14 @@ namespace Catch {
            return n;
        }

-        constexpr StringRef unprintableString = "{?}"_sr;
+        constexpr std::string_view unprintableString = "{?}";

        //! Encases `string in quotes, and optionally escapes invisibles
-        std::string convertIntoString( StringRef string, bool escapeInvisibles );
+        std::string convertIntoString( std::string_view string, bool escapeInvisibles );

        //! Encases `string` in quotes, and escapes invisibles if user requested
        //! it via CLI
-        std::string convertIntoString( StringRef string );
+        std::string convertIntoString( std::string_view string );

        std::string rawMemoryToString( const void *object, std::size_t size );

@@ -78,13 +76,13 @@ namespace Catch {

        template<typename T>
        std::enable_if_t<
-            !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
+            !std::is_enum_v<T> && !std::is_base_of_v<std::exception, T>,
        std::string> convertUnstreamable( T const& ) {
            return std::string(Detail::unprintableString);
        }
        template<typename T>
        std::enable_if_t<
-            !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
+            !std::is_enum_v<T> && std::is_base_of_v<std::exception, T>,
         std::string> convertUnstreamable(T const& ex) {
            return ex.what();
        }
@@ -92,7 +90,7 @@ namespace Catch {

        template<typename T>
        std::enable_if_t<
-            std::is_enum<T>::value,
+            std::is_enum_v<T>,
        std::string> convertUnstreamable( T const& value ) {
            return convertUnknownEnumToString( value );
        }
@@ -173,12 +171,10 @@ namespace Catch {
        static std::string convert(const std::string& str);
    };

-#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
    template<>
    struct StringMaker<std::string_view> {
        static std::string convert(std::string_view str);
    };
-#endif

    template<>
    struct StringMaker<char const *> {
@@ -195,12 +191,10 @@ namespace Catch {
        static std::string convert(const std::wstring& wstr);
    };

-# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
    template<>
    struct StringMaker<std::wstring_view> {
        static std::string convert(std::wstring_view str);
    };
-# endif

    template<>
    struct StringMaker<wchar_t const *> {
@@ -216,7 +210,7 @@ namespace Catch {
    struct StringMaker<char[SZ]> {
        static std::string convert(char const* str) {
            return Detail::convertIntoString(
-                StringRef( str, Detail::catch_strnlen( str, SZ ) ) );
+                std::string_view( str, Detail::catch_strnlen( str, SZ ) ) );
        }
    };
    template<size_t SZ>
@@ -224,7 +218,7 @@ namespace Catch {
        static std::string convert(signed char const* str) {
            auto reinterpreted = reinterpret_cast<char const*>(str);
            return Detail::convertIntoString(
-                StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
+                std::string_view(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
        }
    };
    template<size_t SZ>
@@ -232,16 +226,14 @@ namespace Catch {
        static std::string convert(unsigned char const* str) {
            auto reinterpreted = reinterpret_cast<char const*>(str);
            return Detail::convertIntoString(
-                StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
+                std::string_view(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
        }
    };

-#if defined(CATCH_CONFIG_CPP17_BYTE)
    template<>
    struct StringMaker<std::byte> {
        static std::string convert(std::byte value);
    };
-#endif // defined(CATCH_CONFIG_CPP17_BYTE)
    template<>
    struct StringMaker<int> {
        static std::string convert(int value);
@@ -387,7 +379,7 @@ namespace Catch {
 }
 #endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER

-#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER)
 #include <optional>
 namespace Catch {
    template<typename T>
@@ -417,7 +409,7 @@ namespace Catch {
        template<
            typename Tuple,
            std::size_t N = 0,
-            bool = (N < std::tuple_size<Tuple>::value)
+            bool = (N < std::tuple_size_v<Tuple>)
            >
            struct TupleElementPrinter {
            static void print(const Tuple& tuple, std::ostream& os) {
@@ -451,7 +443,7 @@ namespace Catch {
 }
 #endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER

-#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
+#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER)
 #include <variant>
 namespace Catch {
    template<>
--- a/src/catch2/catch_user_config.hpp.in
+++ b/src/catch2/catch_user_config.hpp.in
@@ -60,56 +60,6 @@



-#cmakedefine CATCH_CONFIG_CPP17_BYTE
-#cmakedefine CATCH_CONFIG_NO_CPP17_BYTE
-
-#if defined( CATCH_CONFIG_CPP17_BYTE ) && \
-    defined( CATCH_CONFIG_NO_CPP17_BYTE )
-#    error Cannot force CPP17_BYTE to both ON and OFF
-#endif
-
-
-
-#cmakedefine CATCH_CONFIG_CPP17_OPTIONAL
-#cmakedefine CATCH_CONFIG_NO_CPP17_OPTIONAL
-
-#if defined( CATCH_CONFIG_CPP17_OPTIONAL ) && \
-    defined( CATCH_CONFIG_NO_CPP17_OPTIONAL )
-#    error Cannot force CPP17_OPTIONAL to both ON and OFF
-#endif
-
-
-
-#cmakedefine CATCH_CONFIG_CPP17_STRING_VIEW
-#cmakedefine CATCH_CONFIG_NO_CPP17_STRING_VIEW
-
-#if defined( CATCH_CONFIG_CPP17_STRING_VIEW ) && \
-    defined( CATCH_CONFIG_NO_CPP17_STRING_VIEW )
-#    error Cannot force CPP17_STRING_VIEW to both ON and OFF
-#endif
-
-
-
-#cmakedefine CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#cmakedefine CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS
-
-#if defined( CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS ) && \
-    defined( CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS )
-#    error Cannot force CPP17_UNCAUGHT_EXCEPTIONS to both ON and OFF
-#endif
-
-
-
-#cmakedefine CATCH_CONFIG_CPP17_VARIANT
-#cmakedefine CATCH_CONFIG_NO_CPP17_VARIANT
-
-#if defined( CATCH_CONFIG_CPP17_VARIANT ) && \
-    defined( CATCH_CONFIG_NO_CPP17_VARIANT )
-#    error Cannot force CPP17_VARIANT to both ON and OFF
-#endif
-
-
-
 #cmakedefine CATCH_CONFIG_GLOBAL_NEXTAFTER
 #cmakedefine CATCH_CONFIG_NO_GLOBAL_NEXTAFTER

--- a/src/catch2/catch_version.cpp
+++ b/src/catch2/catch_version.cpp
@@ -36,7 +36,7 @@ namespace Catch {
    }

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

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

 #define CATCH_VERSION_MAJOR 3
-#define CATCH_VERSION_MINOR 9
-#define CATCH_VERSION_PATCH 1
+#define CATCH_VERSION_MINOR 10
+#define CATCH_VERSION_PATCH 0

 #endif // CATCH_VERSION_MACROS_HPP_INCLUDED
--- a/src/catch2/generators/catch_generators.cpp
+++ b/src/catch2/generators/catch_generators.cpp
@@ -27,11 +27,11 @@ namespace Detail {

    GeneratorUntypedBase::~GeneratorUntypedBase() = default;

-    IGeneratorTracker* acquireGeneratorTracker(StringRef generatorName, SourceLineInfo const& lineInfo ) {
+    IGeneratorTracker* acquireGeneratorTracker(std::string_view generatorName, SourceLineInfo const& lineInfo ) {
        return getResultCapture().acquireGeneratorTracker( generatorName, lineInfo );
    }

-    IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
+    IGeneratorTracker* createGeneratorTracker( std::string_view generatorName,
                                 SourceLineInfo lineInfo,
                                 GeneratorBasePtr&& generator ) {
        return getResultCapture().createGeneratorTracker(
--- a/src/catch2/generators/catch_generators.hpp
+++ b/src/catch2/generators/catch_generators.hpp
@@ -11,7 +11,6 @@
 #include <catch2/catch_tostring.hpp>
 #include <catch2/interfaces/catch_interfaces_generatortracker.hpp>
 #include <catch2/internal/catch_source_line_info.hpp>
-#include <catch2/internal/catch_stringref.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>
 #include <catch2/internal/catch_unique_name.hpp>

@@ -88,7 +87,7 @@ namespace Detail {

    template<typename T>
    class FixedValuesGenerator final : public IGenerator<T> {
-        static_assert(!std::is_same<T, bool>::value,
+        static_assert(!std::is_same_v<T, bool>,
            "FixedValuesGenerator does not support bools because of std::vector<bool>"
            "specialization, use SingleValue Generator instead.");
        std::vector<T> m_values;
@@ -131,7 +130,7 @@ namespace Detail {
            m_generators.emplace_back( value( CATCH_MOVE( val ) ) );
        }
        template <typename U>
-        std::enable_if_t<!std::is_same<std::decay_t<U>, T>::value>
+        std::enable_if_t<!std::is_same_v<std::decay_t<U>, T>>
        add_generator( U&& val ) {
            add_generator( T( CATCH_FORWARD( val ) ) );
        }
@@ -197,14 +196,14 @@ namespace Detail {
        return makeGenerators( value( T( CATCH_FORWARD( val ) ) ), CATCH_FORWARD( moreGenerators )... );
    }

-    IGeneratorTracker* acquireGeneratorTracker( StringRef generatorName,
+    IGeneratorTracker* acquireGeneratorTracker( std::string_view generatorName,
                                                SourceLineInfo const& lineInfo );
-    IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
+    IGeneratorTracker* createGeneratorTracker( std::string_view generatorName,
                                               SourceLineInfo lineInfo,
                                               GeneratorBasePtr&& generator );

    template<typename L>
-    auto generate( StringRef generatorName, SourceLineInfo const& lineInfo, L const& generatorExpression ) -> typename decltype(generatorExpression())::type {
+    auto generate( std::string_view generatorName, SourceLineInfo const& lineInfo, L const& generatorExpression ) -> typename decltype(generatorExpression())::type {
        using UnderlyingType = typename decltype(generatorExpression())::type;

        IGeneratorTracker* tracker = acquireGeneratorTracker( generatorName, lineInfo );
@@ -225,7 +224,7 @@ namespace Detail {
 } // namespace Generators
 } // namespace Catch

-#define CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL( ... ) #__VA_ARGS__##_catch_sr
+#define CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL( ... ) #__VA_ARGS__
 #define CATCH_INTERNAL_GENERATOR_STRINGIZE(...) CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL(__VA_ARGS__)

 #define GENERATE( ... ) \
--- a/src/catch2/generators/catch_generators_adapters.hpp
+++ b/src/catch2/generators/catch_generators_adapters.hpp
@@ -58,8 +58,9 @@ namespace Generators {
    class FilterGenerator final : public IGenerator<T> {
        GeneratorWrapper<T> m_generator;
        Predicate m_predicate;
+        static_assert(!std::is_reference_v<Predicate>, "This would most likely result in a dangling reference");
    public:
-        template <typename P = Predicate>
+        template <typename P>
        FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
            m_generator(CATCH_MOVE(generator)),
            m_predicate(CATCH_FORWARD(pred))
@@ -91,12 +92,12 @@ namespace Generators {

    template <typename T, typename Predicate>
    GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(Catch::Detail::make_unique<FilterGenerator<T, Predicate>>(CATCH_FORWARD(pred), CATCH_MOVE(generator)));
+        return GeneratorWrapper<T>(Catch::Detail::make_unique<FilterGenerator<T, typename std::remove_reference<Predicate>::type>>(CATCH_FORWARD(pred), CATCH_MOVE(generator)));
    }

    template <typename T>
    class RepeatGenerator final : public IGenerator<T> {
-        static_assert(!std::is_same<T, bool>::value,
+        static_assert(!std::is_same_v<T, bool>,
            "RepeatGenerator currently does not support bools"
            "because of std::vector<bool> specialization");
        GeneratorWrapper<T> m_generator;
--- a/src/catch2/generators/catch_generators_random.hpp
+++ b/src/catch2/generators/catch_generators_random.hpp
@@ -83,7 +83,7 @@ public:
 };

 template <typename T>
-std::enable_if_t<std::is_integral<T>::value, GeneratorWrapper<T>>
+std::enable_if_t<std::is_integral_v<T>, GeneratorWrapper<T>>
 random(T a, T b) {
    return GeneratorWrapper<T>(
        Catch::Detail::make_unique<RandomIntegerGenerator<T>>(a, b, Detail::getSeed())
@@ -91,7 +91,7 @@ random(T a, T b) {
 }

 template <typename T>
-std::enable_if_t<std::is_floating_point<T>::value,
+std::enable_if_t<std::is_floating_point_v<T>,
 GeneratorWrapper<T>>
 random(T a, T b) {
    return GeneratorWrapper<T>(
--- a/src/catch2/generators/catch_generators_range.hpp
+++ b/src/catch2/generators/catch_generators_range.hpp
@@ -52,20 +52,20 @@ public:

 template <typename T>
 GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
-    static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
+    static_assert(std::is_arithmetic_v<T> && !std::is_same_v<T, bool>, "Type must be numeric");
    return GeneratorWrapper<T>(Catch::Detail::make_unique<RangeGenerator<T>>(start, end, step));
 }

 template <typename T>
 GeneratorWrapper<T> range(T const& start, T const& end) {
-    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
+    static_assert(std::is_integral_v<T> && !std::is_same_v<T, bool>, "Type must be an integer");
    return GeneratorWrapper<T>(Catch::Detail::make_unique<RangeGenerator<T>>(start, end));
 }


 template <typename T>
 class IteratorGenerator final : public IGenerator<T> {
-    static_assert(!std::is_same<T, bool>::value,
+    static_assert(!std::is_same_v<T, bool>,
        "IteratorGenerator currently does not support bools"
        "because of std::vector<bool> specialization");

--- a/src/catch2/interfaces/catch_interfaces_capture.hpp
+++ b/src/catch2/interfaces/catch_interfaces_capture.hpp
@@ -10,7 +10,6 @@

 #include <string>

-#include <catch2/internal/catch_stringref.hpp>
 #include <catch2/internal/catch_result_type.hpp>
 #include <catch2/internal/catch_unique_ptr.hpp>
 #include <catch2/benchmark/detail/catch_benchmark_stats_fwd.hpp>
@@ -43,31 +42,31 @@ namespace Catch {
        virtual ~IResultCapture();

        virtual void notifyAssertionStarted( AssertionInfo const& info ) = 0;
-        virtual bool sectionStarted( StringRef sectionName,
+        virtual bool sectionStarted( std::string_view sectionName,
                                     SourceLineInfo const& sectionLineInfo,
                                     Counts& assertions ) = 0;
        virtual void sectionEnded( SectionEndInfo&& endInfo ) = 0;
        virtual void sectionEndedEarly( SectionEndInfo&& endInfo ) = 0;

        virtual IGeneratorTracker*
-        acquireGeneratorTracker( StringRef generatorName,
+        acquireGeneratorTracker( std::string_view generatorName,
                                 SourceLineInfo const& lineInfo ) = 0;
        virtual IGeneratorTracker*
-        createGeneratorTracker( StringRef generatorName,
+        createGeneratorTracker( std::string_view generatorName,
                                SourceLineInfo lineInfo,
                                Generators::GeneratorBasePtr&& generator ) = 0;

-        virtual void benchmarkPreparing( StringRef name ) = 0;
+        virtual void benchmarkPreparing( std::string_view name ) = 0;
        virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
        virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
-        virtual void benchmarkFailed( StringRef error ) = 0;
+        virtual void benchmarkFailed( std::string_view error ) = 0;

-        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
-        virtual void popScopedMessage( MessageInfo const& message ) = 0;
+        virtual void pushScopedMessage( MessageInfo&& message ) = 0;
+        virtual void popScopedMessage( unsigned int messageId ) = 0;

        virtual void emplaceUnscopedMessage( MessageBuilder&& builder ) = 0;

-        virtual void handleFatalErrorCondition( StringRef message ) = 0;
+        virtual void handleFatalErrorCondition( std::string_view message ) = 0;

        virtual void handleExpr
                (   AssertionInfo const& info,
--- a/src/catch2/interfaces/catch_interfaces_config.hpp
+++ b/src/catch2/interfaces/catch_interfaces_config.hpp
@@ -9,7 +9,6 @@
 #define CATCH_INTERFACES_CONFIG_HPP_INCLUDED

 #include <catch2/internal/catch_noncopyable.hpp>
-#include <catch2/internal/catch_stringref.hpp>

 #include <chrono>
 #include <string>
@@ -66,7 +65,7 @@ namespace Catch {
        virtual ~IConfig();

        virtual bool allowThrows() const = 0;
-        virtual StringRef name() const = 0;
+        virtual std::string_view name() const = 0;
        virtual bool includeSuccessfulResults() const = 0;
        virtual bool shouldDebugBreak() const = 0;
        virtual bool warnAboutMissingAssertions() const = 0;
--- a/src/catch2/interfaces/catch_interfaces_enum_values_registry.hpp
+++ b/src/catch2/interfaces/catch_interfaces_enum_values_registry.hpp
@@ -8,20 +8,19 @@
 #ifndef CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
 #define CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED

-#include <catch2/internal/catch_stringref.hpp>
-
+#include <string_view>
 #include <vector>

 namespace Catch {

    namespace Detail {
        struct EnumInfo {
-            StringRef m_name;
-            std::vector<std::pair<int, StringRef>> m_values;
+            std::string_view m_name;
+            std::vector<std::pair<int, std::string_view>> m_values;

            ~EnumInfo();

-            StringRef lookup( int value ) const;
+            std::string_view lookup( int value ) const;
        };
    } // namespace Detail

@@ -29,10 +28,10 @@ namespace Catch {
    public:
        virtual ~IMutableEnumValuesRegistry(); // = default;

-        virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
+        virtual Detail::EnumInfo const& registerEnum( std::string_view enumName, std::string_view allEnums, std::vector<int> const& values ) = 0;

        template<typename E>
-        Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
+        Detail::EnumInfo const& registerEnum( std::string_view enumName, std::string_view allEnums, std::initializer_list<E> values ) {
            static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
            std::vector<int> intValues;
            intValues.reserve( values.size() );
--- a/src/catch2/interfaces/catch_interfaces_generatortracker.cpp
+++ b/src/catch2/interfaces/catch_interfaces_generatortracker.cpp
@@ -21,7 +21,7 @@ namespace Catch {
            return ret;
        }

-        StringRef GeneratorUntypedBase::currentElementAsString() const {
+        std::string_view GeneratorUntypedBase::currentElementAsString() const {
            if ( m_stringReprCache.empty() ) {
                m_stringReprCache = stringifyImpl();
            }
--- a/src/catch2/interfaces/catch_interfaces_generatortracker.hpp
+++ b/src/catch2/interfaces/catch_interfaces_generatortracker.hpp
@@ -9,7 +9,6 @@
 #define CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED

 #include <catch2/internal/catch_unique_ptr.hpp>
-#include <catch2/internal/catch_stringref.hpp>

 #include <string>

@@ -71,7 +70,7 @@ namespace Catch {
             * is destructed, or it moves onto the next element, whichever
             * comes first.
             */
-            StringRef currentElementAsString() const;
+            std::string_view currentElementAsString() const;
        };
        using GeneratorBasePtr = Catch::Detail::unique_ptr<GeneratorUntypedBase>;

--- a/src/catch2/interfaces/catch_interfaces_reporter.hpp
+++ b/src/catch2/interfaces/catch_interfaces_reporter.hpp
@@ -13,7 +13,6 @@
 #include <catch2/catch_totals.hpp>
 #include <catch2/catch_assertion_result.hpp>
 #include <catch2/internal/catch_message_info.hpp>
-#include <catch2/internal/catch_stringref.hpp>
 #include <catch2/internal/catch_unique_ptr.hpp>
 #include <catch2/benchmark/detail/catch_benchmark_stats.hpp>

@@ -154,9 +153,9 @@ namespace Catch {
        }

        //! Called when no test cases match provided test spec
-        virtual void noMatchingTestCases( StringRef unmatchedSpec ) = 0;
+        virtual void noMatchingTestCases( std::string_view unmatchedSpec ) = 0;
        //! Called for all invalid test specs from the cli
-        virtual void reportInvalidTestSpec( StringRef invalidArgument ) = 0;
+        virtual void reportInvalidTestSpec( std::string_view invalidArgument ) = 0;

        /**
         * Called once in a testing run before tests are started
@@ -173,13 +172,13 @@ namespace Catch {
        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;

        //! Called when user-code is being probed before the actual benchmark runs
-        virtual void benchmarkPreparing( StringRef benchmarkName ) = 0;
+        virtual void benchmarkPreparing( std::string_view benchmarkName ) = 0;
        //! Called after probe but before the user-code is being benchmarked
        virtual void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) = 0;
        //! Called with the benchmark results if benchmark successfully finishes
        virtual void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) = 0;
        //! Called if running the benchmarks fails for any reason
-        virtual void benchmarkFailed( StringRef benchmarkName ) = 0;
+        virtual void benchmarkFailed( std::string_view benchmarkName ) = 0;

        //! Called before assertion success/failure is evaluated
        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
@@ -209,7 +208,7 @@ namespace Catch {
        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;

        //! Called if a fatal error (signal/structured exception) occurred
-        virtual void fatalErrorEncountered( StringRef error ) = 0;
+        virtual void fatalErrorEncountered( std::string_view error ) = 0;

        //! Writes out information about provided reporters using reporter-specific format
        virtual void listReporters(std::vector<ReporterDescription> const& descriptions) = 0;
--- a/src/catch2/interfaces/catch_interfaces_reporter_factory.hpp
+++ b/src/catch2/interfaces/catch_interfaces_reporter_factory.hpp
@@ -9,7 +9,6 @@
 #define CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED

 #include <catch2/internal/catch_unique_ptr.hpp>
-#include <catch2/internal/catch_stringref.hpp>

 #include <string>

@@ -36,7 +35,7 @@ namespace Catch {
        virtual ~EventListenerFactory(); // = default
        virtual IEventListenerPtr create( IConfig const* config ) const = 0;
        //! Return a meaningful name for the listener, e.g. its type name
-        virtual StringRef getName() const = 0;
+        virtual std::string_view getName() const = 0;
        //! Return listener's description if available
        virtual std::string getDescription() const = 0;
    };
--- a/src/catch2/internal/catch_assertion_handler.cpp
+++ b/src/catch2/internal/catch_assertion_handler.cpp
@@ -15,9 +15,9 @@
 namespace Catch {

    AssertionHandler::AssertionHandler
-        (   StringRef macroName,
+        (   std::string_view macroName,
            SourceLineInfo const& lineInfo,
-            StringRef capturedExpression,
+            std::string_view capturedExpression,
            ResultDisposition::Flags resultDisposition )
    :   m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
        m_resultCapture( getResultCapture() )
--- a/src/catch2/internal/catch_assertion_handler.hpp
+++ b/src/catch2/internal/catch_assertion_handler.hpp
@@ -30,9 +30,9 @@ namespace Catch {

    public:
        AssertionHandler
-            (   StringRef macroName,
+            (   std::string_view macroName,
                SourceLineInfo const& lineInfo,
-                StringRef capturedExpression,
+                std::string_view capturedExpression,
                ResultDisposition::Flags resultDisposition );
        ~AssertionHandler() {
            if ( !m_completed ) {
--- a/src/catch2/internal/catch_case_insensitive_comparisons.cpp
+++ b/src/catch2/internal/catch_case_insensitive_comparisons.cpp
@@ -14,8 +14,8 @@
 namespace Catch {
    namespace Detail {

-        bool CaseInsensitiveLess::operator()( StringRef lhs,
-                                              StringRef rhs ) const {
+        bool CaseInsensitiveLess::operator()( std::string_view lhs,
+                                              std::string_view rhs ) const {
            return std::lexicographical_compare(
                lhs.begin(), lhs.end(),
                rhs.begin(), rhs.end(),
@@ -23,8 +23,8 @@ namespace Catch {
        }

        bool
-        CaseInsensitiveEqualTo::operator()( StringRef lhs,
-                                            StringRef rhs ) const {
+        CaseInsensitiveEqualTo::operator()( std::string_view lhs,
+                                            std::string_view rhs ) const {
            return std::equal(
                lhs.begin(), lhs.end(),
                rhs.begin(), rhs.end(),
--- a/src/catch2/internal/catch_case_insensitive_comparisons.hpp
+++ b/src/catch2/internal/catch_case_insensitive_comparisons.hpp
@@ -8,20 +8,20 @@
 #ifndef CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
 #define CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED

-#include <catch2/internal/catch_stringref.hpp>
+#include <string_view>

 namespace Catch {
    namespace Detail {
        //! Provides case-insensitive `op<` semantics when called
        struct CaseInsensitiveLess {
-            bool operator()( StringRef lhs,
-                             StringRef rhs ) const;
+            bool operator()( std::string_view lhs,
+                             std::string_view rhs ) const;
        };

        //! Provides case-insensitive `op==` semantics when called
        struct CaseInsensitiveEqualTo {
-            bool operator()( StringRef lhs,
-                             StringRef rhs ) const;
+            bool operator()( std::string_view lhs,
+                             std::string_view rhs ) const;
        };

    } // namespace Detail
--- a/src/catch2/internal/catch_clara.cpp
+++ b/src/catch2/internal/catch_clara.cpp
@@ -25,7 +25,7 @@ namespace {
            ;
    }

-    Catch::StringRef normaliseOpt( Catch::StringRef optName ) {
+    std::string_view normaliseOpt( std::string_view optName ) {
        if ( optName[0] == '-'
 #if defined(CATCH_PLATFORM_WINDOWS)
             || optName[0] == '/'
@@ -37,7 +37,7 @@ namespace {
        return optName;
    }

-    static size_t find_first_separator(Catch::StringRef sr) {
+    static size_t find_first_separator(std::string_view sr) {
        auto is_separator = []( char c ) {
            return c == ' ' || c == ':' || c == '=';
        };
@@ -47,7 +47,7 @@ namespace {
            ++pos;
        }

-        return Catch::StringRef::npos;
+        return std::string_view::npos;
    }

 } // namespace
@@ -65,10 +65,10 @@ namespace Catch {
                }

                if ( it != itEnd ) {
-                    StringRef next = *it;
+                    std::string_view next = *it;
                    if ( isOptPrefix( next[0] ) ) {
                        auto delimiterPos = find_first_separator(next);
-                        if ( delimiterPos != StringRef::npos ) {
+                        if ( delimiterPos != std::string_view::npos ) {
                            m_tokenBuffer.push_back(
                                { TokenType::Option,
                                  next.substr( 0, delimiterPos ) } );
@@ -205,7 +205,7 @@ namespace Catch {
            return { oss.str(), m_description };
        }

-        bool Opt::isMatch(StringRef optToken) const {
+        bool Opt::isMatch(std::string_view optToken) const {
            auto normalisedToken = normaliseOpt(optToken);
            for (auto const& name : m_optNames) {
                if (normaliseOpt(name) == normalisedToken)
@@ -243,12 +243,12 @@ namespace Catch {
                        if (!tokens)
                            return Detail::InternalParseResult::runtimeError(
                                "Expected argument following " +
-                                token.token);
+                                std::string(token.token));
                        auto const& argToken = *tokens;
                        if (argToken.type != Detail::TokenType::Argument)
                            return Detail::InternalParseResult::runtimeError(
                                "Expected argument following " +
-                                token.token);
+                                std::string(token.token));
                        const auto result = valueRef->setValue(static_cast<std::string>(argToken.token));
                        if (!result)
                            return Detail::InternalParseResult(result);
@@ -436,7 +436,7 @@ namespace Catch {
                if ( !tokenParsed )
                    return Detail::InternalParseResult::runtimeError(
                        "Unrecognised token: " +
-                        result.value().remainingTokens()->token );
+                        std::string(result.value().remainingTokens()->token) );
            }
            // !TBD Check missing required options
            return result;
@@ -445,7 +445,7 @@ namespace Catch {
        Args::Args(int argc, char const* const* argv) :
            m_exeName(argv[0]), m_args(argv + 1, argv + argc) {}

-        Args::Args(std::initializer_list<StringRef> args) :
+        Args::Args(std::initializer_list<std::string_view> args) :
            m_exeName(*args.begin()),
            m_args(args.begin() + 1, args.end()) {}

--- a/src/catch2/internal/catch_clara.hpp
+++ b/src/catch2/internal/catch_clara.hpp
@@ -20,16 +20,8 @@
 #    pragma GCC diagnostic ignored "-Wsign-conversion"
 #endif

-#ifndef CLARA_CONFIG_OPTIONAL_TYPE
-#    ifdef __has_include
-#        if __has_include( <optional>) && __cplusplus >= 201703L
-#            include <optional>
-#            define CLARA_CONFIG_OPTIONAL_TYPE std::optional
-#        endif
-#    endif
-#endif
+#include <optional>

-#include <catch2/internal/catch_stringref.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>
 #include <catch2/internal/catch_noncopyable.hpp>
 #include <catch2/internal/catch_void_type.hpp>
@@ -100,13 +92,13 @@ namespace Catch {
            enum class TokenType { Option, Argument };
            struct Token {
                TokenType type;
-                StringRef token;
+                std::string_view token;
            };

            // Abstracts iterators into args as a stream of tokens, with option
            // arguments uniformly handled
            class TokenStream {
-                using Iterator = std::vector<StringRef>::const_iterator;
+                using Iterator = std::vector<std::string_view>::const_iterator;
                Iterator it;
                Iterator itEnd;
                std::vector<Token> m_tokenBuffer;
@@ -309,7 +301,7 @@ namespace Catch {

            struct HelpColumns {
                std::string left;
-                StringRef descriptions;
+                std::string_view descriptions;
            };

            template <typename T>
@@ -328,10 +320,9 @@ namespace Catch {
                                      std::string& target );
            ParserResult convertInto( std::string const& source, bool& target );

-#ifdef CLARA_CONFIG_OPTIONAL_TYPE
            template <typename T>
            auto convertInto( std::string const& source,
-                              CLARA_CONFIG_OPTIONAL_TYPE<T>& target )
+                              std::optional<T>& target )
                -> ParserResult {
                T temp;
                auto result = convertInto( source, temp );
@@ -339,7 +330,6 @@ namespace Catch {
                    target = CATCH_MOVE( temp );
                return result;
            }
-#endif // CLARA_CONFIG_OPTIONAL_TYPE

            struct BoundRef : Catch::Detail::NonCopyable {
                virtual ~BoundRef() = default;
@@ -393,7 +383,7 @@ namespace Catch {

            template <typename ReturnType> struct LambdaInvoker {
                static_assert(
-                    std::is_same<ReturnType, ParserResult>::value,
+                    std::is_same_v<ReturnType, ParserResult>,
                    "Lambda must return void or clara::ParserResult" );

                template <typename L, typename ArgType>
@@ -449,8 +439,8 @@ namespace Catch {
                    UnaryLambdaTraits<L>::isValid,
                    "Supplied lambda must take exactly one argument" );
                static_assert(
-                    std::is_same<typename UnaryLambdaTraits<L>::ArgType,
-                                 bool>::value,
+                    std::is_same_v<typename UnaryLambdaTraits<L>::ArgType,
+                                   bool>,
                    "flags must be boolean" );

                explicit BoundFlagLambda( L const& lambda ):
@@ -489,8 +479,8 @@ namespace Catch {
            protected:
                Optionality m_optionality = Optionality::Optional;
                std::shared_ptr<BoundRef> m_ref;
-                StringRef m_hint;
-                StringRef m_description;
+                std::string_view m_hint;
+                std::string_view m_description;

                explicit ParserRefImpl( std::shared_ptr<BoundRef> const& ref ):
                    m_ref( ref ) {}
@@ -499,29 +489,29 @@ namespace Catch {
                template <typename LambdaT>
                ParserRefImpl( accept_many_t,
                               LambdaT const& ref,
-                               StringRef hint ):
+                               std::string_view hint ):
                    m_ref( std::make_shared<BoundManyLambda<LambdaT>>( ref ) ),
                    m_hint( hint ) {}

                template <typename T,
                          typename = typename std::enable_if_t<
                              !Detail::is_unary_function_v<T>>>
-                ParserRefImpl( T& ref, StringRef hint ):
+                ParserRefImpl( T& ref, std::string_view hint ):
                    m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
                    m_hint( hint ) {}

                template <typename LambdaT,
                          typename = typename std::enable_if_t<
                              Detail::is_unary_function_v<LambdaT>>>
-                ParserRefImpl( LambdaT const& ref, StringRef hint ):
+                ParserRefImpl( LambdaT const& ref, std::string_view hint ):
                    m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
                    m_hint( hint ) {}

-                DerivedT& operator()( StringRef description ) & {
+                DerivedT& operator()( std::string_view description ) & {
                    m_description = description;
                    return static_cast<DerivedT&>( *this );
                }
-                DerivedT&& operator()( StringRef description ) && {
+                DerivedT&& operator()( std::string_view description ) && {
                    m_description = description;
                    return static_cast<DerivedT&&>( *this );
                }
@@ -547,7 +537,7 @@ namespace Catch {
                        return 1;
                }

-                StringRef hint() const { return m_hint; }
+                std::string_view hint() const { return m_hint; }
            };

        } // namespace detail
@@ -567,7 +557,7 @@ namespace Catch {
        // A parser for options
        class Opt : public Detail::ParserRefImpl<Opt> {
        protected:
-            std::vector<StringRef> m_optNames;
+            std::vector<std::string_view> m_optNames;

        public:
            template <typename LambdaT>
@@ -580,31 +570,31 @@ namespace Catch {
            template <typename LambdaT,
                      typename = typename std::enable_if_t<
                          Detail::is_unary_function_v<LambdaT>>>
-            Opt( LambdaT const& ref, StringRef hint ):
+            Opt( LambdaT const& ref, std::string_view hint ):
                ParserRefImpl( ref, hint ) {}

            template <typename LambdaT>
-            Opt( accept_many_t, LambdaT const& ref, StringRef hint ):
+            Opt( accept_many_t, LambdaT const& ref, std::string_view hint ):
                ParserRefImpl( accept_many, ref, hint ) {}

            template <typename T,
                      typename = typename std::enable_if_t<
                          !Detail::is_unary_function_v<T>>>
-            Opt( T& ref, StringRef hint ):
+            Opt( T& ref, std::string_view hint ):
                ParserRefImpl( ref, hint ) {}

-            Opt& operator[]( StringRef optName ) & {
+            Opt& operator[]( std::string_view optName ) & {
                m_optNames.push_back(optName);
                return *this;
            }
-            Opt&& operator[]( StringRef optName ) && {
+            Opt&& operator[]( std::string_view optName ) && {
                m_optNames.push_back( optName );
                return CATCH_MOVE(*this);
            }

            Detail::HelpColumns getHelpColumns() const;

-            bool isMatch(StringRef optToken) const;
+            bool isMatch(std::string_view optToken) const;

            using ParserBase::parse;

@@ -705,15 +695,15 @@ namespace Catch {
         */
        class Args {
            friend Detail::TokenStream;
-            StringRef m_exeName;
-            std::vector<StringRef> m_args;
+            std::string_view m_exeName;
+            std::vector<std::string_view> m_args;

        public:
            Args(int argc, char const* const* argv);
            // Helper constructor for testing
-            Args(std::initializer_list<StringRef> args);
+            Args(std::initializer_list<std::string_view> args);

-            StringRef exeName() const { return m_exeName; }
+            std::string_view exeName() const { return m_exeName; }
        };


--- a/src/catch2/internal/catch_commandline.cpp
+++ b/src/catch2/internal/catch_commandline.cpp
@@ -88,7 +88,7 @@ namespace Catch {
                return ParserResult::ok( ParseResultType::Matched );
            };
        auto const setDefaultColourMode = [&]( std::string const& colourMode ) {
-            Optional<ColourMode> maybeMode = Catch::Detail::stringToColourMode(toLower( colourMode ));
+            std::optional<ColourMode> maybeMode = Catch::Detail::stringToColourMode(toLower( colourMode ));
            if ( !maybeMode ) {
                return ParserResult::runtimeError(
                    "colour mode must be one of: default, ansi, win32, "
@@ -135,7 +135,7 @@ namespace Catch {
                return ParserResult::runtimeError( "Received empty reporter spec." );
            }

-            Optional<ReporterSpec> parsed =
+            std::optional<ReporterSpec> parsed =
                parseReporterSpec( userReporterSpec );
            if ( !parsed ) {
                return ParserResult::runtimeError(
@@ -156,7 +156,7 @@ namespace Catch {
            }


-            const bool hadOutputFile = reporterSpec.outputFile().some();
+            const bool hadOutputFile = reporterSpec.outputFile().has_value();
            config.reporterSpecifications.push_back( CATCH_MOVE( *parsed ) );
            // It would be enough to check this only once at the very end, but
            // there is  not a place where we could call this check, so do it
@@ -165,7 +165,7 @@ namespace Catch {
            if (!hadOutputFile) {
                int n_reporters_without_file = 0;
                for (auto const& spec : config.reporterSpecifications) {
-                    if (spec.outputFile().none()) {
+                    if (!spec.outputFile()) {
                        n_reporters_without_file++;
                    }
                }
--- a/src/catch2/internal/catch_compiler_capabilities.hpp
+++ b/src/catch2/internal/catch_compiler_capabilities.hpp
@@ -29,10 +29,6 @@

 #ifdef __cplusplus

-#  if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
-#    define CATCH_CPP17_OR_GREATER
-#  endif
-
 #  if (__cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
 #    define CATCH_CPP20_OR_GREATER
 #  endif
@@ -198,8 +194,7 @@
 #   define _BSD_SOURCE
 // some versions of cygwin (most) do not support std::to_string. Use the libstd check.
 // https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
-# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
-           && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
+# if !(defined(_GLIBCXX_USE_C99) && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))

 #    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING

@@ -220,13 +215,17 @@
 #    endif

 // Universal Windows platform does not support SEH
-// Or console colours (or console at all...)
-#  if defined(CATCH_PLATFORM_WINDOWS_UWP)
-#    define CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32
-#  else
+#  if !defined(CATCH_PLATFORM_WINDOWS_UWP)
 #    define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
 #  endif

+// Only some Windows platform families support the console
+#  if defined(WINAPI_FAMILY_PARTITION)
+#    if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM)
+#      define CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32
+#    endif
+#  endif
+
 // MSVC traditional preprocessor needs some workaround for __VA_ARGS__
 // _MSVC_TRADITIONAL == 0 means new conformant preprocessor
 // _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
@@ -271,43 +270,6 @@
 #define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
 #endif

-// Various stdlib support checks that require __has_include
-#if defined(__has_include)
-  // Check if string_view is available and usable
-  #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
-  #endif
-
-  // Check if optional is available and usable
-  #  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
-  #  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
-
-  // Check if byte is available and usable
-  #  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
-  #    include <cstddef>
-  #    if defined(__cpp_lib_byte) && (__cpp_lib_byte > 0)
-  #      define CATCH_INTERNAL_CONFIG_CPP17_BYTE
-  #    endif
-  #  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
-
-  // Check if variant is available and usable
-  #  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
-  #    if defined(__clang__) && (__clang_major__ < 8)
-         // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
-         // fix should be in clang 8, workaround in libstdc++ 8.2
-  #      include <ciso646>
-  #      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
-  #        define CATCH_CONFIG_NO_CPP17_VARIANT
-  #      else
-  #        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
-  #      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
-  #    else
-  #      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
-  #    endif // defined(__clang__) && (__clang_major__ < 8)
-  #  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
-#endif // defined(__has_include)
-

 #if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
 #   define CATCH_CONFIG_WINDOWS_SEH
@@ -325,22 +287,6 @@
 #    define CATCH_CONFIG_CPP11_TO_STRING
 #endif

-#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
-#  define CATCH_CONFIG_CPP17_OPTIONAL
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
-#  define CATCH_CONFIG_CPP17_STRING_VIEW
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
-#  define CATCH_CONFIG_CPP17_VARIANT
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
-#  define CATCH_CONFIG_CPP17_BYTE
-#endif
-

 #if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
 #  define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
--- a/src/catch2/internal/catch_config_uncaught_exceptions.hpp
+++ b/src/catch2/internal/catch_config_uncaught_exceptions.hpp
@@ -1,46 +0,0 @@
-
-//              Copyright Catch2 Authors
-// Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE.txt or copy at
-//        https://www.boost.org/LICENSE_1_0.txt)
-
-// SPDX-License-Identifier: BSL-1.0
-
-/** \file
- * Wrapper for UNCAUGHT_EXCEPTIONS configuration option
- *
- * For some functionality, Catch2 requires to know whether there is
- * an active exception. Because `std::uncaught_exception` is deprecated
- * in C++17, we want to use `std::uncaught_exceptions` if possible.
- */
-
-#ifndef CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
-#define CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
-
-#include <catch2/catch_user_config.hpp>
-
-#if defined(_MSC_VER)
-#  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
-#    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#  endif
-#endif
-
-
-#include <exception>
-
-#if defined(__cpp_lib_uncaught_exceptions) \
-    && !defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
-
-#  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#endif // __cpp_lib_uncaught_exceptions
-
-
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) \
-    && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) \
-    && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
-
-#  define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#endif
-
-
-#endif // CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
--- a/src/catch2/internal/catch_console_colour.cpp
+++ b/src/catch2/internal/catch_console_colour.cpp
@@ -161,7 +161,7 @@ namespace {
 #endif // Windows/ ANSI/ None


-#if defined( CATCH_PLATFORM_LINUX ) || defined( CATCH_PLATFORM_MAC ) || defined( __GLIBC__ )
+#if defined( CATCH_PLATFORM_LINUX ) || defined( CATCH_PLATFORM_MAC ) || defined( __GLIBC__ ) || defined(__FreeBSD__)
 #    define CATCH_INTERNAL_HAS_ISATTY
 #    include <unistd.h>
 #endif
--- a/src/catch2/internal/catch_container_nonmembers.hpp
+++ b/src/catch2/internal/catch_container_nonmembers.hpp
@@ -1,73 +0,0 @@
-
-//              Copyright Catch2 Authors
-// Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE.txt or copy at
-//        https://www.boost.org/LICENSE_1_0.txt)
-
-// SPDX-License-Identifier: BSL-1.0
-#ifndef CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
-#define CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
-
-#include <catch2/internal/catch_compiler_capabilities.hpp>
-
-#include <cstddef>
-#include <initializer_list>
-
-// We want a simple polyfill over `std::empty`, `std::size` and so on
-// for C++14 or C++ libraries with incomplete support.
-// We also have to handle that MSVC std lib will happily provide these
-// under older standards.
-#if defined(CATCH_CPP17_OR_GREATER) || defined(_MSC_VER)
-
-// We are already using this header either way, so there shouldn't
-// be much additional overhead in including it to get the feature
-// test macros
-#include <string>
-
-#  if !defined(__cpp_lib_nonmember_container_access)
-#      define CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
-#  endif
-
-#else
-#define CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
-#endif
-
-
-
-namespace Catch {
-namespace Detail {
-
-#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
-    template <typename Container>
-    constexpr auto empty(Container const& cont) -> decltype(cont.empty()) {
-        return cont.empty();
-    }
-    template <typename T, std::size_t N>
-    constexpr bool empty(const T (&)[N]) noexcept {
-        // GCC < 7 does not support the const T(&)[] parameter syntax
-        // so we have to ignore the length explicitly
-        (void)N;
-        return false;
-    }
-    template <typename T>
-    constexpr bool empty(std::initializer_list<T> list) noexcept {
-        return list.size() > 0;
-    }
-
-
-    template <typename Container>
-    constexpr auto size(Container const& cont) -> decltype(cont.size()) {
-        return cont.size();
-    }
-    template <typename T, std::size_t N>
-    constexpr std::size_t size(const T(&)[N]) noexcept {
-        return N;
-    }
-#endif // CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
-
-} // end namespace Detail
-} // end namespace Catch
-
-
-
-#endif // CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
--- a/src/catch2/internal/catch_decomposer.cpp
+++ b/src/catch2/internal/catch_decomposer.cpp
@@ -17,7 +17,7 @@ namespace Catch {
        os << "Some class derived from ITransientExpression without overriding streamReconstructedExpression";
    }

-    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
+    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, std::string_view op, std::string const& rhs ) {
        if( lhs.size() + rhs.size() < 40 &&
                lhs.find('\n') == std::string::npos &&
                rhs.find('\n') == std::string::npos )
--- a/src/catch2/internal/catch_decomposer.hpp
+++ b/src/catch2/internal/catch_decomposer.hpp
@@ -9,10 +9,8 @@
 #define CATCH_DECOMPOSER_HPP_INCLUDED

 #include <catch2/catch_tostring.hpp>
-#include <catch2/internal/catch_stringref.hpp>
 #include <catch2/internal/catch_compare_traits.hpp>
 #include <catch2/internal/catch_test_failure_exception.hpp>
-#include <catch2/internal/catch_logical_traits.hpp>
 #include <catch2/internal/catch_compiler_capabilities.hpp>

 #include <type_traits>
@@ -129,7 +127,7 @@
 namespace Catch {

    namespace Detail {
-        // This was added in C++20, but we require only C++14 for now.
+        // This was added in C++20, but we require only C++17 for now.
        template <typename T>
        using RemoveCVRef_t = std::remove_cv_t<std::remove_reference_t<T>>;
    }
@@ -148,8 +146,8 @@ namespace Catch {
    template <typename T>
    struct capture_by_value
        : std::integral_constant<bool,
-                                 std::is_arithmetic<T>::value ||
-                                     std::is_enum<T>::value> {};
+                                 std::is_arithmetic_v<T> ||
+                                     std::is_enum_v<T>> {};

 #if defined( CATCH_CONFIG_CPP20_COMPARE_OVERLOADS )
    template <>
@@ -190,12 +188,12 @@ namespace Catch {
        }
    };

-    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
+    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, std::string_view op, std::string const& rhs );

    template<typename LhsT, typename RhsT>
    class BinaryExpr  : public ITransientExpression {
        LhsT m_lhs;
-        StringRef m_op;
+        std::string_view m_op;
        RhsT m_rhs;

        void streamReconstructedExpression( std::ostream &os ) const override {
@@ -204,7 +202,7 @@ namespace Catch {
        }

    public:
-        constexpr BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
+        constexpr BinaryExpr( bool comparisonResult, LhsT lhs, std::string_view op, RhsT rhs )
        :   ITransientExpression{ true, comparisonResult },
            m_lhs( lhs ),
            m_op( op ),
@@ -294,48 +292,48 @@ namespace Catch {
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs )             \
        -> std::enable_if_t<                                                   \
-            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
-                                Detail::negation<capture_by_value<             \
-                                    Detail::RemoveCVRef_t<RhsT>>>>::value,     \
+            std::conjunction_v<Detail::is_##id##_comparable<LhsT, RhsT>,       \
+                                std::negation<capture_by_value<                \
+                                    Detail::RemoveCVRef_t<RhsT>>>>,            \
            BinaryExpr<LhsT, RhsT const&>> {                                   \
        return {                                                               \
-            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op, rhs }; \
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
        -> std::enable_if_t<                                                   \
-            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
-                                capture_by_value<RhsT>>::value,                \
+            std::conjunction_v<Detail::is_##id##_comparable<LhsT, RhsT>,       \
+                                capture_by_value<RhsT>>,                       \
            BinaryExpr<LhsT, RhsT>> {                                          \
        return {                                                               \
-            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op, rhs }; \
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
        -> std::enable_if_t<                                                   \
-            Detail::conjunction<                                               \
-                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
+            std::conjunction_v<                                                \
+                std::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,       \
                Detail::is_eq_0_comparable<LhsT>,                              \
              /* We allow long because we want `ptr op NULL` to be accepted */ \
-                Detail::disjunction<std::is_same<RhsT, int>,                   \
-                                    std::is_same<RhsT, long>>>::value,         \
+                std::disjunction<std::is_same<RhsT, int>,                      \
+                                    std::is_same<RhsT, long>>>,                \
            BinaryExpr<LhsT, RhsT>> {                                          \
        if ( rhs != 0 ) { throw_test_failure_exception(); }                    \
        return {                                                               \
-            static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs };   \
+            static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op, rhs };   \
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
        -> std::enable_if_t<                                                   \
-            Detail::conjunction<                                               \
-                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
+            std::conjunction_v<                                                \
+                std::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,       \
                Detail::is_eq_0_comparable<RhsT>,                              \
              /* We allow long because we want `ptr op NULL` to be accepted */ \
-                Detail::disjunction<std::is_same<LhsT, int>,                   \
-                                    std::is_same<LhsT, long>>>::value,         \
+                std::disjunction<std::is_same<LhsT, int>,                      \
+                                    std::is_same<LhsT, long>>>,                \
            BinaryExpr<LhsT, RhsT>> {                                          \
        if ( lhs.m_lhs != 0 ) { throw_test_failure_exception(); }              \
-        return { static_cast<bool>( 0 op rhs ), lhs.m_lhs, #op##_sr, rhs };    \
+        return { static_cast<bool>( 0 op rhs ), lhs.m_lhs, #op, rhs };    \
    }

        CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( eq, == )
@@ -348,44 +346,44 @@ namespace Catch {
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs )             \
        -> std::enable_if_t<                                                   \
-            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
-                                Detail::negation<capture_by_value<             \
-                                    Detail::RemoveCVRef_t<RhsT>>>>::value,     \
+            std::conjunction_v<Detail::is_##id##_comparable<LhsT, RhsT>,       \
+                                std::negation<capture_by_value<                \
+                                    Detail::RemoveCVRef_t<RhsT>>>>,            \
            BinaryExpr<LhsT, RhsT const&>> {                                   \
        return {                                                               \
-            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op, rhs }; \
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
        -> std::enable_if_t<                                                   \
-            Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>,      \
-                                capture_by_value<RhsT>>::value,                \
+            std::conjunction_v<Detail::is_##id##_comparable<LhsT, RhsT>,       \
+                                capture_by_value<RhsT>>      ,                 \
            BinaryExpr<LhsT, RhsT>> {                                          \
        return {                                                               \
-            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op, rhs }; \
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
        -> std::enable_if_t<                                                   \
-            Detail::conjunction<                                               \
-                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
+            std::conjunction_v<                                                \
+                std::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,       \
                Detail::is_##id##_0_comparable<LhsT>,                          \
-                std::is_same<RhsT, int>>::value,                               \
+                std::is_same<RhsT, int>>,                                      \
            BinaryExpr<LhsT, RhsT>> {                                          \
        if ( rhs != 0 ) { throw_test_failure_exception(); }                    \
        return {                                                               \
-            static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs };   \
+            static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op, rhs };   \
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
        -> std::enable_if_t<                                                   \
-            Detail::conjunction<                                               \
-                Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,    \
+            std::conjunction_v<                                                \
+                std::negation<Detail::is_##id##_comparable<LhsT, RhsT>>,       \
                Detail::is_##id##_0_comparable<RhsT>,                          \
-                std::is_same<LhsT, int>>::value,                               \
+                std::is_same<LhsT, int>>,                                      \
            BinaryExpr<LhsT, RhsT>> {                                          \
        if ( lhs.m_lhs != 0 ) { throw_test_failure_exception(); }              \
-        return { static_cast<bool>( 0 op rhs ), lhs.m_lhs, #op##_sr, rhs };    \
+        return { static_cast<bool>( 0 op rhs ), lhs.m_lhs, #op, rhs };    \
    }

        CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( lt, < )
@@ -403,14 +401,14 @@ namespace Catch {
            !capture_by_value<Detail::RemoveCVRef_t<RhsT>>::value,             \
            BinaryExpr<LhsT, RhsT const&>> {                                   \
        return {                                                               \
-            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op, rhs }; \
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
        -> std::enable_if_t<capture_by_value<RhsT>::value,                     \
                            BinaryExpr<LhsT, RhsT>> {                          \
        return {                                                               \
-            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op, rhs }; \
    }

        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(|)
--- a/src/catch2/internal/catch_enum_values_registry.cpp
+++ b/src/catch2/internal/catch_enum_values_registry.cpp
@@ -19,7 +19,7 @@ namespace Catch {
        namespace {
            // Extracts the actual name part of an enum instance
            // In other words, it returns the Blue part of Bikeshed::Colour::Blue
-            StringRef extractInstanceName(StringRef enumInstance) {
+            std::string_view extractInstanceName(std::string_view enumInstance) {
                // Find last occurrence of ":"
                size_t name_start = enumInstance.size();
                while (name_start > 0 && enumInstance[name_start - 1] != ':') {
@@ -29,9 +29,9 @@ namespace Catch {
            }
        }

-        std::vector<StringRef> parseEnums( StringRef enums ) {
+        std::vector<std::string_view> parseEnums( std::string_view enums ) {
            auto enumValues = splitStringRef( enums, ',' );
-            std::vector<StringRef> parsed;
+            std::vector<std::string_view> parsed;
            parsed.reserve( enumValues.size() );
            for( auto const& enumValue : enumValues ) {
                parsed.push_back(trim(extractInstanceName(enumValue)));
@@ -41,15 +41,15 @@ namespace Catch {

        EnumInfo::~EnumInfo() = default;

-        StringRef EnumInfo::lookup( int value ) const {
+        std::string_view EnumInfo::lookup( int value ) const {
            for( auto const& valueToName : m_values ) {
                if( valueToName.first == value )
                    return valueToName.second;
            }
-            return "{** unexpected enum value **}"_sr;
+            return "{** unexpected enum value **}";
        }

-        Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+        Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( std::string_view enumName, std::string_view allValueNames, std::vector<int> const& values ) {
            auto enumInfo = Catch::Detail::make_unique<EnumInfo>();
            enumInfo->m_name = enumName;
            enumInfo->m_values.reserve( values.size() );
@@ -63,11 +63,10 @@ namespace Catch {
            return enumInfo;
        }

-        EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+        EnumInfo const& EnumValuesRegistry::registerEnum( std::string_view enumName, std::string_view allValueNames, std::vector<int> const& values ) {
            m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
            return *m_enumInfos.back();
        }

    } // Detail
 } // Catch
-
--- a/src/catch2/internal/catch_enum_values_registry.hpp
+++ b/src/catch2/internal/catch_enum_values_registry.hpp
@@ -10,7 +10,6 @@

 #include <catch2/interfaces/catch_interfaces_enum_values_registry.hpp>
 #include <catch2/internal/catch_unique_ptr.hpp>
-#include <catch2/internal/catch_stringref.hpp>

 #include <vector>

@@ -18,16 +17,16 @@ namespace Catch {

    namespace Detail {

-        Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
+        Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( std::string_view enumName, std::string_view allValueNames, std::vector<int> const& values );

        class EnumValuesRegistry : public IMutableEnumValuesRegistry {

            std::vector<Catch::Detail::unique_ptr<EnumInfo>> m_enumInfos;

-            EnumInfo const& registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values) override;
+            EnumInfo const& registerEnum( std::string_view enumName, std::string_view allValueNames, std::vector<int> const& values) override;
        };

-        std::vector<StringRef> parseEnums( StringRef enums );
+        std::vector<std::string_view> parseEnums( std::string_view enums );

    } // Detail

--- a/src/catch2/internal/catch_is_permutation.hpp
+++ b/src/catch2/internal/catch_is_permutation.hpp
@@ -49,7 +49,7 @@ namespace Catch {

        template <typename ForwardIter, typename Sentinel>
        constexpr
-        std::enable_if_t<!std::is_same<ForwardIter, Sentinel>::value,
+        std::enable_if_t<!std::is_same_v<ForwardIter, Sentinel>,
                         std::ptrdiff_t>
        sentinel_distance( ForwardIter iter, const Sentinel sentinel ) {
            std::ptrdiff_t dist = 0;
--- a/src/catch2/internal/catch_jsonwriter.cpp
+++ b/src/catch2/internal/catch_jsonwriter.cpp
@@ -7,8 +7,36 @@
 // SPDX-License-Identifier: BSL-1.0
 #include <catch2/internal/catch_enforce.hpp>
 #include <catch2/internal/catch_jsonwriter.hpp>
+#include <catch2/internal/catch_unreachable.hpp>

 namespace Catch {
+
+    namespace {
+        static bool needsEscape( char c ) {
+            return c == '"' || c == '\\' || c == '\b' || c == '\f' ||
+                   c == '\n' || c == '\r' || c == '\t';
+        }
+
+        static std::string_view makeEscapeStringRef( char c ) {
+            if ( c == '"' ) {
+                return "\\\"";
+            } else if ( c == '\\' ) {
+                return "\\\\";
+            } else if ( c == '\b' ) {
+                return "\\b";
+            } else if ( c == '\f' ) {
+                return "\\f";
+            } else if ( c == '\n' ) {
+                return "\\n";
+            } else if ( c == '\r' ) {
+                return "\\r";
+            } else if ( c == '\t' ) {
+                return "\\t";
+            }
+            Catch::Detail::Unreachable();
+        }
+    } // namespace
+
    void JsonUtils::indent( std::ostream& os, std::uint64_t level ) {
        for ( std::uint64_t i = 0; i < level; ++i ) {
            os << "  ";
@@ -47,7 +75,7 @@ namespace Catch {
        m_os << '}';
    }

-    JsonValueWriter JsonObjectWriter::write( StringRef key ) {
+    JsonValueWriter JsonObjectWriter::write( std::string_view key ) {
        JsonUtils::appendCommaNewline(
            m_os, m_should_comma, m_indent_level + 1 );

@@ -108,40 +136,29 @@ namespace Catch {
        return JsonArrayWriter{ m_os, m_indent_level };
    }

-    void JsonValueWriter::write( Catch::StringRef value ) && {
+    void JsonValueWriter::write( std::string_view value ) && {
        writeImpl( value, true );
    }

    void JsonValueWriter::write( bool value ) && {
-        writeImpl( value ? "true"_sr : "false"_sr, false );
+        writeImpl( value ? "true" : "false", false );
    }

-    void JsonValueWriter::writeImpl( Catch::StringRef value, bool quote ) {
+    void JsonValueWriter::writeImpl( std::string_view value, bool quote ) {
        if ( quote ) { m_os << '"'; }
-        for (char c : value) {
-            // Escape list taken from https://www.json.org/json-en.html,
-            // string definition.
-            // Note that while forward slash _can_ be escaped, it does
-            // not have to be, if JSON is not further embedded somewhere
-            // where forward slash is meaningful.
-            if ( c == '"' ) {
-                m_os << "\\\"";
-            } else if ( c == '\\' ) {
-                m_os << "\\\\";
-            } else if ( c == '\b' ) {
-                m_os << "\\b";
-            } else if ( c == '\f' ) {
-                m_os << "\\f";
-            } else if ( c == '\n' ) {
-                m_os << "\\n";
-            } else if ( c == '\r' ) {
-                m_os << "\\r";
-            } else if ( c == '\t' ) {
-                m_os << "\\t";
-            } else {
-                m_os << c;
+        size_t current_start = 0;
+        for ( size_t i = 0; i < value.size(); ++i ) {
+            if ( needsEscape( value[i] ) ) {
+                if ( current_start < i ) {
+                    m_os << value.substr( current_start, i - current_start );
+                }
+                m_os << makeEscapeStringRef( value[i] );
+                current_start = i + 1;
            }
        }
+        if ( current_start < value.size() ) {
+            m_os << value.substr( current_start, value.size() - current_start );
+        }
        if ( quote ) { m_os << '"'; }
    }

--- a/src/catch2/internal/catch_jsonwriter.hpp
+++ b/src/catch2/internal/catch_jsonwriter.hpp
@@ -9,7 +9,6 @@
 #define CATCH_JSONWRITER_HPP_INCLUDED

 #include <catch2/internal/catch_reusable_string_stream.hpp>
-#include <catch2/internal/catch_stringref.hpp>

 #include <cstdint>
 #include <sstream>
@@ -35,13 +34,13 @@ namespace Catch {

        template <typename T>
        void write( T const& value ) && {
-            writeImpl( value, !std::is_arithmetic<T>::value );
+            writeImpl( value, !std::is_arithmetic_v<T> );
        }
-        void write( StringRef value ) &&;
+        void write( std::string_view value ) &&;
        void write( bool value ) &&;

    private:
-        void writeImpl( StringRef value, bool quote );
+        void writeImpl( std::string_view value, bool quote );

        // Without this SFINAE, this overload is a better match
        // for `std::string`, `char const*`, `char const[N]` args.
@@ -49,7 +48,7 @@ namespace Catch {
        // and multiple iteration over the strings
        template <typename T,
                  typename = typename std::enable_if_t<
-                      !std::is_convertible<T, StringRef>::value>>
+                      !std::is_convertible_v<T, std::string_view>>>
        void writeImpl( T const& value, bool quote_value ) {
            m_sstream << value;
            writeImpl( m_sstream.str(), quote_value );
@@ -70,7 +69,7 @@ namespace Catch {

        ~JsonObjectWriter();

-        JsonValueWriter write( StringRef key );
+        JsonValueWriter write( std::string_view key );

    private:
        std::ostream& m_os;
--- a/src/catch2/internal/catch_list.cpp
+++ b/src/catch2/internal/catch_list.cpp
@@ -30,7 +30,7 @@ namespace Catch {
            auto const& testSpec = config.testSpec();
            std::vector<TestCaseHandle> matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);

-            std::map<StringRef, TagInfo, Detail::CaseInsensitiveLess> tagCounts;
+            std::map<std::string_view, TagInfo, Detail::CaseInsensitiveLess> tagCounts;
            for (auto const& testCase : matchedTestCases) {
                for (auto const& tagName : testCase.getTestCaseInfo().tags) {
                    auto it = tagCounts.find(tagName.original);
@@ -75,7 +75,7 @@ namespace Catch {

    } // end anonymous namespace

-    void TagInfo::add( StringRef spelling ) {
+    void TagInfo::add( std::string_view spelling ) {
        ++count;
        spellings.insert( spelling );
    }
--- a/src/catch2/internal/catch_list.hpp
+++ b/src/catch2/internal/catch_list.hpp
@@ -8,10 +8,9 @@
 #ifndef CATCH_LIST_HPP_INCLUDED
 #define CATCH_LIST_HPP_INCLUDED

-#include <catch2/internal/catch_stringref.hpp>
-
 #include <set>
 #include <string>
+#include <string_view>


 namespace Catch {
@@ -24,15 +23,15 @@ namespace Catch {
        std::string name, description;
    };
    struct ListenerDescription {
-        StringRef name;
+        std::string_view name;
        std::string description;
    };

    struct TagInfo {
-        void add(StringRef spelling);
+        void add(std::string_view spelling);
        std::string all() const;

-        std::set<StringRef> spellings;
+        std::set<std::string_view> spellings;
        std::size_t count = 0;
    };

--- a/src/catch2/internal/catch_logical_traits.hpp
+++ b/src/catch2/internal/catch_logical_traits.hpp
@@ -1,44 +0,0 @@
-
-//              Copyright Catch2 Authors
-// Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE.txt or copy at
-//        https://www.boost.org/LICENSE_1_0.txt)
-
-// SPDX-License-Identifier: BSL-1.0
-#ifndef CATCH_LOGICAL_TRAITS_HPP_INCLUDED
-#define CATCH_LOGICAL_TRAITS_HPP_INCLUDED
-
-#include <type_traits>
-
-namespace Catch {
-namespace Detail {
-
-#if defined( __cpp_lib_logical_traits ) && __cpp_lib_logical_traits >= 201510
-
-    using std::conjunction;
-    using std::disjunction;
-    using std::negation;
-
-#else
-
-    template <class...> struct conjunction : std::true_type {};
-    template <class B1> struct conjunction<B1> : B1 {};
-    template <class B1, class... Bn>
-    struct conjunction<B1, Bn...>
-        : std::conditional_t<bool( B1::value ), conjunction<Bn...>, B1> {};
-
-    template <class...> struct disjunction : std::false_type {};
-    template <class B1> struct disjunction<B1> : B1 {};
-    template <class B1, class... Bn>
-    struct disjunction<B1, Bn...>
-        : std::conditional_t<bool( B1::value ), B1, disjunction<Bn...>> {};
-
-    template <class B>
-    struct negation : std::integral_constant<bool, !bool(B::value)> {};
-
-#endif
-
-} // namespace Detail
-} // namespace Catch
-
-#endif // CATCH_LOGICAL_TRAITS_HPP_INCLUDED
--- a/src/catch2/internal/catch_message_info.cpp
+++ b/src/catch2/internal/catch_message_info.cpp
@@ -10,16 +10,17 @@

 namespace Catch {

-    MessageInfo::MessageInfo(   StringRef _macroName,
-                                SourceLineInfo const& _lineInfo,
-                                ResultWas::OfType _type )
+    MessageInfo::MessageInfo( std::string_view _macroName,
+                              SourceLineInfo const& _lineInfo,
+                              ResultWas::OfType _type )
    :   macroName( _macroName ),
        lineInfo( _lineInfo ),
        type( _type ),
        sequence( ++globalCount )
    {}

-    // This may need protecting if threading support is added
-    unsigned int MessageInfo::globalCount = 0;
+    // Messages are owned by their individual threads, so the counter should be thread-local as well.
+    // Alternative consideration: atomic, so threads don't share IDs and things are easier to debug.
+    thread_local unsigned int MessageInfo::globalCount = 0;

 } // end namespace Catch
--- a/src/catch2/internal/catch_message_info.hpp
+++ b/src/catch2/internal/catch_message_info.hpp
@@ -11,21 +11,21 @@
 #include <catch2/internal/catch_deprecation_macro.hpp>
 #include <catch2/internal/catch_result_type.hpp>
 #include <catch2/internal/catch_source_line_info.hpp>
-#include <catch2/internal/catch_stringref.hpp>

 #include <string>

 namespace Catch {

    struct MessageInfo {
-        MessageInfo(    StringRef _macroName,
+        MessageInfo(    std::string_view _macroName,
                        SourceLineInfo const& _lineInfo,
                        ResultWas::OfType _type );

-        StringRef macroName;
+        std::string_view macroName;
        std::string message;
        SourceLineInfo lineInfo;
        ResultWas::OfType type;
+        // The "ID" of the message, used to know when to remove it from reporter context.
        unsigned int sequence;

        DEPRECATED( "Explicitly use the 'sequence' member instead" )
@@ -37,7 +37,7 @@ namespace Catch {
            return sequence < other.sequence;
        }
    private:
-        static unsigned int globalCount;
+        static thread_local unsigned int globalCount;
    };

 } // end namespace Catch
--- a/src/catch2/internal/catch_meta.hpp
+++ b/src/catch2/internal/catch_meta.hpp
@@ -27,16 +27,8 @@ namespace Catch {
    template <typename Fun, typename... Args>
    struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};

-
-#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
-    // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
-    // replaced with std::invoke_result here.
    template <typename Func, typename... U>
    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U...>>>;
-#else
-    template <typename Func, typename... U>
-    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::result_of_t<Func(U...)>>>;
-#endif

 } // namespace Catch

--- a/src/catch2/internal/catch_optional.hpp
+++ b/src/catch2/internal/catch_optional.hpp
@@ -1,117 +0,0 @@
-
-//              Copyright Catch2 Authors
-// Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE.txt or copy at
-//        https://www.boost.org/LICENSE_1_0.txt)
-
-// SPDX-License-Identifier: BSL-1.0
-#ifndef CATCH_OPTIONAL_HPP_INCLUDED
-#define CATCH_OPTIONAL_HPP_INCLUDED
-
-#include <catch2/internal/catch_move_and_forward.hpp>
-
-#include <cassert>
-
-namespace Catch {
-
-    // An optional type
-    template<typename T>
-    class Optional {
-    public:
-        Optional(): nullableValue( nullptr ) {}
-        ~Optional() { reset(); }
-
-        Optional( T const& _value ):
-            nullableValue( new ( storage ) T( _value ) ) {}
-        Optional( T&& _value ):
-            nullableValue( new ( storage ) T( CATCH_MOVE( _value ) ) ) {}
-
-        Optional& operator=( T const& _value ) {
-            reset();
-            nullableValue = new ( storage ) T( _value );
-            return *this;
-        }
-        Optional& operator=( T&& _value ) {
-            reset();
-            nullableValue = new ( storage ) T( CATCH_MOVE( _value ) );
-            return *this;
-        }
-
-        Optional( Optional const& _other ):
-            nullableValue( _other ? new ( storage ) T( *_other ) : nullptr ) {}
-        Optional( Optional&& _other ):
-            nullableValue( _other ? new ( storage ) T( CATCH_MOVE( *_other ) )
-                                  : nullptr ) {}
-
-        Optional& operator=( Optional const& _other ) {
-            if ( &_other != this ) {
-                reset();
-                if ( _other ) { nullableValue = new ( storage ) T( *_other ); }
-            }
-            return *this;
-        }
-        Optional& operator=( Optional&& _other ) {
-            if ( &_other != this ) {
-                reset();
-                if ( _other ) {
-                    nullableValue = new ( storage ) T( CATCH_MOVE( *_other ) );
-                }
-            }
-            return *this;
-        }
-
-        void reset() {
-            if ( nullableValue ) { nullableValue->~T(); }
-            nullableValue = nullptr;
-        }
-
-        T& operator*() {
-            assert(nullableValue);
-            return *nullableValue;
-        }
-        T const& operator*() const {
-            assert(nullableValue);
-            return *nullableValue;
-        }
-        T* operator->() {
-            assert(nullableValue);
-            return nullableValue;
-        }
-        const T* operator->() const {
-            assert(nullableValue);
-            return nullableValue;
-        }
-
-        T valueOr( T const& defaultValue ) const {
-            return nullableValue ? *nullableValue : defaultValue;
-        }
-
-        bool some() const { return nullableValue != nullptr; }
-        bool none() const { return nullableValue == nullptr; }
-
-        bool operator !() const { return nullableValue == nullptr; }
-        explicit operator bool() const {
-            return some();
-        }
-
-        friend bool operator==(Optional const& a, Optional const& b) {
-            if (a.none() && b.none()) {
-                return true;
-            } else if (a.some() && b.some()) {
-                return *a == *b;
-            } else {
-                return false;
-            }
-        }
-        friend bool operator!=(Optional const& a, Optional const& b) {
-            return !( a == b );
-        }
-
-    private:
-        T* nullableValue;
-        alignas(alignof(T)) char storage[sizeof(T)];
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_OPTIONAL_HPP_INCLUDED
--- a/src/catch2/internal/catch_output_redirect.cpp
+++ b/src/catch2/internal/catch_output_redirect.cpp
@@ -311,23 +311,6 @@ namespace Catch {
        }
    }

-    RedirectGuard::RedirectGuard( RedirectGuard&& rhs ) noexcept:
-        m_redirect( rhs.m_redirect ),
-        m_activate( rhs.m_activate ),
-        m_previouslyActive( rhs.m_previouslyActive ),
-        m_moved( false ) {
-        rhs.m_moved = true;
-    }
-
-    RedirectGuard& RedirectGuard::operator=( RedirectGuard&& rhs ) noexcept {
-        m_redirect = rhs.m_redirect;
-        m_activate = rhs.m_activate;
-        m_previouslyActive = rhs.m_previouslyActive;
-        m_moved = false;
-        rhs.m_moved = true;
-        return *this;
-    }
-
 } // namespace Catch

 #if defined( CATCH_CONFIG_NEW_CAPTURE )
--- a/src/catch2/internal/catch_output_redirect.hpp
+++ b/src/catch2/internal/catch_output_redirect.hpp
@@ -63,10 +63,6 @@ namespace Catch {

        RedirectGuard( RedirectGuard const& ) = delete;
        RedirectGuard& operator=( RedirectGuard const& ) = delete;
-
-        // C++14 needs move-able guards to return them from functions
-        RedirectGuard( RedirectGuard&& rhs ) noexcept;
-        RedirectGuard& operator=( RedirectGuard&& rhs ) noexcept;
    };

    RedirectGuard scopedActivate( OutputRedirect& redirectImpl );
--- a/src/catch2/internal/catch_parse_numbers.cpp
+++ b/src/catch2/internal/catch_parse_numbers.cpp
@@ -12,10 +12,11 @@

 #include <limits>
 #include <stdexcept>
+#include <optional>

 namespace Catch {

-    Optional<unsigned int> parseUInt(std::string const& input, int base) {
+    std::optional<unsigned int> parseUInt(std::string const& input, int base) {
        auto trimmed = trim( input );
        // std::stoull is annoying and accepts numbers starting with '-',
        // it just negates them into unsigned int
--- a/src/catch2/internal/catch_parse_numbers.hpp
+++ b/src/catch2/internal/catch_parse_numbers.hpp
@@ -8,8 +8,7 @@
 #ifndef CATCH_PARSE_NUMBERS_HPP_INCLUDED
 #define CATCH_PARSE_NUMBERS_HPP_INCLUDED

-#include <catch2/internal/catch_optional.hpp>
-
+#include <optional>
 #include <string>

 namespace Catch {
@@ -20,7 +19,7 @@ namespace Catch {
     * Effectively a wrapper around std::stoul but with better error checking
     * e.g. "-1" is rejected, instead of being parsed as UINT_MAX.
     */
-    Optional<unsigned int> parseUInt(std::string const& input, int base = 10);
+    std::optional<unsigned int> parseUInt(std::string const& input, int base = 10);
 }

 #endif // CATCH_PARSE_NUMBERS_HPP_INCLUDED
--- a/src/catch2/internal/catch_preprocessor.hpp
+++ b/src/catch2/internal/catch_preprocessor.hpp
@@ -176,7 +176,7 @@ namespace Catch {
    template<typename... Ts>\
    void reg_test(TypeList<Ts...>, Catch::NameAndTags nameAndTags)\
    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Ts...>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Ts...>), CATCH_INTERNAL_LINEINFO, std::string_view(), nameAndTags);\
    }

 #define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature, ...)
@@ -184,19 +184,19 @@ namespace Catch {
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
    {\
-        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, std::string_view(), nameAndTags);\
    }

 #define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
    template<typename Type>\
-    void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+    void reg_test(TypeList<Type>, std::string_view className, Catch::NameAndTags nameAndTags)\
    {\
        Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
    }

 #define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
-    void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+    void reg_test(Nttp<__VA_ARGS__>, std::string_view className, Catch::NameAndTags nameAndTags)\
    {\
        Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
    }
--- a/src/catch2/internal/catch_preprocessor_internal_stringify.hpp
+++ b/src/catch2/internal/catch_preprocessor_internal_stringify.hpp
@@ -11,9 +11,9 @@
 #include <catch2/catch_user_config.hpp>

 #if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
-  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__##_catch_sr
+  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
 #else
-  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"_catch_sr
+  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
 #endif

 #endif // CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
--- a/src/catch2/internal/catch_random_floating_point_helpers.hpp
+++ b/src/catch2/internal/catch_random_floating_point_helpers.hpp
@@ -27,7 +27,7 @@ namespace Catch {
         */
        template <typename FloatType>
        FloatType gamma(FloatType a, FloatType b) {
-            static_assert( std::is_floating_point<FloatType>::value,
+            static_assert( std::is_floating_point_v<FloatType>,
                           "gamma returns the largest ULP magnitude within "
                           "floating point range [a, b]. This only makes sense "
                           "for floating point types" );
--- a/src/catch2/internal/catch_random_integer_helpers.hpp
+++ b/src/catch2/internal/catch_random_integer_helpers.hpp
@@ -122,7 +122,7 @@ namespace Catch {

        template <typename UInt>
        constexpr ExtendedMultResult<UInt> extendedMult( UInt lhs, UInt rhs ) {
-            static_assert( std::is_unsigned<UInt>::value,
+            static_assert( std::is_unsigned_v<UInt>,
                           "extendedMult can only handle unsigned integers" );
            static_assert( sizeof( UInt ) < sizeof( std::uint64_t ),
                           "Generic extendedMult can only handle types smaller "
@@ -141,7 +141,7 @@ namespace Catch {
            std::enable_if_t<sizeof(typename Generator::result_type) >= sizeof(TargetType),
            TargetType> fillBitsFrom(Generator& gen) {
            using gresult_type = typename Generator::result_type;
-            static_assert( std::is_unsigned<TargetType>::value, "Only unsigned integers are supported" );
+            static_assert( std::is_unsigned_v<TargetType>, "Only unsigned integers are supported" );
            static_assert( Generator::min() == 0 &&
                           Generator::max() == static_cast<gresult_type>( -1 ),
                           "Generator must be able to output all numbers in its result type (effectively it must be a random bit generator)" );
@@ -160,7 +160,7 @@ namespace Catch {
            std::enable_if_t<sizeof(typename Generator::result_type) < sizeof(TargetType),
            TargetType> fillBitsFrom(Generator& gen) {
            using gresult_type = typename Generator::result_type;
-            static_assert( std::is_unsigned<TargetType>::value,
+            static_assert( std::is_unsigned_v<TargetType>,
                           "Only unsigned integers are supported" );
            static_assert( Generator::min() == 0 &&
                           Generator::max() == static_cast<gresult_type>( -1 ),
@@ -188,12 +188,12 @@ namespace Catch {
         */
        template <typename OriginalType, typename UnsignedType>
        constexpr
-        std::enable_if_t<std::is_signed<OriginalType>::value, UnsignedType>
+        std::enable_if_t<std::is_signed_v<OriginalType>, UnsignedType>
        transposeToNaturalOrder( UnsignedType in ) {
            static_assert(
                sizeof( OriginalType ) == sizeof( UnsignedType ),
                "reordering requires the same sized types on both sides" );
-            static_assert( std::is_unsigned<UnsignedType>::value,
+            static_assert( std::is_unsigned_v<UnsignedType>,
                           "Input type must be unsigned" );
            // Assuming 2s complement (standardized in current C++), the
            // positive and negative numbers are already internally ordered,
@@ -209,12 +209,12 @@ namespace Catch {
        template <typename OriginalType,
                  typename UnsignedType>
        constexpr
-        std::enable_if_t<std::is_unsigned<OriginalType>::value, UnsignedType>
+        std::enable_if_t<std::is_unsigned_v<OriginalType>, UnsignedType>
            transposeToNaturalOrder(UnsignedType in) {
            static_assert(
                sizeof( OriginalType ) == sizeof( UnsignedType ),
                "reordering requires the same sized types on both sides" );
-            static_assert( std::is_unsigned<UnsignedType>::value, "Input type must be unsigned" );
+            static_assert( std::is_unsigned_v<UnsignedType>, "Input type must be unsigned" );
            // No reordering is needed for unsigned -> unsigned
            return in;
        }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Chris Thrasher	8efee9b763	Use std::string_view	2025-09-22 11:50:44 -06:00
Chris Thrasher	a5735af2f7	Use std::optional	2025-09-22 11:35:23 -06:00
Chris Thrasher	db46dc4cb2	Upgrade to C++17	2025-09-22 11:35:22 -06:00
Chris Thrasher	c6cefc6596	Disable reproducible build flags for dev builds	2025-09-21 21:43:51 -06:00
Silent	dc3a4ea41a	Fix non-desktop Windows platforms not defining CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32 correctly Fixes building on non-desktop GDK platforms.	2025-09-17 20:25:26 +02:00
Martin Hořeňovský	cd93d202e0	Small refactoring in CAPTURE parsing	2025-08-26 12:40:13 +02:00
Martin Hořeňovský	227af796b4	Move MessageInfos into the run context Together with the previous change, this means that `ScopedMessage` only needs to keep around a single unsigned int.	2025-08-26 12:37:52 +02:00
Martin Hořeňovský	33adb4c779	Use only the ID of a message when removing it from context	2025-08-26 12:07:41 +02:00
Martin Hořeňovský	25319fd304	v3.10.0	2025-08-25 21:30:21 +02:00
Szapi	85c4bad86b	Forbid deducing reference types for m_predicate in FilterGenerator (#3005 ) Forbid deducing reference types for m_predicate in FilterGenerator to prevent dangling references. This is needed for out-of-line predicates to work correctly instead of undefined behavior or crashes. --------- Co-authored-by: Tek Mate <mate.tek@evosoft.com>	2025-08-23 21:55:38 +02:00
Martin Hořeňovský	582200a1f8	Make message macros (FAIL, WARN, INFO, etc) thread safe This builds on the existing work to make assertion thread safe, by adding an extra synchronization point in the holder of `ReusableStringStream`'s stream instances, as those are used to build the messages, and finishing the move of message scope holders to be thread-local.	2025-08-23 11:08:18 +02:00
Martin Hořeňovský	f4e05a67bb	Improve performance of writing XML As with the JSON writer, the old code was made to be simple and for each char just decided whether it needs escaping, or should be written as-is. The new code instead looks for characters that need escaping and batches writes of characters that do not. This provides 4-8x speedup (length dependent) for writing strings that do not need escaping, and keeps roughly the same performance for those that do need escaping.	2025-08-22 17:03:35 +02:00
Martin Hořeňovský	fb2e4fbe41	Improve performance of writing JSON values The old code was exceedingly simple, as it went char-by-char and decided whether to write it to the output stream as-is, or escaped. This caused a _lot_ of stream writes of individual characters. The new code instead looks for characters that need escaping, and bulk-writes the non-escaped characters in between them. This leads to about the same performance for strings that comprise of only escaped characters, and 3-10x improvement for strings without any escaping needed. In practice, we should expect the former rather than the latter, but this is still nice improvement.	2025-08-22 17:00:40 +02:00
Martin Hořeňovský	78a9518a28	Don't add / to start of pkg-config file path when DESTDIR is unset This broke installation on Windows, because the suddenly started with a '/' instead of a drive letter. Closes #3019	2025-08-21 20:58:55 +02:00
Shloka Jain	3e82ef9317	Fix color mode detection on FreeBSD by adding platform macro	2025-08-12 14:38:50 +02:00
Martin Hořeňovský	7cad6d7539	Handle DESTDIR env var when generating pkgconfig files Having the ability to configure the installation path at config time, and the ability to change the prefix at install time is not enough, apparently people also use env var to redirect them instead. Closes #3006	2025-08-09 23:05:18 +02:00