WIP: devirtualize RunContext

I also made a bunch of refactorings around the headers and includes
to simplify the main include path.

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

@@ -29,13 +29,13 @@ jobs:
             build_type: Debug
             std: 14
             other_pkgs: g++-7
-            cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON
+            cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON
           - cxx: g++-7
             build_description: Extras + Examples
             build_type: Release
             std: 14
             other_pkgs: g++-7
-            cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON
+            cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON
 
           # Extras and examples with Clang-10
           - cxx: clang++-10
@@ -43,13 +43,13 @@ jobs:
             build_type: Debug
             std: 17
             other_pkgs: clang-10
-            cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON
+            cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON
           - cxx: clang++-10
             build_description: Extras + Examples
             build_type: Release
             std: 17
             other_pkgs: clang-10
-            cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON
+            cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON
 
           # Configure tests with Clang-10
           - cxx: clang++-10

BUILD.bazel

@@ -43,14 +43,12 @@ expand_template(
         "#cmakedefine CATCH_CONFIG_NO_GLOBAL_NEXTAFTER": "",
         "#cmakedefine CATCH_CONFIG_NO_POSIX_SIGNALS": "",
         "#cmakedefine CATCH_CONFIG_NO_USE_ASYNC": "",
-        "#cmakedefine CATCH_CONFIG_NO_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT": "",
         "#cmakedefine CATCH_CONFIG_NO_WCHAR": "",
         "#cmakedefine CATCH_CONFIG_NO_WINDOWS_SEH": "",
         "#cmakedefine CATCH_CONFIG_NOSTDOUT": "",
         "#cmakedefine CATCH_CONFIG_POSIX_SIGNALS": "",
         "#cmakedefine CATCH_CONFIG_PREFIX_ALL": "",
         "#cmakedefine CATCH_CONFIG_SHARED_LIBRARY": "",
-        "#cmakedefine CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT": "",
         "#cmakedefine CATCH_CONFIG_USE_ASYNC": "",
         "#cmakedefine CATCH_CONFIG_WCHAR": "",
         "#cmakedefine CATCH_CONFIG_WINDOWS_CRTDBG": "",

CMake/CatchConfigOptions.cmake

@@ -41,7 +41,6 @@ set(_OverridableOptions
   "WCHAR"
   "WINDOWS_SEH"
   "GETENV"
-  "EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT"
 )
 
 foreach(OptionName ${_OverridableOptions})
@@ -69,11 +68,7 @@ set(_OtherConfigOptions
 foreach(OptionName ${_OtherConfigOptions})
   AddConfigOption(${OptionName})
 endforeach()
-if(DEFINED BUILD_SHARED_LIBS)
-    set(CATCH_CONFIG_SHARED_LIBRARY ${BUILD_SHARED_LIBS})
-else()
-    set(CATCH_CONFIG_SHARED_LIBRARY "")
-endif()
+set(CATCH_CONFIG_SHARED_LIBRARY ${BUILD_SHARED_LIBS})
 
 set(CATCH_CONFIG_DEFAULT_REPORTER "console" CACHE STRING "Read docs/configuration.md for details. The name of the reporter should be without quotes.")
 set(CATCH_CONFIG_CONSOLE_WIDTH "80" CACHE STRING "Read docs/configuration.md for details. Must form a valid integer literal.")

CMake/CatchMiscFunctions.cmake

@@ -74,7 +74,6 @@ function(add_warnings_to_targets targets)
           "-Woverloaded-virtual"
           "-Wparentheses"
           "-Wpedantic"
-          "-Wredundant-decls"
           "-Wreorder"
           "-Wreturn-std-move"
           "-Wshadow"
@@ -84,7 +83,7 @@ function(add_warnings_to_targets targets)
           "-Wundef"
           "-Wuninitialized"
           "-Wunneeded-internal-declaration"
-          "-Wunreachable-code-aggressive"
+          "-Wunreachable-code"
           "-Wunused"
           "-Wunused-function"
           "-Wunused-parameter"

CMakeLists.txt

@@ -21,7 +21,6 @@ cmake_dependent_option(CATCH_ENABLE_COVERAGE "Generate coverage for codecov.io"
 cmake_dependent_option(CATCH_ENABLE_WERROR "Enables Werror during build" ON "CATCH_DEVELOPMENT_BUILD" OFF)
 cmake_dependent_option(CATCH_BUILD_SURROGATES "Enable generating and building surrogate TUs for the main headers" OFF "CATCH_DEVELOPMENT_BUILD" OFF)
 cmake_dependent_option(CATCH_ENABLE_CONFIGURE_TESTS "Enable CMake configuration tests. WARNING: VERY EXPENSIVE" OFF "CATCH_DEVELOPMENT_BUILD" OFF)
-cmake_dependent_option(CATCH_ENABLE_CMAKE_HELPER_TESTS "Enable CMake helper tests. WARNING: VERY EXPENSIVE" OFF "CATCH_DEVELOPMENT_BUILD" OFF)
 
 
 # Catch2's build breaks if done in-tree. You probably should not build
@@ -32,7 +31,7 @@ if (CMAKE_BINARY_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
 endif()
 
 project(Catch2
-  VERSION 3.4.0 # CML version placeholder, don't delete
+  VERSION 3.3.2 # CML version placeholder, don't delete
   LANGUAGES CXX
   # HOMEPAGE_URL is not supported until CMake version 3.12, which
   # we do not target yet.

CMakePresets.json

@@ -18,8 +18,7 @@
                 "CATCH_BUILD_EXAMPLES": "ON",
                 "CATCH_BUILD_EXTRA_TESTS": "ON",
                 "CATCH_BUILD_SURROGATES": "ON",
-                "CATCH_ENABLE_CONFIGURE_TESTS": "ON",
-                "CATCH_ENABLE_CMAKE_HELPER_TESTS": "ON"
+                "CATCH_ENABLE_CONFIGURE_TESTS": "ON"
             }
         }
     ]   

WORKSPACE.bazel

@@ -4,10 +4,10 @@ load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 
 http_archive(
     name = "bazel_skylib",
-    sha256 = "66ffd9315665bfaafc96b52278f57c7e2dd09f5ede279ea6d39b2be471e7e3aa",
+    sha256 = "b8a1527901774180afc798aeb28c4634bdccf19c4d98e7bdd1ce79d1fe9aaad7",
     urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/bazel-skylib/releases/download/1.4.2/bazel-skylib-1.4.2.tar.gz",
-        "https://github.com/bazelbuild/bazel-skylib/releases/download/1.4.2/bazel-skylib-1.4.2.tar.gz",
+        "https://mirror.bazel.build/github.com/bazelbuild/bazel-skylib/releases/download/1.4.1/bazel-skylib-1.4.1.tar.gz",
+        "https://github.com/bazelbuild/bazel-skylib/releases/download/1.4.1/bazel-skylib-1.4.1.tar.gz",
     ],
 )
 

docs/cmake-integration.md

@@ -126,7 +126,6 @@ catch_discover_tests(target
                      [OUTPUT_DIR dir]
                      [OUTPUT_PREFIX prefix]
                      [OUTPUT_SUFFIX suffix]
-                     [DISCOVERY_MODE <POST_BUILD|PRE_TEST>]
 )
 ```
 
@@ -199,16 +198,6 @@ If specified, `suffix` is added to each output file name, like so
 `--out dir/<test_name>suffix`. This can be used to add a file extension to
 the output file name e.g. ".xml".
 
-* `DISCOVERY_MODE mode`
-
-If specified allows control over when test discovery is performed.
-For a value of `POST_BUILD` (default) test discovery is performed at build time.
-For a a value of `PRE_TEST` test discovery is delayed until just prior to test
-execution (useful e.g. in cross-compilation environments).
-``DISCOVERY_MODE`` defaults to the value of the
-``CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE`` variable if it is not passed when
-calling ``catch_discover_tests``. This provides a mechanism for globally
-selecting a preferred test discovery behavior.
 
 ### `ParseAndAddCatchTests.cmake`
 

docs/configuration.md

@@ -15,7 +15,6 @@
 [Enabling stringification](#enabling-stringification)<br>
 [Disabling exceptions](#disabling-exceptions)<br>
 [Overriding Catch's debug break (`-b`)](#overriding-catchs-debug-break--b)<br>
-[Static analysis support](#static-analysis-support)<br>
 
 Catch2 is designed to "just work" as much as possible, and most of the
 configuration options below are changed automatically during compilation,
@@ -265,31 +264,6 @@ The macro will be used as is, that is, `CATCH_BREAK_INTO_DEBUGGER();`
 must compile and must break into debugger.
 
 
-## Static analysis support
-
-> Introduced in Catch2 3.4.0.
-
-Some parts of Catch2, e.g. `SECTION`s, can be hard for static analysis
-tools to reason about. Catch2 can change its internals to help static
-analysis tools reason about the tests.
-
-Catch2 automatically detects some static analysis tools (initial
-implementation checks for clang-tidy and Coverity), but you can override
-its detection (in either direction) via
-
-```
-CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT     // force enables static analysis help
-CATCH_CONFIG_NO_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT  // force disables static analysis help
-```
-
-_As the name suggests, this is currently experimental, and thus we provide
-no backwards compatibility guarantees._
-
-**DO NOT ENABLE THIS FOR BUILDS YOU INTEND TO RUN.** The changed internals
-are not meant to be runnable, only "scannable".
-
-
-
 ---
 
 [Home](Readme.md#top)

docs/faq.md

@@ -28,7 +28,7 @@ depending on how often the cleanup needs to happen.
 ## Why cannot I derive from the built-in reporters?
 
 They are not made to be overridden, in that we do not attempt to maintain
-a consistent internal state if a member function is overridden, and by
+a consistent internal state if a member function is overriden, and by
 forbidding users from using them as a base class, we can refactor them
 as needed later.
 

docs/generators.md

@@ -134,7 +134,7 @@ type, making their usage much nicer. These are
 * `map<T>(func, GeneratorWrapper<U>&&)` for `MapGenerator<T, U, Func>` (map `U` to `T`)
 * `chunk(chunk-size, GeneratorWrapper<T>&&)` for `ChunkGenerator<T>`
 * `random(IntegerOrFloat a, IntegerOrFloat b)` for `RandomIntegerGenerator` or `RandomFloatGenerator`
-* `range(Arithmetic start, Arithmetic end)` for `RangeGenerator<Arithmetic>` with a step size of `1`
+* `range(Arithemtic start, Arithmetic end)` for `RangeGenerator<Arithmetic>` with a step size of `1`
 * `range(Arithmetic start, Arithmetic end, Arithmetic step)` for `RangeGenerator<Arithmetic>` with a custom step size
 * `from_range(InputIterator from, InputIterator to)` for `IteratorGenerator<T>`
 * `from_range(Container const&)` for `IteratorGenerator<T>`
@@ -221,21 +221,3 @@ For full example of implementing your own generator, look into Catch2's
 examples, specifically
 [Generators: Create your own generator](../examples/300-Gen-OwnGenerator.cpp).
 
-
-### Handling empty generators
-
-The generator interface assumes that a generator always has at least one
-element. This is not always true, e.g. if the generator depends on an external
-datafile, the file might be missing.
-
-There are two ways to handle this, depending on whether you want this
-to be an error or not.
-
- * If empty generator **is** an error, throw an exception in constructor.
- * If empty generator **is not** an error, use the [`SKIP`](skipping-passing-failing.md#skipping-test-cases-at-runtime) in constructor.
-
-
-
----
-
-[Home](Readme.md#top)

docs/opensource-users.md

@@ -95,9 +95,6 @@ A C++ client library for Consul. Consul is a distributed tool for discovering an
 ### [Reactive-Extensions/ RxCpp](https://github.com/Reactive-Extensions/RxCpp)
 A library of algorithms for values-distributed-in-time.
 
-### [SFML](https://github.com/SFML/SFML)
-Simple and Fast Multimedia Library.
-
 ### [SOCI](https://github.com/SOCI/soci)
 The C++ Database Access Library.
 
@@ -146,7 +143,7 @@ Newsbeuter is an open-source RSS/Atom feed reader for text terminals.
 A 2D, Zombie, RPG game which is being made on our own engine.
 
 ### [raspigcd](https://github.com/pantadeusz/raspigcd)
-Low level CLI app and library for execution of GCODE on Raspberry Pi without any additional microcontrollers (just RPi + Stepsticks).
+Low level CLI app and library for execution of GCODE on Raspberry Pi without any additional microcontrolers (just RPi + Stepsticks).
 
 ### [SpECTRE](https://github.com/sxs-collaboration/spectre)
 SpECTRE is a code for multi-scale, multi-physics problems in astrophysics and gravitational physics.

docs/release-notes.md

@@ -57,34 +57,6 @@
 
 
 
-## 3.4.0
-
-### Improvements
-* `VectorEquals` supports elements that provide only `==` and not `!=` (#2648)
-* Catch2 supports compiling with IAR compiler (#2651)
-* Various small internal performance improvements
-* Various small internal compilation time improvements
-* XMLReporter now reports location info for INFO and WARN (#1251)
-  * This bumps up the xml format version to 3
-* Documented that `SKIP` in generator constructor can be used to handle empty  generator (#1593)
-* Added experimental static analysis support to `TEST_CASE` and `SECTION` macros (#2681)
-  * The two macros are redefined in a way that helps the SA tools reason about the possible paths through a test case with sections.
-  * The support is controlled by the `CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT` option and autodetects clang-tidy and Coverity.
-* `*_THROWS`, `*_THROWS_AS`, etc now suppress warning coming from `__attribute__((warn_unused_result))` on GCC  (#2691)
-  * Unlike plain `[[nodiscard]]`, this warning is not silenced by void cast. WTF GCC?
-
-### Fixes
-* Fixed `assertionStarting` events being sent after the expr is evaluated (#2678)
-* Errors in `TEST_CASE` tags are now reported nicely (#2650)
-
-### Miscellaneous
-* Bunch of improvements to `catch_discover_tests`
-  * Added DISCOVERY_MODE option, so the discovery can happen either post build or pre-run.
-  * Fixed handling of semicolons and backslashes in test names (#2674, #2676)
-* meson build can disable building tests (#2693)
-* meson build properly sets meson version 0.54.1 as the minimal supported version (#2688)
-
-
 ## 3.3.2
 
 ### Improvements
@@ -177,7 +149,7 @@
 
 ### Fixes
 * Cleaned out some warnings and static analysis issues
-  * Suppressed `-Wcomma` warning rarely occurring in templated test cases (#2543)
+  * Suppressed `-Wcomma` warning rarely occuring in templated test cases (#2543)
   * Constified implementation details in `INFO` (#2564)
   * Made `MatcherGenericBase` copy constructor const (#2566)
 * Fixed serialization of test filters so the output roundtrips
@@ -545,7 +517,7 @@ v3 releases.
   * The `SECTION`(s) before the `GENERATE` will not be run multiple times, the following ones will.
 * Added `-D`/`--min-duration` command line flag (#1910)
   * If a test takes longer to finish than the provided value, its name and duration will be printed.
-  * This flag is overridden by setting `-d`/`--duration`.
+  * This flag is overriden by setting `-d`/`--duration`.
 
 ### Fixes
 * `TAPReporter` no longer skips successful assertions (#1983)
@@ -613,7 +585,7 @@ v3 releases.
 ### Fixes
 * Fixed computation of benchmarking column widths in ConsoleReporter (#1885, #1886)
 * Suppressed clang-tidy's `cppcoreguidelines-pro-type-vararg` in assertions (#1901)
-  * It was a false positive triggered by the new warning support workaround
+  * It was a false positive trigered by the new warning support workaround
 * Fixed bug in test specification parser handling of OR'd patterns using escaping (#1905)
 
 ### Miscellaneous
@@ -950,7 +922,7 @@ v3 releases.
 
 ### Contrib
 * `ParseAndAddCatchTests` has learned how to use `DISABLED` CTest property (#1452)
-* `ParseAndAddCatchTests` now works when there is a whitespace before the test name (#1493)
+* `ParseAndAddCatchTests` now works when there is a whitspace before the test name (#1493)
 
 
 ### Miscellaneous

docs/reporter-events.md

@@ -96,12 +96,12 @@ void assertionStarting( AssertionInfo const& assertionInfo );
 void assertionEnded( AssertionStats const& assertionStats );
 ```
 
-The `assertionStarting` event is emitted before the expression in the
-assertion is captured or evaluated and `assertionEnded` is emitted
-afterwards. This means that given assertion like `REQUIRE(a + b == c + d)`,
-Catch2 first emits `assertionStarting` event, then `a + b` and `c + d`
-are evaluated, then their results are captured, the comparison is evaluated,
-and then `assertionEnded` event is emitted.
+`assertionStarting` is called after the expression is captured, but before
+the assertion expression is evaluated. This might seem like a minor
+distinction, but what it means is that if you have assertion like
+`REQUIRE( a + b == c + d )`, then what happens is that `a + b` and `c + d`
+are evaluated before `assertionStarting` is emitted, while the `==` is
+evaluated after the event.
 
 
 ## Benchmarking events

docs/reporters.md

@@ -52,7 +52,7 @@ its machine-readable XML output to file `result-junit.xml`, and the
 uses ANSI colour codes for colouring the output.
 
 Using multiple reporters (or one reporter and one-or-more [event
-listeners](event-listeners.md#top)) can have surprisingly complex semantics
+listeners](event-listener.md#top)) can have surprisingly complex semantics
 when using customization points provided to reporters by Catch2, namely
 capturing stdout/stderr from test cases.
 

docs/skipping-passing-failing.md

@@ -84,12 +84,6 @@ exit code, same as it does if no test cases have run. This behaviour can
 be overridden using the [--allow-running-no-tests](command-line.md#no-tests-override)
 flag.
 
-### `SKIP` inside generators
-
-You can also use the `SKIP` macro inside generator's constructor to handle
-cases where the generator is empty, but you do not want to fail the test
-case.
-
 
 ## Passing and failing test cases
 

examples/302-Gen-Table.cpp

@@ -44,11 +44,11 @@ TEST_CASE("Table allows pre-computed test inputs and outputs", "[example][genera
 
 /* Possible simplifications where less legacy toolchain support is needed:
  *
- * - With libstdc++6 or newer, the make_tuple() calls can be omitted
+ * - With libstdc++6 or newer, the make_tuple() calls can be ommitted
  * (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
+ * - In C++17 mode std::tie() and the preceding variable delcarations can be
  * replaced by structured bindings: auto [test_input, expected] = GENERATE(
  * table<std::string, size_t>({ ...
  */

extras/Catch.cmake

@@ -35,9 +35,8 @@ same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
                          [TEST_LIST var]
                          [REPORTER reporter]
                          [OUTPUT_DIR dir]
-                         [OUTPUT_PREFIX prefix]
+                         [OUTPUT_PREFIX prefix}
                          [OUTPUT_SUFFIX suffix]
-                         [DISCOVERY_MODE <POST_BUILD|PRE_TEST>]
     )
 
   ``catch_discover_tests`` sets up a post-build command on the test executable
@@ -124,28 +123,14 @@ same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
     test executable and when the tests are executed themselves. This requires
     cmake/ctest >= 3.22.
 
-  `DISCOVERY_MODE mode``
-    Provides control over when ``catch_discover_tests`` performs test discovery.
-    By default, ``POST_BUILD`` sets up a post-build command to perform test discovery
-    at build time. In certain scenarios, like cross-compiling, this ``POST_BUILD``
-    behavior is not desirable. By contrast, ``PRE_TEST`` delays test discovery until
-    just prior to test execution. This way test discovery occurs in the target environment
-    where the test has a better chance at finding appropriate runtime dependencies.
-
-    ``DISCOVERY_MODE`` defaults to the value of the
-    ``CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE`` variable if it is not passed when
-    calling ``catch_discover_tests``. This provides a mechanism for globally selecting
-    a preferred test discovery behavior without having to modify each call site.
-
 #]=======================================================================]
 
 #------------------------------------------------------------------------------
 function(catch_discover_tests TARGET)
-
   cmake_parse_arguments(
     ""
     ""
-    "TEST_PREFIX;TEST_SUFFIX;WORKING_DIRECTORY;TEST_LIST;REPORTER;OUTPUT_DIR;OUTPUT_PREFIX;OUTPUT_SUFFIX;DISCOVERY_MODE"
+    "TEST_PREFIX;TEST_SUFFIX;WORKING_DIRECTORY;TEST_LIST;REPORTER;OUTPUT_DIR;OUTPUT_PREFIX;OUTPUT_SUFFIX"
     "TEST_SPEC;EXTRA_ARGS;PROPERTIES;DL_PATHS"
     ${ARGN}
   )
@@ -156,20 +141,12 @@ function(catch_discover_tests TARGET)
   if(NOT _TEST_LIST)
     set(_TEST_LIST ${TARGET}_TESTS)
   endif()
+
   if (_DL_PATHS)
     if(${CMAKE_VERSION} VERSION_LESS "3.22.0")
         message(FATAL_ERROR "The DL_PATHS option requires at least cmake 3.22")
     endif()
   endif()
-  if(NOT _DISCOVERY_MODE)
-    if(NOT CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE)
-      set(CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE "POST_BUILD")
-    endif()
-    set(_DISCOVERY_MODE ${CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE})
-  endif()
-  if (NOT _DISCOVERY_MODE MATCHES "^(POST_BUILD|PRE_TEST)$")
-    message(FATAL_ERROR "Unknown DISCOVERY_MODE: ${_DISCOVERY_MODE}")
-  endif()
 
   ## Generate a unique name based on the extra arguments
   string(SHA1 args_hash "${_TEST_SPEC} ${_EXTRA_ARGS} ${_REPORTER} ${_OUTPUT_DIR} ${_OUTPUT_PREFIX} ${_OUTPUT_SUFFIX}")
@@ -182,77 +159,39 @@ function(catch_discover_tests TARGET)
     TARGET ${TARGET}
     PROPERTY CROSSCOMPILING_EMULATOR
   )
+  add_custom_command(
+    TARGET ${TARGET} POST_BUILD
+    BYPRODUCTS "${ctest_tests_file}"
+    COMMAND "${CMAKE_COMMAND}"
+            -D "TEST_TARGET=${TARGET}"
+            -D "TEST_EXECUTABLE=$<TARGET_FILE:${TARGET}>"
+            -D "TEST_EXECUTOR=${crosscompiling_emulator}"
+            -D "TEST_WORKING_DIR=${_WORKING_DIRECTORY}"
+            -D "TEST_SPEC=${_TEST_SPEC}"
+            -D "TEST_EXTRA_ARGS=${_EXTRA_ARGS}"
+            -D "TEST_PROPERTIES=${_PROPERTIES}"
+            -D "TEST_PREFIX=${_TEST_PREFIX}"
+            -D "TEST_SUFFIX=${_TEST_SUFFIX}"
+            -D "TEST_LIST=${_TEST_LIST}"
+            -D "TEST_REPORTER=${_REPORTER}"
+            -D "TEST_OUTPUT_DIR=${_OUTPUT_DIR}"
+            -D "TEST_OUTPUT_PREFIX=${_OUTPUT_PREFIX}"
+            -D "TEST_OUTPUT_SUFFIX=${_OUTPUT_SUFFIX}"
+            -D "TEST_DL_PATHS=${_DL_PATHS}"
+            -D "CTEST_FILE=${ctest_tests_file}"
+            -P "${_CATCH_DISCOVER_TESTS_SCRIPT}"
+    VERBATIM
+  )
 
-  if(_DISCOVERY_MODE STREQUAL "POST_BUILD")
-    add_custom_command(
-      TARGET ${TARGET} POST_BUILD
-      BYPRODUCTS "${ctest_tests_file}"
-      COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_TARGET=${TARGET}"
-              -D "TEST_EXECUTABLE=$<TARGET_FILE:${TARGET}>"
-              -D "TEST_EXECUTOR=${crosscompiling_emulator}"
-              -D "TEST_WORKING_DIR=${_WORKING_DIRECTORY}"
-              -D "TEST_SPEC=${_TEST_SPEC}"
-              -D "TEST_EXTRA_ARGS=${_EXTRA_ARGS}"
-              -D "TEST_PROPERTIES=${_PROPERTIES}"
-              -D "TEST_PREFIX=${_TEST_PREFIX}"
-              -D "TEST_SUFFIX=${_TEST_SUFFIX}"
-              -D "TEST_LIST=${_TEST_LIST}"
-              -D "TEST_REPORTER=${_REPORTER}"
-              -D "TEST_OUTPUT_DIR=${_OUTPUT_DIR}"
-              -D "TEST_OUTPUT_PREFIX=${_OUTPUT_PREFIX}"
-              -D "TEST_OUTPUT_SUFFIX=${_OUTPUT_SUFFIX}"
-              -D "TEST_DL_PATHS=${_DL_PATHS}"
-              -D "CTEST_FILE=${ctest_tests_file}"
-              -P "${_CATCH_DISCOVER_TESTS_SCRIPT}"
-      VERBATIM
-    )
+  file(WRITE "${ctest_include_file}"
+    "if(EXISTS \"${ctest_tests_file}\")\n"
+    "  include(\"${ctest_tests_file}\")\n"
+    "else()\n"
+    "  add_test(${TARGET}_NOT_BUILT-${args_hash} ${TARGET}_NOT_BUILT-${args_hash})\n"
+    "endif()\n"
+  )
 
-    file(WRITE "${ctest_include_file}"
-      "if(EXISTS \"${ctest_tests_file}\")\n"
-      "  include(\"${ctest_tests_file}\")\n"
-      "else()\n"
-      "  add_test(${TARGET}_NOT_BUILT-${args_hash} ${TARGET}_NOT_BUILT-${args_hash})\n"
-      "endif()\n"
-    )
-
-  elseif(_DISCOVERY_MODE STREQUAL "PRE_TEST")
-
-    string(CONCAT ctest_include_content
-      "if(EXISTS \"$<TARGET_FILE:${TARGET}>\")"                                    "\n"
-      "  if(NOT EXISTS \"${ctest_tests_file}\" OR"                                 "\n"
-      "     NOT \"${ctest_tests_file}\" IS_NEWER_THAN \"$<TARGET_FILE:${TARGET}>\" OR\n"
-      "     NOT \"${ctest_tests_file}\" IS_NEWER_THAN \"\${CMAKE_CURRENT_LIST_FILE}\")\n"
-      "    include(\"${_CATCH_DISCOVER_TESTS_SCRIPT}\")"                           "\n"
-      "    catch_discover_tests_impl("                                             "\n"
-      "      TEST_EXECUTABLE"        " [==[" "$<TARGET_FILE:${TARGET}>"   "]==]"   "\n"
-      "      TEST_EXECUTOR"          " [==[" "${crosscompiling_emulator}" "]==]"   "\n"
-      "      TEST_WORKING_DIR"       " [==[" "${_WORKING_DIRECTORY}"      "]==]"   "\n"
-      "      TEST_SPEC"              " [==[" "${_TEST_SPEC}"              "]==]"   "\n"
-      "      TEST_EXTRA_ARGS"        " [==[" "${_EXTRA_ARGS}"             "]==]"   "\n"
-      "      TEST_PROPERTIES"        " [==[" "${_PROPERTIES}"             "]==]"   "\n"
-      "      TEST_PREFIX"            " [==[" "${_TEST_PREFIX}"            "]==]"   "\n"
-      "      TEST_SUFFIX"            " [==[" "${_TEST_SUFFIX}"            "]==]"   "\n"
-      "      TEST_LIST"              " [==[" "${_TEST_LIST}"              "]==]"   "\n"
-      "      TEST_REPORTER"          " [==[" "${_REPORTER}"               "]==]"   "\n"
-      "      TEST_OUTPUT_DIR"        " [==[" "${_OUTPUT_DIR}"             "]==]"   "\n"
-      "      TEST_OUTPUT_PREFIX"     " [==[" "${_OUTPUT_PREFIX}"          "]==]"   "\n"
-      "      TEST_OUTPUT_SUFFIX"     " [==[" "${_OUTPUT_SUFFIX}"          "]==]"   "\n"
-      "      CTEST_FILE"             " [==[" "${ctest_tests_file}"        "]==]"   "\n"
-      "      TEST_DL_PATHS"          " [==[" "${_DL_PATHS}"               "]==]"   "\n"
-      "      CTEST_FILE"             " [==[" "${CTEST_FILE}"              "]==]"   "\n"
-      "    )"                                                                      "\n"
-      "  endif()"                                                                  "\n"
-      "  include(\"${ctest_tests_file}\")"                                         "\n"
-      "else()"                                                                     "\n"
-      "  add_test(${TARGET}_NOT_BUILT ${TARGET}_NOT_BUILT)"                        "\n"
-      "endif()"                                                                    "\n"
-    )
-
-    file(GENERATE OUTPUT "${ctest_include_file}" CONTENT "${ctest_include_content}")
-  endif()
-
-  if(NOT ${CMAKE_VERSION} VERSION_LESS "3.10.0")
+  if(NOT ${CMAKE_VERSION} VERSION_LESS "3.10.0") 
     # Add discovered tests to directory TEST_INCLUDE_FILES
     set_property(DIRECTORY
       APPEND PROPERTY TEST_INCLUDE_FILES "${ctest_include_file}"
@@ -265,7 +204,9 @@ function(catch_discover_tests TARGET)
         PROPERTY TEST_INCLUDE_FILE "${ctest_include_file}"
       )
     else()
-      message(FATAL_ERROR "Cannot set more than one TEST_INCLUDE_FILE")
+      message(FATAL_ERROR
+        "Cannot set more than one TEST_INCLUDE_FILE"
+      )
     endif()
   endif()
 

extras/CatchAddTests.cmake

@@ -1,6 +1,28 @@
 # Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
 # file Copyright.txt or https://cmake.org/licensing for details.
 
+set(prefix "${TEST_PREFIX}")
+set(suffix "${TEST_SUFFIX}")
+set(spec ${TEST_SPEC})
+set(extra_args ${TEST_EXTRA_ARGS})
+set(properties ${TEST_PROPERTIES})
+set(reporter ${TEST_REPORTER})
+set(output_dir ${TEST_OUTPUT_DIR})
+set(output_prefix ${TEST_OUTPUT_PREFIX})
+set(output_suffix ${TEST_OUTPUT_SUFFIX})
+set(dl_paths ${TEST_DL_PATHS})
+set(script)
+set(suite)
+set(tests)
+
+if(WIN32)
+  set(dl_paths_variable_name PATH)
+elseif(APPLE)
+  set(dl_paths_variable_name DYLD_LIBRARY_PATH)
+else()
+  set(dl_paths_variable_name LD_LIBRARY_PATH)
+endif()
+
 function(add_command NAME)
   set(_args "")
   # use ARGV* instead of ARGN, because ARGN splits arrays into multiple arguments
@@ -16,177 +38,119 @@ function(add_command NAME)
   set(script "${script}${NAME}(${_args})\n" PARENT_SCOPE)
 endfunction()
 
-function(catch_discover_tests_impl)
-
-  cmake_parse_arguments(
-    ""
-    ""
-    "TEST_EXECUTABLE;TEST_WORKING_DIR;TEST_DL_PATHS;TEST_OUTPUT_DIR;TEST_OUTPUT_PREFIX;TEST_OUTPUT_SUFFIX;TEST_PREFIX;TEST_REPORTER;TEST_SPEC;TEST_SUFFIX;TEST_LIST;CTEST_FILE"
-    "TEST_EXTRA_ARGS;TEST_PROPERTIES;TEST_EXECUTOR"
-    ${ARGN}
-  )
-
-  set(prefix "${_TEST_PREFIX}")
-  set(suffix "${_TEST_SUFFIX}")
-  set(spec ${_TEST_SPEC})
-  set(extra_args ${_TEST_EXTRA_ARGS})
-  set(properties ${_TEST_PROPERTIES})
-  set(reporter ${_TEST_REPORTER})
-  set(output_dir ${_TEST_OUTPUT_DIR})
-  set(output_prefix ${_TEST_OUTPUT_PREFIX})
-  set(output_suffix ${_TEST_OUTPUT_SUFFIX})
-  set(dl_paths ${_TEST_DL_PATHS})
-  set(script)
-  set(suite)
-  set(tests)
-
-  if(WIN32)
-    set(dl_paths_variable_name PATH)
-  elseif(APPLE)
-    set(dl_paths_variable_name DYLD_LIBRARY_PATH)
-  else()
-    set(dl_paths_variable_name LD_LIBRARY_PATH)
-  endif()
-
-  # Run test executable to get list of available tests
-  if(NOT EXISTS "${_TEST_EXECUTABLE}")
-    message(FATAL_ERROR
-      "Specified test executable '${_TEST_EXECUTABLE}' does not exist"
-    )
-  endif()
-
-  if(dl_paths)
-    cmake_path(CONVERT "${dl_paths}" TO_NATIVE_PATH_LIST paths)
-    set(ENV{${dl_paths_variable_name}} "${paths}")
-  endif()
-
-  execute_process(
-    COMMAND ${_TEST_EXECUTOR} "${_TEST_EXECUTABLE}" ${spec} --list-tests --verbosity quiet
-    OUTPUT_VARIABLE output
-    RESULT_VARIABLE result
-    WORKING_DIRECTORY "${_TEST_WORKING_DIR}"
-  )
-  if(NOT ${result} EQUAL 0)
-    message(FATAL_ERROR
-      "Error running test executable '${_TEST_EXECUTABLE}':\n"
-      "  Result: ${result}\n"
-      "  Output: ${output}\n"
-    )
-  endif()
-
-  # Make sure to escape ; (semicolons) in test names first, because
-  # that'd break the foreach loop for "Parse output" later and create
-  # wrongly splitted and thus failing test cases (false positives)
-  string(REPLACE ";" "\;" output "${output}")
-  string(REPLACE "\n" ";" output "${output}")
-
-  # Prepare reporter
-  if(reporter)
-    set(reporter_arg "--reporter ${reporter}")
-
-    # Run test executable to check whether reporter is available
-    # note that the use of --list-reporters is not the important part,
-    # we only want to check whether the execution succeeds with ${reporter_arg}
-    execute_process(
-      COMMAND ${TEST_EXECUTOR} "${TEST_EXECUTABLE}" ${spec} ${reporter_arg} --list-reporters
-      OUTPUT_VARIABLE reporter_check_output
-      RESULT_VARIABLE reporter_check_result
-      WORKING_DIRECTORY "${TEST_WORKING_DIR}"
-    )
-    if(${reporter_check_result} EQUAL 255)
-      message(FATAL_ERROR
-        "\"${reporter}\" is not a valid reporter!\n"
-      )
-    elseif(NOT ${reporter_check_result} EQUAL 0)
-      message(FATAL_ERROR
-        "Error running test executable '${TEST_EXECUTABLE}':\n"
-        "  Result: ${reporter_check_result}\n"
-        "  Output: ${reporter_check_output}\n"
-      )
-    endif()
-  endif()
-
-  # Prepare output dir
-  if(output_dir AND NOT IS_ABSOLUTE ${output_dir})
-    set(output_dir "${_TEST_WORKING_DIR}/${output_dir}")
-    if(NOT EXISTS ${output_dir})
-      file(MAKE_DIRECTORY ${output_dir})
-    endif()
-  endif()
-
-  if(dl_paths)
-    foreach(path ${dl_paths})
-      cmake_path(NATIVE_PATH path native_path)
-      list(APPEND environment_modifications "${dl_paths_variable_name}=path_list_prepend:${native_path}")
-    endforeach()
-  endif()
-
-  # Parse output
-  foreach(line ${output})
-    set(test "${line}")
-    # Escape characters in test case names that would be parsed by Catch2
-    # Note that the \ escaping must happen FIRST! Do not change the order.
-    set(test_name "${test}")
-    foreach(char \\ , [ ])
-      string(REPLACE ${char} "\\${char}" test_name "${test_name}")
-    endforeach(char)
-    # ...add output dir
-    if(output_dir)
-      string(REGEX REPLACE "[^A-Za-z0-9_]" "_" test_name_clean "${test_name}")
-      set(output_dir_arg "--out ${output_dir}/${output_prefix}${test_name_clean}${output_suffix}")
-    endif()
-
-    # ...and add to script
-    add_command(add_test
-      "${prefix}${test}${suffix}"
-      ${_TEST_EXECUTOR}
-      "${_TEST_EXECUTABLE}"
-      "${test_name}"
-      ${extra_args}
-      "${reporter_arg}"
-      "${output_dir_arg}"
-    )
-    add_command(set_tests_properties
-      "${prefix}${test}${suffix}"
-      PROPERTIES
-      WORKING_DIRECTORY "${_TEST_WORKING_DIR}"
-      ${properties}
-    )
-
-    if(environment_modifications)
-      add_command(set_tests_properties
-        "${prefix}${test}${suffix}"
-        PROPERTIES
-        ENVIRONMENT_MODIFICATION "${environment_modifications}")
-    endif()
-
-    list(APPEND tests "${prefix}${test}${suffix}")
-  endforeach()
-
-  # Create a list of all discovered tests, which users may use to e.g. set
-  # properties on the tests
-  add_command(set ${_TEST_LIST} ${tests})
-
-  # Write CTest script
-  file(WRITE "${_CTEST_FILE}" "${script}")
-endfunction()
-
-if(CMAKE_SCRIPT_MODE_FILE)
-  catch_discover_tests_impl(
-    TEST_EXECUTABLE ${TEST_EXECUTABLE}
-    TEST_EXECUTOR ${TEST_EXECUTOR}
-    TEST_WORKING_DIR ${TEST_WORKING_DIR}
-    TEST_SPEC ${TEST_SPEC}
-    TEST_EXTRA_ARGS ${TEST_EXTRA_ARGS}
-    TEST_PROPERTIES ${TEST_PROPERTIES}
-    TEST_PREFIX ${TEST_PREFIX}
-    TEST_SUFFIX ${TEST_SUFFIX}
-    TEST_LIST ${TEST_LIST}
-    TEST_REPORTER ${TEST_REPORTER}
-    TEST_OUTPUT_DIR ${TEST_OUTPUT_DIR}
-    TEST_OUTPUT_PREFIX ${TEST_OUTPUT_PREFIX}
-    TEST_OUTPUT_SUFFIX ${TEST_OUTPUT_SUFFIX}
-    TEST_DL_PATHS ${TEST_DL_PATHS}
-    CTEST_FILE ${CTEST_FILE}
+# Run test executable to get list of available tests
+if(NOT EXISTS "${TEST_EXECUTABLE}")
+  message(FATAL_ERROR
+    "Specified test executable '${TEST_EXECUTABLE}' does not exist"
   )
 endif()
+
+if(dl_paths)
+  cmake_path(CONVERT "${dl_paths}" TO_NATIVE_PATH_LIST paths)
+  set(ENV{${dl_paths_variable_name}} "${paths}")
+endif()
+
+execute_process(
+  COMMAND ${TEST_EXECUTOR} "${TEST_EXECUTABLE}" ${spec} --list-tests --verbosity quiet
+  OUTPUT_VARIABLE output
+  RESULT_VARIABLE result
+  WORKING_DIRECTORY "${TEST_WORKING_DIR}"
+)
+if(NOT ${result} EQUAL 0)
+  message(FATAL_ERROR
+    "Error running test executable '${TEST_EXECUTABLE}':\n"
+    "  Result: ${result}\n"
+    "  Output: ${output}\n"
+  )
+endif()
+
+string(REPLACE "\n" ";" output "${output}")
+
+# Run test executable to get list of available reporters
+execute_process(
+  COMMAND ${TEST_EXECUTOR} "${TEST_EXECUTABLE}" ${spec} --list-reporters
+  OUTPUT_VARIABLE reporters_output
+  RESULT_VARIABLE reporters_result
+  WORKING_DIRECTORY "${TEST_WORKING_DIR}"
+)
+if(NOT ${reporters_result} EQUAL 0)
+  message(FATAL_ERROR
+    "Error running test executable '${TEST_EXECUTABLE}':\n"
+    "  Result: ${reporters_result}\n"
+    "  Output: ${reporters_output}\n"
+  )
+endif()
+string(FIND "${reporters_output}" "${reporter}" reporter_is_valid)
+if(reporter AND ${reporter_is_valid} EQUAL -1)
+  message(FATAL_ERROR
+    "\"${reporter}\" is not a valid reporter!\n"
+  )
+endif()
+
+# Prepare reporter
+if(reporter)
+  set(reporter_arg "--reporter ${reporter}")
+endif()
+
+# Prepare output dir
+if(output_dir AND NOT IS_ABSOLUTE ${output_dir})
+  set(output_dir "${TEST_WORKING_DIR}/${output_dir}")
+  if(NOT EXISTS ${output_dir})
+    file(MAKE_DIRECTORY ${output_dir})
+  endif()
+endif()
+
+if(dl_paths)
+  foreach(path ${dl_paths})
+    cmake_path(NATIVE_PATH path native_path)
+    list(APPEND environment_modifications "${dl_paths_variable_name}=path_list_prepend:${native_path}")
+  endforeach()
+endif()
+
+# Parse output
+foreach(line ${output})
+  set(test ${line})
+  # Escape characters in test case names that would be parsed by Catch2
+  set(test_name ${test})
+  foreach(char , [ ])
+    string(REPLACE ${char} "\\${char}" test_name ${test_name})
+  endforeach(char)
+  # ...add output dir
+  if(output_dir)
+    string(REGEX REPLACE "[^A-Za-z0-9_]" "_" test_name_clean ${test_name})
+    set(output_dir_arg "--out ${output_dir}/${output_prefix}${test_name_clean}${output_suffix}")
+  endif()
+  
+  # ...and add to script
+  add_command(add_test
+    "${prefix}${test}${suffix}"
+    ${TEST_EXECUTOR}
+    "${TEST_EXECUTABLE}"
+    "${test_name}"
+    ${extra_args}
+    "${reporter_arg}"
+    "${output_dir_arg}"
+  )
+  add_command(set_tests_properties
+    "${prefix}${test}${suffix}"
+    PROPERTIES
+    WORKING_DIRECTORY "${TEST_WORKING_DIR}"
+    ${properties}
+  )
+
+   if(environment_modifications)
+     add_command(set_tests_properties
+       "${prefix}${test}${suffix}"
+       PROPERTIES
+       ENVIRONMENT_MODIFICATION "${environment_modifications}")
+   endif()
+
+  list(APPEND tests "${prefix}${test}${suffix}")
+endforeach()
+
+# Create a list of all discovered tests, which users may use to e.g. set
+# properties on the tests
+add_command(set ${TEST_LIST} ${tests})
+
+# Write CTest script
+file(WRITE "${CTEST_FILE}" "${script}")

meson.build

@@ -8,12 +8,10 @@
 project(
   'catch2',
   'cpp',
-  version: '3.4.0', # CML version placeholder, don't delete
+  version: '3.3.2', # CML version placeholder, don't delete
   license: 'BSL-1.0',
-  meson_version: '>=0.54.1',
+  meson_version: '>=0.50.0',
 )
 
 subdir('src/catch2')
-if get_option('tests')
-  subdir('tests')
-endif
+subdir('tests')

meson_options.txt

@@ -1 +0,0 @@
-option('tests', type: 'boolean', value: true, description: 'Build the unit tests')

src/CMakeLists.txt

@@ -21,8 +21,6 @@ set(BENCHMARK_HEADERS
   ${SOURCES_DIR}/benchmark/catch_sample_analysis.hpp
   ${SOURCES_DIR}/benchmark/detail/catch_analyse.hpp
   ${SOURCES_DIR}/benchmark/detail/catch_benchmark_function.hpp
-  ${SOURCES_DIR}/benchmark/detail/catch_benchmark_stats.hpp
-  ${SOURCES_DIR}/benchmark/detail/catch_benchmark_stats_fwd.hpp
   ${SOURCES_DIR}/benchmark/detail/catch_complete_invoke.hpp
   ${SOURCES_DIR}/benchmark/detail/catch_estimate_clock.hpp
   ${SOURCES_DIR}/benchmark/detail/catch_measure.hpp
@@ -57,6 +55,7 @@ set(IMPL_HEADERS
   ${SOURCES_DIR}/catch_template_test_macros.hpp
   ${SOURCES_DIR}/catch_test_case_info.hpp
   ${SOURCES_DIR}/catch_test_macros.hpp
+  ${SOURCES_DIR}/catch_test_run_info.hpp
   ${SOURCES_DIR}/catch_test_spec.hpp
   ${SOURCES_DIR}/catch_timer.hpp
   ${SOURCES_DIR}/catch_tostring.hpp
@@ -65,6 +64,7 @@ set(IMPL_HEADERS
   ${SOURCES_DIR}/catch_version.hpp
   ${SOURCES_DIR}/catch_version_macros.hpp
   ${SOURCES_DIR}/internal/catch_assertion_handler.hpp
+  ${SOURCES_DIR}/internal/catch_benchmark_stats_fwd.hpp
   ${SOURCES_DIR}/internal/catch_case_insensitive_comparisons.hpp
   ${SOURCES_DIR}/internal/catch_case_sensitive.hpp
   ${SOURCES_DIR}/internal/catch_clara.hpp
@@ -73,7 +73,6 @@ set(IMPL_HEADERS
   ${SOURCES_DIR}/internal/catch_compiler_capabilities.hpp
   ${SOURCES_DIR}/internal/catch_config_android_logwrite.hpp
   ${SOURCES_DIR}/internal/catch_config_counter.hpp
-  ${SOURCES_DIR}/internal/catch_config_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
@@ -109,6 +108,7 @@ set(IMPL_HEADERS
   ${SOURCES_DIR}/internal/catch_preprocessor_remove_parens.hpp
   ${SOURCES_DIR}/internal/catch_random_number_generator.hpp
   ${SOURCES_DIR}/internal/catch_random_seed_generation.hpp
+  ${SOURCES_DIR}/internal/catch_registry_hub.hpp
   ${SOURCES_DIR}/internal/catch_reporter_registry.hpp
   ${SOURCES_DIR}/internal/catch_reporter_spec_parser.hpp
   ${SOURCES_DIR}/internal/catch_result_type.hpp
@@ -131,7 +131,6 @@ set(IMPL_HEADERS
   ${SOURCES_DIR}/internal/catch_test_failure_exception.hpp
   ${SOURCES_DIR}/internal/catch_test_macro_impl.hpp
   ${SOURCES_DIR}/internal/catch_test_registry.hpp
-  ${SOURCES_DIR}/internal/catch_test_run_info.hpp
   ${SOURCES_DIR}/internal/catch_test_spec_parser.hpp
   ${SOURCES_DIR}/internal/catch_textflow.hpp
   ${SOURCES_DIR}/internal/catch_to_string.hpp
@@ -149,7 +148,6 @@ set(IMPL_SOURCES
   ${SOURCES_DIR}/catch_config.cpp
   ${SOURCES_DIR}/catch_get_random_seed.cpp
   ${SOURCES_DIR}/catch_message.cpp
-  ${SOURCES_DIR}/catch_registry_hub.cpp
   ${SOURCES_DIR}/catch_session.cpp
   ${SOURCES_DIR}/catch_tag_alias_autoregistrar.cpp
   ${SOURCES_DIR}/catch_test_case_info.cpp
@@ -185,6 +183,7 @@ set(IMPL_SOURCES
   ${SOURCES_DIR}/internal/catch_polyfills.cpp
   ${SOURCES_DIR}/internal/catch_random_number_generator.cpp
   ${SOURCES_DIR}/internal/catch_random_seed_generation.cpp
+  ${SOURCES_DIR}/internal/catch_registry_hub.cpp
   ${SOURCES_DIR}/internal/catch_reporter_registry.cpp
   ${SOURCES_DIR}/internal/catch_reporter_spec_parser.cpp
   ${SOURCES_DIR}/internal/catch_result_type.cpp
@@ -213,24 +212,17 @@ set(INTERNAL_FILES ${IMPL_SOURCES} ${IMPL_HEADERS})
 
 set(INTERFACE_HEADERS
   ${SOURCES_DIR}/interfaces/catch_interfaces_all.hpp
-  ${SOURCES_DIR}/interfaces/catch_interfaces_capture.hpp
   ${SOURCES_DIR}/interfaces/catch_interfaces_config.hpp
-  ${SOURCES_DIR}/interfaces/catch_interfaces_enum_values_registry.hpp
   ${SOURCES_DIR}/interfaces/catch_interfaces_exception.hpp
   ${SOURCES_DIR}/interfaces/catch_interfaces_generatortracker.hpp
-  ${SOURCES_DIR}/interfaces/catch_interfaces_registry_hub.hpp
   ${SOURCES_DIR}/interfaces/catch_interfaces_reporter.hpp
   ${SOURCES_DIR}/interfaces/catch_interfaces_reporter_factory.hpp
-  ${SOURCES_DIR}/interfaces/catch_interfaces_tag_alias_registry.hpp
-  ${SOURCES_DIR}/interfaces/catch_interfaces_test_invoker.hpp
   ${SOURCES_DIR}/interfaces/catch_interfaces_testcase.hpp
 )
 set(INTERFACE_SOURCES
-  ${SOURCES_DIR}/interfaces/catch_interfaces_capture.cpp
   ${SOURCES_DIR}/interfaces/catch_interfaces_config.cpp
   ${SOURCES_DIR}/interfaces/catch_interfaces_exception.cpp
   ${SOURCES_DIR}/interfaces/catch_interfaces_generatortracker.cpp
-  ${SOURCES_DIR}/interfaces/catch_interfaces_registry_hub.cpp
   ${SOURCES_DIR}/interfaces/catch_interfaces_reporter.cpp
   ${SOURCES_DIR}/interfaces/catch_interfaces_reporter_factory.cpp
   ${SOURCES_DIR}/interfaces/catch_interfaces_testcase.cpp

src/catch2/benchmark/catch_benchmark.hpp

@@ -10,27 +10,26 @@
 #ifndef CATCH_BENCHMARK_HPP_INCLUDED
 #define CATCH_BENCHMARK_HPP_INCLUDED
 
-#include <catch2/catch_user_config.hpp>
+#include <catch2/interfaces/catch_interfaces_config.hpp>
+#include <catch2/interfaces/catch_interfaces_reporter.hpp>
 #include <catch2/internal/catch_compiler_capabilities.hpp>
 #include <catch2/internal/catch_context.hpp>
-#include <catch2/internal/catch_move_and_forward.hpp>
-#include <catch2/internal/catch_test_failure_exception.hpp>
+#include <catch2/internal/catch_run_context.hpp>
+#include <catch2/internal/catch_registry_hub.hpp>
 #include <catch2/internal/catch_unique_name.hpp>
-#include <catch2/interfaces/catch_interfaces_capture.hpp>
-#include <catch2/interfaces/catch_interfaces_config.hpp>
-#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
-#include <catch2/benchmark/detail/catch_benchmark_stats.hpp>
+#include <catch2/internal/catch_move_and_forward.hpp>
+#include <catch2/benchmark/catch_chronometer.hpp>
 #include <catch2/benchmark/catch_clock.hpp>
 #include <catch2/benchmark/catch_environment.hpp>
 #include <catch2/benchmark/catch_execution_plan.hpp>
 #include <catch2/benchmark/detail/catch_estimate_clock.hpp>
+#include <catch2/benchmark/detail/catch_complete_invoke.hpp>
 #include <catch2/benchmark/detail/catch_analyse.hpp>
 #include <catch2/benchmark/detail/catch_benchmark_function.hpp>
 #include <catch2/benchmark/detail/catch_run_for_at_least.hpp>
 
+
 #include <algorithm>
-#include <chrono>
-#include <exception>
 #include <functional>
 #include <string>
 #include <vector>
@@ -86,7 +85,7 @@ namespace Catch {
                     auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
                     BenchmarkStats<FloatDuration<Clock>> stats{ CATCH_MOVE(info), CATCH_MOVE(analysis.samples), analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
                     getResultCapture().benchmarkEnded(stats);
-                } CATCH_CATCH_ANON (TestFailureException const&) {
+                } CATCH_CATCH_ANON (TestFailureException) {
                     getResultCapture().benchmarkFailed("Benchmark failed due to failed assertion"_sr);
                 } CATCH_CATCH_ALL{
                     getResultCapture().benchmarkFailed(translateActiveException());

src/catch2/benchmark/catch_benchmark_all.hpp

@@ -33,8 +33,6 @@
 #include <catch2/benchmark/catch_sample_analysis.hpp>
 #include <catch2/benchmark/detail/catch_analyse.hpp>
 #include <catch2/benchmark/detail/catch_benchmark_function.hpp>
-#include <catch2/benchmark/detail/catch_benchmark_stats.hpp>
-#include <catch2/benchmark/detail/catch_benchmark_stats_fwd.hpp>
 #include <catch2/benchmark/detail/catch_complete_invoke.hpp>
 #include <catch2/benchmark/detail/catch_estimate_clock.hpp>
 #include <catch2/benchmark/detail/catch_measure.hpp>

src/catch2/benchmark/catch_chronometer.hpp

@@ -12,6 +12,7 @@
 
 #include <catch2/benchmark/catch_clock.hpp>
 #include <catch2/benchmark/catch_optimizer.hpp>
+#include <catch2/benchmark/detail/catch_complete_invoke.hpp>
 #include <catch2/internal/catch_meta.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>
 

src/catch2/benchmark/catch_execution_plan.hpp

@@ -17,7 +17,8 @@
 #include <catch2/benchmark/detail/catch_repeat.hpp>
 #include <catch2/benchmark/detail/catch_run_for_at_least.hpp>
 
-#include <vector>
+#include <algorithm>
+#include <iterator>
 
 namespace Catch {
     namespace Benchmark {
@@ -40,17 +41,14 @@ namespace Catch {
                 Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_iterations, Detail::repeat(now<Clock>{}));
 
                 std::vector<FloatDuration<Clock>> times;
-                const auto num_samples = cfg.benchmarkSamples();
-                times.reserve( num_samples );
-                for ( size_t i = 0; i < num_samples; ++i ) {
+                times.reserve(cfg.benchmarkSamples());
+                std::generate_n(std::back_inserter(times), cfg.benchmarkSamples(), [this, env] {
                     Detail::ChronometerModel<Clock> model;
-                    this->benchmark( Chronometer( model, iterations_per_sample ) );
+                    this->benchmark(Chronometer(model, iterations_per_sample));
                     auto sample_time = model.elapsed() - env.clock_cost.mean;
-                    if ( sample_time < FloatDuration<Clock>::zero() ) {
-                        sample_time = FloatDuration<Clock>::zero();
-                    }
-                    times.push_back(sample_time / iterations_per_sample);
-                }
+                    if (sample_time < FloatDuration<Clock>::zero()) sample_time = FloatDuration<Clock>::zero();
+                    return sample_time / iterations_per_sample;
+                });
                 return times;
             }
         };

src/catch2/benchmark/catch_sample_analysis.hpp

@@ -10,11 +10,14 @@
 #ifndef CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
 #define CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
 
+#include <catch2/benchmark/catch_clock.hpp>
 #include <catch2/benchmark/catch_estimate.hpp>
 #include <catch2/benchmark/catch_outlier_classification.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>
 
+#include <algorithm>
 #include <vector>
+#include <iterator>
 
 namespace Catch {
     namespace Benchmark {
@@ -30,9 +33,7 @@ namespace Catch {
             operator SampleAnalysis<Duration2>() const {
                 std::vector<Duration2> samples2;
                 samples2.reserve(samples.size());
-                for (auto const& d : samples) {
-                    samples2.push_back(Duration2(d));
-                }
+                std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
                 return {
                     CATCH_MOVE(samples2),
                     mean,

src/catch2/benchmark/detail/catch_analyse.hpp

@@ -10,12 +10,15 @@
 #ifndef CATCH_ANALYSE_HPP_INCLUDED
 #define CATCH_ANALYSE_HPP_INCLUDED
 
+#include <catch2/benchmark/catch_clock.hpp>
 #include <catch2/benchmark/catch_environment.hpp>
 #include <catch2/benchmark/catch_sample_analysis.hpp>
 #include <catch2/benchmark/detail/catch_stats.hpp>
 #include <catch2/interfaces/catch_interfaces_config.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>
 
+#include <algorithm>
+#include <iterator>
 #include <vector>
 
 namespace Catch {
@@ -26,9 +29,7 @@ namespace Catch {
                 if (!cfg.benchmarkNoAnalysis()) {
                     std::vector<double> samples;
                     samples.reserve(static_cast<size_t>(last - first));
-                    for (auto current = first; current != last; ++current) {
-                        samples.push_back( current->count() );
-                    }
+                    std::transform(first, last, std::back_inserter(samples), [](Duration d) { return d.count(); });
 
                     auto analysis = Catch::Benchmark::Detail::analyse_samples(cfg.benchmarkConfidenceInterval(), cfg.benchmarkResamples(), samples.begin(), samples.end());
                     auto outliers = Catch::Benchmark::Detail::classify_outliers(samples.begin(), samples.end());
@@ -43,10 +44,7 @@ namespace Catch {
                     };
                     std::vector<Duration> samples2;
                     samples2.reserve(samples.size());
-                    for (auto s : samples) {
-                        samples2.push_back( Duration( s ) );
-                    }
-
+                    std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](double d) { return Duration(d); });
                     return {
                         CATCH_MOVE(samples2),
                         wrap_estimate(analysis.mean),

src/catch2/benchmark/detail/catch_benchmark_function.hpp

@@ -11,6 +11,7 @@
 #define CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
 
 #include <catch2/benchmark/catch_chronometer.hpp>
+#include <catch2/benchmark/detail/catch_complete_invoke.hpp>
 #include <catch2/internal/catch_meta.hpp>
 #include <catch2/internal/catch_unique_ptr.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>

src/catch2/benchmark/detail/catch_benchmark_stats.hpp

@@ -1,64 +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_BENCHMARK_STATS_HPP_INCLUDED
-#define CATCH_BENCHMARK_STATS_HPP_INCLUDED
-
-#include <catch2/internal/catch_move_and_forward.hpp>
-#include <catch2/benchmark/catch_estimate.hpp>
-#include <catch2/benchmark/catch_outlier_classification.hpp>
-// The fwd decl & default specialization needs to be seen by VS2017 before
-// BenchmarkStats itself, or VS2017 will report compilation error.
-#include <catch2/benchmark/detail/catch_benchmark_stats_fwd.hpp>
-
-#include <string>
-#include <vector>
-
-namespace Catch {
-
-    struct BenchmarkInfo {
-        std::string name;
-        double estimatedDuration;
-        int iterations;
-        unsigned int samples;
-        unsigned int resamples;
-        double clockResolution;
-        double clockCost;
-    };
-
-    template <class Duration>
-    struct BenchmarkStats {
-        BenchmarkInfo info;
-
-        std::vector<Duration> samples;
-        Benchmark::Estimate<Duration> mean;
-        Benchmark::Estimate<Duration> standardDeviation;
-        Benchmark::OutlierClassification outliers;
-        double outlierVariance;
-
-        template <typename Duration2>
-        operator BenchmarkStats<Duration2>() const {
-            std::vector<Duration2> samples2;
-            samples2.reserve(samples.size());
-            for (auto const& sample : samples) {
-                samples2.push_back(Duration2(sample));
-            }
-            return {
-                info,
-                CATCH_MOVE(samples2),
-                mean,
-                standardDeviation,
-                outliers,
-                outlierVariance,
-            };
-        }
-    };
-
-
-} // end namespace Catch
-
-#endif // CATCH_BENCHMARK_STATS_HPP_INCLUDED

src/catch2/benchmark/detail/catch_complete_invoke.hpp

@@ -10,9 +10,12 @@
 #ifndef CATCH_COMPLETE_INVOKE_HPP_INCLUDED
 #define CATCH_COMPLETE_INVOKE_HPP_INCLUDED
 
+#include <catch2/internal/catch_test_failure_exception.hpp>
 #include <catch2/internal/catch_meta.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>
 
+#include <type_traits>
+
 namespace Catch {
     namespace Benchmark {
         namespace Detail {

src/catch2/benchmark/detail/catch_estimate_clock.hpp

@@ -19,6 +19,7 @@
 #include <catch2/internal/catch_unique_ptr.hpp>
 
 #include <algorithm>
+#include <iterator>
 #include <vector>
 #include <cmath>
 
@@ -29,29 +30,26 @@ namespace Catch {
             std::vector<double> resolution(int k) {
                 std::vector<TimePoint<Clock>> times;
                 times.reserve(static_cast<size_t>(k + 1));
-                for ( int i = 0; i < k + 1; ++i ) {
-                    times.push_back( Clock::now() );
-                }
+                std::generate_n(std::back_inserter(times), k + 1, now<Clock>{});
 
                 std::vector<double> deltas;
                 deltas.reserve(static_cast<size_t>(k));
-                for ( size_t idx = 1; idx < times.size(); ++idx ) {
-                    deltas.push_back( static_cast<double>(
-                        ( times[idx] - times[idx - 1] ).count() ) );
-                }
+                std::transform(std::next(times.begin()), times.end(), times.begin(),
+                    std::back_inserter(deltas),
+                    [](TimePoint<Clock> a, TimePoint<Clock> b) { return static_cast<double>((a - b).count()); });
 
                 return deltas;
             }
 
-            constexpr auto warmup_iterations = 10000;
-            constexpr auto warmup_time = std::chrono::milliseconds(100);
-            constexpr auto minimum_ticks = 1000;
-            constexpr auto warmup_seed = 10000;
-            constexpr auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
-            constexpr auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
-            constexpr auto clock_cost_estimation_tick_limit = 100000;
-            constexpr auto clock_cost_estimation_time = std::chrono::milliseconds(10);
-            constexpr auto clock_cost_estimation_iterations = 10000;
+            const auto warmup_iterations = 10000;
+            const auto warmup_time = std::chrono::milliseconds(100);
+            const auto minimum_ticks = 1000;
+            const auto warmup_seed = 10000;
+            const auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
+            const auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
+            const auto clock_cost_estimation_tick_limit = 100000;
+            const auto clock_cost_estimation_time = std::chrono::milliseconds(10);
+            const auto clock_cost_estimation_iterations = 10000;
 
             template <typename Clock>
             int warmup() {
@@ -86,11 +84,9 @@ namespace Catch {
                 std::vector<double> times;
                 int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
                 times.reserve(static_cast<size_t>(nsamples));
-                for ( int s = 0; s < nsamples; ++s ) {
-                    times.push_back( static_cast<double>(
-                        ( time_clock( r.iterations ) / r.iterations )
-                            .count() ) );
-                }
+                std::generate_n(std::back_inserter(times), nsamples, [time_clock, &r] {
+                    return static_cast<double>((time_clock(r.iterations) / r.iterations).count());
+                });
                 return {
                     FloatDuration<Clock>(mean(times.begin(), times.end())),
                     classify_outliers(times.begin(), times.end()),

src/catch2/benchmark/detail/catch_measure.hpp

@@ -10,6 +10,7 @@
 #ifndef CATCH_MEASURE_HPP_INCLUDED
 #define CATCH_MEASURE_HPP_INCLUDED
 
+#include <catch2/benchmark/catch_clock.hpp>
 #include <catch2/benchmark/detail/catch_complete_invoke.hpp>
 #include <catch2/benchmark/detail/catch_timing.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>

src/catch2/benchmark/detail/catch_run_for_at_least.cpp

@@ -7,9 +7,8 @@
 // SPDX-License-Identifier: BSL-1.0
 
 #include <catch2/benchmark/detail/catch_run_for_at_least.hpp>
-#include <catch2/internal/catch_enforce.hpp>
-
 #include <exception>
+#include <catch2/internal/catch_enforce.hpp>
 
 namespace Catch {
     namespace Benchmark {

src/catch2/benchmark/detail/catch_stats.cpp

@@ -13,7 +13,7 @@
 
 #include <cassert>
 #include <cstddef>
-#include <numeric>
+#include <iterator>
 #include <random>
 
 
@@ -21,172 +21,117 @@
 #include <future>
 #endif
 
-namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            namespace {
+namespace {
 
-                template <typename URng, typename Estimator>
-                static sample
-                resample( URng& rng,
-                          unsigned int resamples,
-                          std::vector<double>::const_iterator first,
-                          std::vector<double>::const_iterator last,
-                          Estimator& estimator ) {
-                    auto n = static_cast<size_t>( last - first );
-                    std::uniform_int_distribution<decltype( n )> dist( 0,
-                                                                       n - 1 );
+using Catch::Benchmark::Detail::sample;
 
-                    sample out;
-                    out.reserve( resamples );
-                    // We allocate the vector outside the loop to avoid realloc
-                    // per resample
-                    std::vector<double> resampled;
-                    resampled.reserve( n );
-                    for ( size_t i = 0; i < resamples; ++i ) {
-                        resampled.clear();
-                        for ( size_t s = 0; s < n; ++s ) {
-                            resampled.push_back(
-                                first[static_cast<std::ptrdiff_t>(
-                                    dist( rng ) )] );
-                        }
-                        const auto estimate =
-                            estimator( resampled.begin(), resampled.end() );
-                        out.push_back( estimate );
-                    }
-                    std::sort( out.begin(), out.end() );
-                    return out;
-                }
+     template <typename URng, typename Estimator>
+     sample resample(URng& rng, unsigned int resamples, std::vector<double>::iterator first, std::vector<double>::iterator last, Estimator& estimator) {
+         auto n = static_cast<size_t>(last - first);
+         std::uniform_int_distribution<decltype(n)> dist(0, n - 1);
 
-                static double outlier_variance( Estimate<double> mean,
-                                                Estimate<double> stddev,
-                                                int n ) {
-                    double sb = stddev.point;
-                    double mn = mean.point / n;
-                    double mg_min = mn / 2.;
-                    double sg = (std::min)( mg_min / 4., sb / std::sqrt( n ) );
-                    double sg2 = sg * sg;
-                    double sb2 = sb * sb;
+         sample out;
+         out.reserve(resamples);
+         std::generate_n(std::back_inserter(out), resamples, [n, first, &estimator, &dist, &rng] {
+             std::vector<double> resampled;
+             resampled.reserve(n);
+             std::generate_n(std::back_inserter(resampled), n, [first, &dist, &rng] { return first[static_cast<std::ptrdiff_t>(dist(rng))]; });
+             return estimator(resampled.begin(), resampled.end());
+         });
+         std::sort(out.begin(), out.end());
+         return out;
+     }
 
-                    auto c_max = [n, mn, sb2, sg2]( double x ) -> double {
-                        double k = mn - x;
-                        double d = k * k;
-                        double nd = n * d;
-                        double k0 = -n * nd;
-                        double k1 = sb2 - n * sg2 + nd;
-                        double det = k1 * k1 - 4 * sg2 * k0;
-                        return static_cast<int>( -2. * k0 /
-                                                 ( k1 + std::sqrt( det ) ) );
-                    };
 
-                    auto var_out = [n, sb2, sg2]( double c ) {
-                        double nc = n - c;
-                        return ( nc / n ) * ( sb2 - nc * sg2 );
-                    };
+    double erf_inv(double x) {
+        // Code accompanying the article "Approximating the erfinv function" in GPU Computing Gems, Volume 2
+        double w, p;
 
-                    return (std::min)( var_out( 1 ),
-                                       var_out(
-                                           (std::min)( c_max( 0. ),
-                                                       c_max( mg_min ) ) ) ) /
-                           sb2;
-                }
+        w = -log((1.0 - x) * (1.0 + x));
 
-                static double erf_inv( double x ) {
-                    // Code accompanying the article "Approximating the erfinv
-                    // function" in GPU Computing Gems, Volume 2
-                    double w, p;
+        if (w < 6.250000) {
+            w = w - 3.125000;
+            p = -3.6444120640178196996e-21;
+            p = -1.685059138182016589e-19 + p * w;
+            p = 1.2858480715256400167e-18 + p * w;
+            p = 1.115787767802518096e-17 + p * w;
+            p = -1.333171662854620906e-16 + p * w;
+            p = 2.0972767875968561637e-17 + p * w;
+            p = 6.6376381343583238325e-15 + p * w;
+            p = -4.0545662729752068639e-14 + p * w;
+            p = -8.1519341976054721522e-14 + p * w;
+            p = 2.6335093153082322977e-12 + p * w;
+            p = -1.2975133253453532498e-11 + p * w;
+            p = -5.4154120542946279317e-11 + p * w;
+            p = 1.051212273321532285e-09 + p * w;
+            p = -4.1126339803469836976e-09 + p * w;
+            p = -2.9070369957882005086e-08 + p * w;
+            p = 4.2347877827932403518e-07 + p * w;
+            p = -1.3654692000834678645e-06 + p * w;
+            p = -1.3882523362786468719e-05 + p * w;
+            p = 0.0001867342080340571352 + p * w;
+            p = -0.00074070253416626697512 + p * w;
+            p = -0.0060336708714301490533 + p * w;
+            p = 0.24015818242558961693 + p * w;
+            p = 1.6536545626831027356 + p * w;
+        } else if (w < 16.000000) {
+            w = sqrt(w) - 3.250000;
+            p = 2.2137376921775787049e-09;
+            p = 9.0756561938885390979e-08 + p * w;
+            p = -2.7517406297064545428e-07 + p * w;
+            p = 1.8239629214389227755e-08 + p * w;
+            p = 1.5027403968909827627e-06 + p * w;
+            p = -4.013867526981545969e-06 + p * w;
+            p = 2.9234449089955446044e-06 + p * w;
+            p = 1.2475304481671778723e-05 + p * w;
+            p = -4.7318229009055733981e-05 + p * w;
+            p = 6.8284851459573175448e-05 + p * w;
+            p = 2.4031110387097893999e-05 + p * w;
+            p = -0.0003550375203628474796 + p * w;
+            p = 0.00095328937973738049703 + p * w;
+            p = -0.0016882755560235047313 + p * w;
+            p = 0.0024914420961078508066 + p * w;
+            p = -0.0037512085075692412107 + p * w;
+            p = 0.005370914553590063617 + p * w;
+            p = 1.0052589676941592334 + p * w;
+            p = 3.0838856104922207635 + p * w;
+        } else {
+            w = sqrt(w) - 5.000000;
+            p = -2.7109920616438573243e-11;
+            p = -2.5556418169965252055e-10 + p * w;
+            p = 1.5076572693500548083e-09 + p * w;
+            p = -3.7894654401267369937e-09 + p * w;
+            p = 7.6157012080783393804e-09 + p * w;
+            p = -1.4960026627149240478e-08 + p * w;
+            p = 2.9147953450901080826e-08 + p * w;
+            p = -6.7711997758452339498e-08 + p * w;
+            p = 2.2900482228026654717e-07 + p * w;
+            p = -9.9298272942317002539e-07 + p * w;
+            p = 4.5260625972231537039e-06 + p * w;
+            p = -1.9681778105531670567e-05 + p * w;
+            p = 7.5995277030017761139e-05 + p * w;
+            p = -0.00021503011930044477347 + p * w;
+            p = -0.00013871931833623122026 + p * w;
+            p = 1.0103004648645343977 + p * w;
+            p = 4.8499064014085844221 + p * w;
+        }
+        return p * x;
+    }
 
-                    w = -log( ( 1.0 - x ) * ( 1.0 + x ) );
+    double standard_deviation(std::vector<double>::iterator first, std::vector<double>::iterator last) {
+        auto m = Catch::Benchmark::Detail::mean(first, last);
+        double variance = std::accumulate( first,
+                                           last,
+                                           0.,
+                                           [m]( double a, double b ) {
+                                               double diff = b - m;
+                                               return a + diff * diff;
+                                           } ) /
+                          ( last - first );
+        return std::sqrt( variance );
+    }
 
-                    if ( w < 6.250000 ) {
-                        w = w - 3.125000;
-                        p = -3.6444120640178196996e-21;
-                        p = -1.685059138182016589e-19 + p * w;
-                        p = 1.2858480715256400167e-18 + p * w;
-                        p = 1.115787767802518096e-17 + p * w;
-                        p = -1.333171662854620906e-16 + p * w;
-                        p = 2.0972767875968561637e-17 + p * w;
-                        p = 6.6376381343583238325e-15 + p * w;
-                        p = -4.0545662729752068639e-14 + p * w;
-                        p = -8.1519341976054721522e-14 + p * w;
-                        p = 2.6335093153082322977e-12 + p * w;
-                        p = -1.2975133253453532498e-11 + p * w;
-                        p = -5.4154120542946279317e-11 + p * w;
-                        p = 1.051212273321532285e-09 + p * w;
-                        p = -4.1126339803469836976e-09 + p * w;
-                        p = -2.9070369957882005086e-08 + p * w;
-                        p = 4.2347877827932403518e-07 + p * w;
-                        p = -1.3654692000834678645e-06 + p * w;
-                        p = -1.3882523362786468719e-05 + p * w;
-                        p = 0.0001867342080340571352 + p * w;
-                        p = -0.00074070253416626697512 + p * w;
-                        p = -0.0060336708714301490533 + p * w;
-                        p = 0.24015818242558961693 + p * w;
-                        p = 1.6536545626831027356 + p * w;
-                    } else if ( w < 16.000000 ) {
-                        w = sqrt( w ) - 3.250000;
-                        p = 2.2137376921775787049e-09;
-                        p = 9.0756561938885390979e-08 + p * w;
-                        p = -2.7517406297064545428e-07 + p * w;
-                        p = 1.8239629214389227755e-08 + p * w;
-                        p = 1.5027403968909827627e-06 + p * w;
-                        p = -4.013867526981545969e-06 + p * w;
-                        p = 2.9234449089955446044e-06 + p * w;
-                        p = 1.2475304481671778723e-05 + p * w;
-                        p = -4.7318229009055733981e-05 + p * w;
-                        p = 6.8284851459573175448e-05 + p * w;
-                        p = 2.4031110387097893999e-05 + p * w;
-                        p = -0.0003550375203628474796 + p * w;
-                        p = 0.00095328937973738049703 + p * w;
-                        p = -0.0016882755560235047313 + p * w;
-                        p = 0.0024914420961078508066 + p * w;
-                        p = -0.0037512085075692412107 + p * w;
-                        p = 0.005370914553590063617 + p * w;
-                        p = 1.0052589676941592334 + p * w;
-                        p = 3.0838856104922207635 + p * w;
-                    } else {
-                        w = sqrt( w ) - 5.000000;
-                        p = -2.7109920616438573243e-11;
-                        p = -2.5556418169965252055e-10 + p * w;
-                        p = 1.5076572693500548083e-09 + p * w;
-                        p = -3.7894654401267369937e-09 + p * w;
-                        p = 7.6157012080783393804e-09 + p * w;
-                        p = -1.4960026627149240478e-08 + p * w;
-                        p = 2.9147953450901080826e-08 + p * w;
-                        p = -6.7711997758452339498e-08 + p * w;
-                        p = 2.2900482228026654717e-07 + p * w;
-                        p = -9.9298272942317002539e-07 + p * w;
-                        p = 4.5260625972231537039e-06 + p * w;
-                        p = -1.9681778105531670567e-05 + p * w;
-                        p = 7.5995277030017761139e-05 + p * w;
-                        p = -0.00021503011930044477347 + p * w;
-                        p = -0.00013871931833623122026 + p * w;
-                        p = 1.0103004648645343977 + p * w;
-                        p = 4.8499064014085844221 + p * w;
-                    }
-                    return p * x;
-                }
-
-                static double
-                standard_deviation( std::vector<double>::const_iterator first,
-                                    std::vector<double>::const_iterator last ) {
-                    auto m = Catch::Benchmark::Detail::mean( first, last );
-                    double variance =
-                        std::accumulate( first,
-                                         last,
-                                         0.,
-                                         [m]( double a, double b ) {
-                                             double diff = b - m;
-                                             return a + diff * diff;
-                                         } ) /
-                        ( last - first );
-                    return std::sqrt( variance );
-                }
-
-            } // namespace
-        }     // namespace Detail
-    }         // namespace Benchmark
-} // namespace Catch
+}
 
 namespace Catch {
     namespace Benchmark {
@@ -216,47 +161,6 @@ namespace Catch {
                 return xj + g * (xj1 - xj);
             }
 
-            OutlierClassification
-            classify_outliers( std::vector<double>::const_iterator first,
-                               std::vector<double>::const_iterator last ) {
-                std::vector<double> copy( first, last );
-
-                auto q1 = weighted_average_quantile( 1, 4, copy.begin(), copy.end() );
-                auto q3 = weighted_average_quantile( 3, 4, copy.begin(), copy.end() );
-                auto iqr = q3 - q1;
-                auto los = q1 - ( iqr * 3. );
-                auto lom = q1 - ( iqr * 1.5 );
-                auto him = q3 + ( iqr * 1.5 );
-                auto his = q3 + ( iqr * 3. );
-
-                OutlierClassification o;
-                for ( ; first != last; ++first ) {
-                    const double t = *first;
-                    if ( t < los ) {
-                        ++o.low_severe;
-                    } else if ( t < lom ) {
-                        ++o.low_mild;
-                    } else if ( t > his ) {
-                        ++o.high_severe;
-                    } else if ( t > him ) {
-                        ++o.high_mild;
-                    }
-                    ++o.samples_seen;
-                }
-                return o;
-            }
-
-            double mean( std::vector<double>::const_iterator first,
-                         std::vector<double>::const_iterator last ) {
-                auto count = last - first;
-                double sum = 0.;
-                while (first != last) {
-                    sum += *first;
-                    ++first;
-                }
-                return sum / static_cast<double>(count);
-            }
-
 
             double erfc_inv(double x) {
                 return erf_inv(1.0 - x);
@@ -278,10 +182,35 @@ namespace Catch {
                 return result;
             }
 
-            bootstrap_analysis analyse_samples(double confidence_level,
-                                               unsigned int n_resamples,
-                                               std::vector<double>::iterator first,
-                                               std::vector<double>::iterator last) {
+
+            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n) {
+                double sb = stddev.point;
+                double mn = mean.point / n;
+                double mg_min = mn / 2.;
+                double sg = (std::min)(mg_min / 4., sb / std::sqrt(n));
+                double sg2 = sg * sg;
+                double sb2 = sb * sb;
+
+                auto c_max = [n, mn, sb2, sg2](double x) -> double {
+                    double k = mn - x;
+                    double d = k * k;
+                    double nd = n * d;
+                    double k0 = -n * nd;
+                    double k1 = sb2 - n * sg2 + nd;
+                    double det = k1 * k1 - 4 * sg2 * k0;
+                    return static_cast<int>(-2. * k0 / (k1 + std::sqrt(det)));
+                };
+
+                auto var_out = [n, sb2, sg2](double c) {
+                    double nc = n - c;
+                    return (nc / n) * (sb2 - nc * sg2);
+                };
+
+                return (std::min)(var_out(1), var_out((std::min)(c_max(0.), c_max(mg_min)))) / sb2;
+            }
+
+
+            bootstrap_analysis analyse_samples(double confidence_level, unsigned int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
                 CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
                 CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
                 static std::random_device entropy;
@@ -289,12 +218,11 @@ namespace Catch {
 
                 auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
 
-                auto mean = &Detail::mean;
+                auto mean = &Detail::mean<std::vector<double>::iterator>;
                 auto stddev = &standard_deviation;
 
 #if defined(CATCH_CONFIG_USE_ASYNC)
-                auto Estimate = [=](double(*f)(std::vector<double>::const_iterator,
-                                               std::vector<double>::const_iterator)) {
+                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
                     auto seed = entropy();
                     return std::async(std::launch::async, [=] {
                         std::mt19937 rng(seed);
@@ -309,8 +237,7 @@ namespace Catch {
                 auto mean_estimate = mean_future.get();
                 auto stddev_estimate = stddev_future.get();
 #else
-                auto Estimate = [=](double(*f)(std::vector<double>::const_iterator,
-                                               std::vector<double>::const_iterator)) {
+                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
                     auto seed = entropy();
                     std::mt19937 rng(seed);
                     auto resampled = resample(rng, n_resamples, first, last, f);

src/catch2/benchmark/detail/catch_stats.hpp

@@ -15,6 +15,8 @@
 
 #include <algorithm>
 #include <vector>
+#include <numeric>
+#include <tuple>
 #include <cmath>
 
 namespace Catch {
@@ -28,17 +30,39 @@ namespace Catch {
 
             double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last);
 
-            OutlierClassification
-            classify_outliers( std::vector<double>::const_iterator first,
-                               std::vector<double>::const_iterator last );
+            template <typename Iterator>
+            OutlierClassification classify_outliers(Iterator first, Iterator last) {
+                std::vector<double> copy(first, last);
 
-            double mean( std::vector<double>::const_iterator first,
-                         std::vector<double>::const_iterator last );
+                auto q1 = weighted_average_quantile(1, 4, copy.begin(), copy.end());
+                auto q3 = weighted_average_quantile(3, 4, copy.begin(), copy.end());
+                auto iqr = q3 - q1;
+                auto los = q1 - (iqr * 3.);
+                auto lom = q1 - (iqr * 1.5);
+                auto him = q3 + (iqr * 1.5);
+                auto his = q3 + (iqr * 3.);
 
-            template <typename Estimator>
-            sample jackknife(Estimator&& estimator,
-                             std::vector<double>::iterator first,
-                             std::vector<double>::iterator last) {
+                OutlierClassification o;
+                for (; first != last; ++first) {
+                    auto&& t = *first;
+                    if (t < los) ++o.low_severe;
+                    else if (t < lom) ++o.low_mild;
+                    else if (t > his) ++o.high_severe;
+                    else if (t > him) ++o.high_mild;
+                    ++o.samples_seen;
+                }
+                return o;
+            }
+
+            template <typename Iterator>
+            double mean(Iterator first, Iterator last) {
+                auto count = last - first;
+                double sum = std::accumulate(first, last, 0.);
+                return sum / static_cast<double>(count);
+            }
+
+            template <typename Estimator, typename Iterator>
+            sample jackknife(Estimator&& estimator, Iterator first, Iterator last) {
                 auto n = static_cast<size_t>(last - first);
                 auto second = first;
                 ++second;
@@ -61,12 +85,8 @@ namespace Catch {
 
             double normal_quantile(double p);
 
-            template <typename Estimator>
-            Estimate<double> bootstrap( double confidence_level,
-                                        std::vector<double>::iterator first,
-                                        std::vector<double>::iterator last,
-                                        sample const& resample,
-                                        Estimator&& estimator ) {
+            template <typename Iterator, typename Estimator>
+            Estimate<double> bootstrap(double confidence_level, Iterator first, Iterator last, sample const& resample, Estimator&& estimator) {
                 auto n_samples = last - first;
 
                 double point = estimator(first, last);
@@ -75,13 +95,13 @@ namespace Catch {
 
                 sample jack = jackknife(estimator, first, last);
                 double jack_mean = mean(jack.begin(), jack.end());
-                double sum_squares = 0, sum_cubes = 0;
-                for (double x : jack) {
-                    auto difference = jack_mean - x;
-                    auto square = difference * difference;
-                    auto cube = square * difference;
-                    sum_squares += square; sum_cubes += cube;
-                }
+                double sum_squares, sum_cubes;
+                std::tie(sum_squares, sum_cubes) = std::accumulate(jack.begin(), jack.end(), std::make_pair(0., 0.), [jack_mean](std::pair<double, double> sqcb, double x) -> std::pair<double, double> {
+                    auto d = jack_mean - x;
+                    auto d2 = d * d;
+                    auto d3 = d2 * d;
+                    return { sqcb.first + d2, sqcb.second + d3 };
+                });
 
                 double accel = sum_cubes / (6 * std::pow(sum_squares, 1.5));
                 long n = static_cast<long>(resample.size());
@@ -108,16 +128,15 @@ namespace Catch {
                 return { point, resample[lo], resample[hi], confidence_level };
             }
 
+            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n);
+
             struct bootstrap_analysis {
                 Estimate<double> mean;
                 Estimate<double> standard_deviation;
                 double outlier_variance;
             };
 
-            bootstrap_analysis analyse_samples(double confidence_level,
-                                               unsigned int n_resamples,
-                                               std::vector<double>::iterator first,
-                                               std::vector<double>::iterator last);
+            bootstrap_analysis analyse_samples(double confidence_level, unsigned int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last);
         } // namespace Detail
     } // namespace Benchmark
 } // namespace Catch

src/catch2/catch_all.hpp

@@ -36,6 +36,7 @@
 #include <catch2/catch_template_test_macros.hpp>
 #include <catch2/catch_test_case_info.hpp>
 #include <catch2/catch_test_macros.hpp>
+#include <catch2/catch_test_run_info.hpp>
 #include <catch2/catch_test_spec.hpp>
 #include <catch2/catch_timer.hpp>
 #include <catch2/catch_tostring.hpp>
@@ -46,6 +47,7 @@
 #include <catch2/generators/catch_generators_all.hpp>
 #include <catch2/interfaces/catch_interfaces_all.hpp>
 #include <catch2/internal/catch_assertion_handler.hpp>
+#include <catch2/internal/catch_benchmark_stats_fwd.hpp>
 #include <catch2/internal/catch_case_insensitive_comparisons.hpp>
 #include <catch2/internal/catch_case_sensitive.hpp>
 #include <catch2/internal/catch_clara.hpp>
@@ -54,7 +56,6 @@
 #include <catch2/internal/catch_compiler_capabilities.hpp>
 #include <catch2/internal/catch_config_android_logwrite.hpp>
 #include <catch2/internal/catch_config_counter.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>
@@ -87,10 +88,10 @@
 #include <catch2/internal/catch_platform.hpp>
 #include <catch2/internal/catch_polyfills.hpp>
 #include <catch2/internal/catch_preprocessor.hpp>
-#include <catch2/internal/catch_preprocessor_internal_stringify.hpp>
 #include <catch2/internal/catch_preprocessor_remove_parens.hpp>
 #include <catch2/internal/catch_random_number_generator.hpp>
 #include <catch2/internal/catch_random_seed_generation.hpp>
+#include <catch2/internal/catch_registry_hub.hpp>
 #include <catch2/internal/catch_reporter_registry.hpp>
 #include <catch2/internal/catch_reporter_spec_parser.hpp>
 #include <catch2/internal/catch_result_type.hpp>
@@ -113,7 +114,6 @@
 #include <catch2/internal/catch_test_failure_exception.hpp>
 #include <catch2/internal/catch_test_macro_impl.hpp>
 #include <catch2/internal/catch_test_registry.hpp>
-#include <catch2/internal/catch_test_run_info.hpp>
 #include <catch2/internal/catch_test_spec_parser.hpp>
 #include <catch2/internal/catch_textflow.hpp>
 #include <catch2/internal/catch_to_string.hpp>

src/catch2/catch_config.cpp

@@ -13,7 +13,7 @@
 #include <catch2/internal/catch_stringref.hpp>
 #include <catch2/internal/catch_string_manip.hpp>
 #include <catch2/internal/catch_test_spec_parser.hpp>
-#include <catch2/interfaces/catch_interfaces_tag_alias_registry.hpp>
+#include <catch2/internal/catch_tag_alias_registry.hpp>
 #include <catch2/internal/catch_getenv.hpp>
 
 #include <fstream>
@@ -105,7 +105,7 @@ namespace Catch {
             elem = trim(elem);
         }
 
-        // Insert the default reporter if user hasn't asked for a specific one
+        // Insert the default reporter if user hasn't asked for a specfic one
         if ( m_data.reporterSpecifications.empty() ) {
             m_data.reporterSpecifications.push_back( {
 #if defined( CATCH_CONFIG_DEFAULT_REPORTER )
@@ -123,7 +123,7 @@ namespace Catch {
 
         // Bazel support can modify the test specs, so parsing has to happen
         // after reading Bazel env vars.
-        TestSpecParser parser( ITagAliasRegistry::get() );
+        TestSpecParser parser( TagAliasRegistry::get() );
         if ( !m_data.testsOrTags.empty() ) {
             m_hasTestFilters = true;
             for ( auto const& testOrTags : m_data.testsOrTags ) {

src/catch2/catch_message.cpp

@@ -6,10 +6,10 @@
 
 // SPDX-License-Identifier: BSL-1.0
 #include <catch2/catch_message.hpp>
-#include <catch2/interfaces/catch_interfaces_capture.hpp>
 #include <catch2/internal/catch_uncaught_exceptions.hpp>
 #include <catch2/internal/catch_enforce.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>
+#include <catch2/internal/catch_run_context.hpp>
 
 #include <cassert>
 #include <stack>
@@ -37,11 +37,7 @@ namespace Catch {
     }
 
 
-    Capturer::Capturer( StringRef macroName,
-                        SourceLineInfo const& lineInfo,
-                        ResultWas::OfType resultType,
-                        StringRef names ):
-        m_resultCapture( getResultCapture() ) {
+    Capturer::Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ) {
         auto trimmed = [&] (size_t start, size_t end) {
             while (names[start] == ',' || isspace(static_cast<unsigned char>(names[start]))) {
                 ++start;

src/catch2/catch_message.hpp

@@ -12,6 +12,7 @@
 #include <catch2/internal/catch_reusable_string_stream.hpp>
 #include <catch2/internal/catch_stream_end_stop.hpp>
 #include <catch2/internal/catch_message_info.hpp>
+#include <catch2/internal/catch_run_context.hpp>
 #include <catch2/catch_tostring.hpp>
 
 #include <string>
@@ -20,7 +21,6 @@
 namespace Catch {
 
     struct SourceLineInfo;
-    class IResultCapture;
 
     struct MessageStream {
 
@@ -61,7 +61,7 @@ namespace Catch {
 
     class Capturer {
         std::vector<MessageInfo> m_messages;
-        IResultCapture& m_resultCapture;
+        RunContext& m_resultCapture = getResultCapture();
         size_t m_captured = 0;
     public:
         Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );

src/catch2/catch_registry_hub.cpp

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

src/catch2/catch_session.cpp

@@ -13,9 +13,9 @@
 #include <catch2/internal/catch_run_context.hpp>
 #include <catch2/catch_test_spec.hpp>
 #include <catch2/catch_version.hpp>
+#include <catch2/interfaces/catch_interfaces_reporter.hpp>
 #include <catch2/internal/catch_startup_exception_registry.hpp>
 #include <catch2/internal/catch_sharding.hpp>
-#include <catch2/internal/catch_test_case_registry_impl.hpp>
 #include <catch2/internal/catch_textflow.hpp>
 #include <catch2/internal/catch_windows_h_proxy.hpp>
 #include <catch2/reporters/catch_reporter_multi.hpp>
@@ -24,10 +24,12 @@
 #include <catch2/internal/catch_move_and_forward.hpp>
 #include <catch2/internal/catch_stdstreams.hpp>
 #include <catch2/internal/catch_istream.hpp>
+#include <catch2/internal/catch_test_case_registry_impl.hpp>
+#include <catch2/internal/catch_registry_hub.hpp>
+#include <catch2/catch_test_case_info.hpp>
 
 #include <algorithm>
 #include <cassert>
-#include <exception>
 #include <iomanip>
 #include <set>
 

src/catch2/catch_tag_alias_autoregistrar.cpp

@@ -8,7 +8,7 @@
 
 #include <catch2/catch_tag_alias_autoregistrar.hpp>
 #include <catch2/internal/catch_compiler_capabilities.hpp>
-#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
+#include <catch2/internal/catch_registry_hub.hpp>
 
 namespace Catch {
 

src/catch2/catch_test_case_info.cpp

@@ -139,20 +139,12 @@ namespace Catch {
         for (size_t idx = 0; idx < originalTags.size(); ++idx) {
             auto c = originalTags[idx];
             if (c == '[') {
-                CATCH_ENFORCE(
-                    !inTag,
-                    "Found '[' inside a tag while registering test case '"
-                        << _nameAndTags.name << "' at " << _lineInfo );
-
+                assert(!inTag);
                 inTag = true;
                 tagStart = idx;
             }
             if (c == ']') {
-                CATCH_ENFORCE(
-                    inTag,
-                    "Found unmatched ']' while registering test case '"
-                        << _nameAndTags.name << "' at " << _lineInfo );
-
+                assert(inTag);
                 inTag = false;
                 tagEnd = idx;
                 assert(tagStart < tagEnd);
@@ -161,11 +153,7 @@ namespace Catch {
                 // it over to backing storage and actually reference the
                 // backing storage in the saved tags
                 StringRef tagStr = originalTags.substr(tagStart+1, tagEnd - tagStart - 1);
-                CATCH_ENFORCE( !tagStr.empty(),
-                               "Found an empty tag while registering test case '"
-                                   << _nameAndTags.name << "' at "
-                                   << _lineInfo );
-
+                CATCH_ENFORCE(!tagStr.empty(), "Empty tags are not allowed");
                 enforceNotReservedTag(tagStr, lineInfo);
                 properties |= parseSpecialTag(tagStr);
                 // When copying a tag to the backing storage, we need to
@@ -179,12 +167,8 @@ namespace Catch {
                 // the tags.
                 internalAppendTag(tagStr);
             }
+            (void)inTag; // Silence "set-but-unused" warning in release mode.
         }
-        CATCH_ENFORCE( !inTag,
-                       "Found an unclosed tag while registering test case '"
-                           << _nameAndTags.name << "' at " << _lineInfo );
-
-
         // Add [.] if relevant
         if (isHidden()) {
             internalAppendTag("."_sr);

src/catch2/catch_test_run_info.hpp

@@ -17,6 +17,7 @@ namespace Catch {
         StringRef name;
     };
 
+
 } // end namespace Catch
 
 #endif // CATCH_TEST_RUN_INFO_HPP_INCLUDED

src/catch2/catch_test_spec.cpp

@@ -6,10 +6,9 @@
 
 // SPDX-License-Identifier: BSL-1.0
 #include <catch2/catch_test_spec.hpp>
-#include <catch2/interfaces/catch_interfaces_testcase.hpp>
-#include <catch2/internal/catch_test_case_registry_impl.hpp>
 #include <catch2/internal/catch_reusable_string_stream.hpp>
 #include <catch2/internal/catch_string_manip.hpp>
+#include <catch2/internal/catch_test_case_registry_impl.hpp>
 #include <catch2/catch_test_case_info.hpp>
 
 #include <algorithm>
@@ -108,18 +107,16 @@ namespace Catch {
         return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
     }
 
-    TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const {
-        Matches matches;
-        matches.reserve( m_filters.size() );
-        for ( auto const& filter : m_filters ) {
+    TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const
+    {
+        Matches matches( m_filters.size() );
+        std::transform( m_filters.begin(), m_filters.end(), matches.begin(), [&]( Filter const& filter ){
             std::vector<TestCaseHandle const*> currentMatches;
-            for ( auto const& test : testCases )
-                if ( isThrowSafe( test, config ) &&
-                     filter.matches( test.getTestCaseInfo() ) )
+            for( auto const& test : testCases )
+                if( isThrowSafe( test, config ) && filter.matches( test.getTestCaseInfo() ) )
                     currentMatches.emplace_back( &test );
-            matches.push_back(
-                FilterMatch{ extractFilterName( filter ), currentMatches } );
-        }
+            return FilterMatch{ extractFilterName(filter), currentMatches };
+        } );
         return matches;
     }
 

src/catch2/catch_tostring.hpp

@@ -16,9 +16,9 @@
 
 #include <catch2/internal/catch_compiler_capabilities.hpp>
 #include <catch2/internal/catch_config_wchar.hpp>
+#include <catch2/internal/catch_stringref.hpp>
 #include <catch2/internal/catch_reusable_string_stream.hpp>
 #include <catch2/internal/catch_void_type.hpp>
-#include <catch2/interfaces/catch_interfaces_enum_values_registry.hpp>
 
 #ifdef CATCH_CONFIG_CPP17_STRING_VIEW
 #include <string_view>
@@ -116,6 +116,7 @@ namespace Catch {
     } // namespace Detail
 
 
+    // If we decide for C++14, change these to enable_if_ts
     template <typename T, typename = void>
     struct StringMaker {
         template <typename Fake = T>
@@ -647,7 +648,7 @@ struct ratio_string<std::milli> {
     };
 }
 
-#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
+#include <catch2/internal/catch_registry_hub.hpp>
 
 #define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
 namespace Catch { \

src/catch2/catch_translate_exception.cpp

@@ -7,7 +7,7 @@
 // SPDX-License-Identifier: BSL-1.0
 
 #include <catch2/catch_translate_exception.hpp>
-#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
+#include <catch2/internal/catch_registry_hub.hpp>
 
 namespace Catch {
     namespace Detail {

src/catch2/catch_translate_exception.hpp

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

src/catch2/catch_user_config.hpp.in

@@ -169,18 +169,9 @@
 #endif
 
 
-#cmakedefine CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
-#cmakedefine CATCH_CONFIG_NO_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
-
-#if defined( CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT ) && \
-    defined( CATCH_CONFIG_NO_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT )
-#    error Cannot force STATIC_ANALYSIS_SUPPORT to both ON and OFF
-#endif
-
-
 // ------
 // Simple toggle defines
-// their value is never used and they cannot be overridden
+// their value is never used and they cannot be overriden
 // ------
 
 

src/catch2/catch_version.cpp

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

src/catch2/catch_version_macros.hpp

@@ -9,7 +9,7 @@
 #define CATCH_VERSION_MACROS_HPP_INCLUDED
 
 #define CATCH_VERSION_MAJOR 3
-#define CATCH_VERSION_MINOR 4
-#define CATCH_VERSION_PATCH 0
+#define CATCH_VERSION_MINOR 3
+#define CATCH_VERSION_PATCH 2
 
 #endif // CATCH_VERSION_MACROS_HPP_INCLUDED

src/catch2/generators/catch_generators.cpp

@@ -9,7 +9,7 @@
 #include <catch2/generators/catch_generators.hpp>
 #include <catch2/internal/catch_enforce.hpp>
 #include <catch2/generators/catch_generator_exception.hpp>
-#include <catch2/interfaces/catch_interfaces_capture.hpp>
+#include <catch2/internal/catch_run_context.hpp>
 
 namespace Catch {
 

src/catch2/interfaces/catch_interfaces_all.hpp

@@ -22,16 +22,11 @@
 #ifndef CATCH_INTERFACES_ALL_HPP_INCLUDED
 #define CATCH_INTERFACES_ALL_HPP_INCLUDED
 
-#include <catch2/interfaces/catch_interfaces_capture.hpp>
 #include <catch2/interfaces/catch_interfaces_config.hpp>
-#include <catch2/interfaces/catch_interfaces_enum_values_registry.hpp>
 #include <catch2/interfaces/catch_interfaces_exception.hpp>
 #include <catch2/interfaces/catch_interfaces_generatortracker.hpp>
-#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
 #include <catch2/interfaces/catch_interfaces_reporter.hpp>
 #include <catch2/interfaces/catch_interfaces_reporter_factory.hpp>
-#include <catch2/interfaces/catch_interfaces_tag_alias_registry.hpp>
-#include <catch2/interfaces/catch_interfaces_test_invoker.hpp>
 #include <catch2/interfaces/catch_interfaces_testcase.hpp>
 
 #endif // CATCH_INTERFACES_ALL_HPP_INCLUDED

src/catch2/interfaces/catch_interfaces_capture.cpp

@@ -1,13 +0,0 @@
-
-//              Copyright Catch2 Authors
-// Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE.txt or copy at
-//        https://www.boost.org/LICENSE_1_0.txt)
-
-// SPDX-License-Identifier: BSL-1.0
-
-#include <catch2/interfaces/catch_interfaces_capture.hpp>
-
-namespace Catch {
-    IResultCapture::~IResultCapture() = default;
-}

src/catch2/interfaces/catch_interfaces_capture.hpp

@@ -1,110 +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_INTERFACES_CAPTURE_HPP_INCLUDED
-#define CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
-
-#include <string>
-#include <chrono>
-
-#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>
-
-namespace Catch {
-
-    class AssertionResult;
-    struct AssertionInfo;
-    struct SectionInfo;
-    struct SectionEndInfo;
-    struct MessageInfo;
-    struct MessageBuilder;
-    struct Counts;
-    struct AssertionReaction;
-    struct SourceLineInfo;
-
-    class ITransientExpression;
-    class IGeneratorTracker;
-
-    struct BenchmarkInfo;
-
-    namespace Generators {
-        class GeneratorUntypedBase;
-        using GeneratorBasePtr = Catch::Detail::unique_ptr<GeneratorUntypedBase>;
-    }
-
-
-    class IResultCapture {
-    public:
-        virtual ~IResultCapture();
-
-        virtual void notifyAssertionStarted( AssertionInfo const& info ) = 0;
-        virtual bool sectionStarted( StringRef sectionName,
-                                     SourceLineInfo const& sectionLineInfo,
-                                     Counts& assertions ) = 0;
-        virtual void sectionEnded( SectionEndInfo&& endInfo ) = 0;
-        virtual void sectionEndedEarly( SectionEndInfo&& endInfo ) = 0;
-
-        virtual IGeneratorTracker*
-        acquireGeneratorTracker( StringRef generatorName,
-                                 SourceLineInfo const& lineInfo ) = 0;
-        virtual IGeneratorTracker*
-        createGeneratorTracker( StringRef generatorName,
-                                SourceLineInfo lineInfo,
-                                Generators::GeneratorBasePtr&& generator ) = 0;
-
-        virtual void benchmarkPreparing( StringRef name ) = 0;
-        virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
-        virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
-        virtual void benchmarkFailed( StringRef error ) = 0;
-
-        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
-        virtual void popScopedMessage( MessageInfo const& message ) = 0;
-
-        virtual void emplaceUnscopedMessage( MessageBuilder&& builder ) = 0;
-
-        virtual void handleFatalErrorCondition( StringRef message ) = 0;
-
-        virtual void handleExpr
-                (   AssertionInfo const& info,
-                    ITransientExpression const& expr,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleMessage
-                (   AssertionInfo const& info,
-                    ResultWas::OfType resultType,
-                    StringRef message,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleUnexpectedExceptionNotThrown
-                (   AssertionInfo const& info,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleUnexpectedInflightException
-                (   AssertionInfo const& info,
-                    std::string&& message,
-                    AssertionReaction& reaction ) = 0;
-        virtual void handleIncomplete
-                (   AssertionInfo const& info ) = 0;
-        virtual void handleNonExpr
-                (   AssertionInfo const &info,
-                    ResultWas::OfType resultType,
-                    AssertionReaction &reaction ) = 0;
-
-
-
-        virtual bool lastAssertionPassed() = 0;
-        virtual void assertionPassed() = 0;
-
-        // Deprecated, do not use:
-        virtual std::string getCurrentTestName() const = 0;
-        virtual const AssertionResult* getLastResult() const = 0;
-        virtual void exceptionEarlyReported() = 0;
-    };
-
-    IResultCapture& getResultCapture();
-}
-
-#endif // CATCH_INTERFACES_CAPTURE_HPP_INCLUDED

src/catch2/interfaces/catch_interfaces_enum_values_registry.hpp

@@ -1,47 +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_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
-#define CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
-
-#include <catch2/internal/catch_stringref.hpp>
-
-#include <vector>
-
-namespace Catch {
-
-    namespace Detail {
-        struct EnumInfo {
-            StringRef m_name;
-            std::vector<std::pair<int, StringRef>> m_values;
-
-            ~EnumInfo();
-
-            StringRef lookup( int value ) const;
-        };
-    } // namespace Detail
-
-    class IMutableEnumValuesRegistry {
-    public:
-        virtual ~IMutableEnumValuesRegistry(); // = default;
-
-        virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
-
-        template<typename E>
-        Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef 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() );
-            for( auto enumValue : values )
-                intValues.push_back( static_cast<int>( enumValue ) );
-            return registerEnum( enumName, allEnums, intValues );
-        }
-    };
-
-} // Catch
-
-#endif // CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED

src/catch2/interfaces/catch_interfaces_exception.cpp

@@ -10,5 +10,4 @@
 
 namespace Catch {
     IExceptionTranslator::~IExceptionTranslator() = default;
-    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
 }

src/catch2/interfaces/catch_interfaces_exception.hpp

@@ -14,8 +14,6 @@
 #include <vector>
 
 namespace Catch {
-    using exceptionTranslateFunction = std::string(*)();
-
     class IExceptionTranslator;
     using ExceptionTranslators = std::vector<Detail::unique_ptr<IExceptionTranslator const>>;
 
@@ -25,12 +23,6 @@ namespace Catch {
         virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
     };
 
-    class IExceptionTranslatorRegistry {
-    public:
-        virtual ~IExceptionTranslatorRegistry(); // = default
-        virtual std::string translateActiveException() const = 0;
-    };
-
 } // namespace Catch
 
 #endif // CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED

src/catch2/interfaces/catch_interfaces_registry_hub.cpp

@@ -1,14 +0,0 @@
-
-//              Copyright Catch2 Authors
-// Distributed under the Boost Software License, Version 1.0.
-//   (See accompanying file LICENSE.txt or copy at
-//        https://www.boost.org/LICENSE_1_0.txt)
-
-// SPDX-License-Identifier: BSL-1.0
-
-#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
-
-namespace Catch {
-    IRegistryHub::~IRegistryHub() = default;
-    IMutableRegistryHub::~IMutableRegistryHub() = default;
-}

src/catch2/interfaces/catch_interfaces_registry_hub.hpp

@@ -1,66 +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_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
-#define CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
-
-#include <catch2/internal/catch_unique_ptr.hpp>
-
-#include <string>
-
-namespace Catch {
-
-    class TestCaseHandle;
-    struct TestCaseInfo;
-    class ITestCaseRegistry;
-    class IExceptionTranslatorRegistry;
-    class IExceptionTranslator;
-    class ReporterRegistry;
-    class IReporterFactory;
-    class ITagAliasRegistry;
-    class ITestInvoker;
-    class IMutableEnumValuesRegistry;
-    struct SourceLineInfo;
-
-    class StartupExceptionRegistry;
-    class EventListenerFactory;
-
-    using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
-
-    class IRegistryHub {
-    public:
-        virtual ~IRegistryHub(); // = default
-
-        virtual ReporterRegistry const& getReporterRegistry() const = 0;
-        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
-        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
-        virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
-
-
-        virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
-    };
-
-    class IMutableRegistryHub {
-    public:
-        virtual ~IMutableRegistryHub(); // = default
-        virtual void registerReporter( std::string const& name, IReporterFactoryPtr factory ) = 0;
-        virtual void registerListener( Detail::unique_ptr<EventListenerFactory> factory ) = 0;
-        virtual void registerTest(Detail::unique_ptr<TestCaseInfo>&& testInfo, Detail::unique_ptr<ITestInvoker>&& invoker) = 0;
-        virtual void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) = 0;
-        virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
-        virtual void registerStartupException() noexcept = 0;
-        virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
-    };
-
-    IRegistryHub const& getRegistryHub();
-    IMutableRegistryHub& getMutableRegistryHub();
-    void cleanUp();
-    std::string translateActiveException();
-
-}
-
-#endif // CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED

src/catch2/interfaces/catch_interfaces_reporter.hpp

@@ -9,22 +9,27 @@
 #define CATCH_INTERFACES_REPORTER_HPP_INCLUDED
 
 #include <catch2/catch_section_info.hpp>
+#include <catch2/catch_test_run_info.hpp>
 #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_test_run_info.hpp>
 #include <catch2/internal/catch_unique_ptr.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>
-#include <catch2/benchmark/detail/catch_benchmark_stats.hpp>
+#include <catch2/benchmark/catch_estimate.hpp>
+#include <catch2/benchmark/catch_outlier_classification.hpp>
+#include <catch2/internal/catch_benchmark_stats_fwd.hpp>
 
 #include <map>
 #include <string>
 #include <vector>
 #include <iosfwd>
+#include <chrono>
 
 namespace Catch {
 
+    struct BenchmarkInfo;
+
     struct ReporterDescription;
     struct ListenerDescription;
     struct TagInfo;
@@ -107,6 +112,45 @@ namespace Catch {
         bool aborting;
     };
 
+
+    struct BenchmarkInfo {
+        std::string name;
+        double estimatedDuration;
+        int iterations;
+        unsigned int samples;
+        unsigned int resamples;
+        double clockResolution;
+        double clockCost;
+    };
+
+    template <class Duration>
+    struct BenchmarkStats {
+        BenchmarkInfo info;
+
+        std::vector<Duration> samples;
+        Benchmark::Estimate<Duration> mean;
+        Benchmark::Estimate<Duration> standardDeviation;
+        Benchmark::OutlierClassification outliers;
+        double outlierVariance;
+
+        template <typename Duration2>
+        operator BenchmarkStats<Duration2>() const {
+            std::vector<Duration2> samples2;
+            samples2.reserve(samples.size());
+            for (auto const& sample : samples) {
+                samples2.push_back(Duration2(sample));
+            }
+            return {
+                info,
+                CATCH_MOVE(samples2),
+                mean,
+                standardDeviation,
+                outliers,
+                outlierVariance,
+            };
+        }
+    };
+
     //! By setting up its preferences, a reporter can modify Catch2's behaviour
     //! in some regards, e.g. it can request Catch2 to capture writes to
     //! stdout/stderr during test execution, and pass them to the reporter.
@@ -205,7 +249,7 @@ namespace Catch {
          */
         virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
 
-        //! Called if a fatal error (signal/structured exception) occurred
+        //! Called if a fatal error (signal/structured exception) occured
         virtual void fatalErrorEncountered( StringRef error ) = 0;
 
         //! Writes out information about provided reporters using reporter-specific format

src/catch2/interfaces/catch_interfaces_tag_alias_registry.hpp

@@ -1,29 +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_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
-#define CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    struct TagAlias;
-
-    class ITagAliasRegistry {
-    public:
-        virtual ~ITagAliasRegistry(); // = default
-        // Nullptr if not present
-        virtual TagAlias const* find( std::string const& alias ) const = 0;
-        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
-
-        static ITagAliasRegistry const& get();
-    };
-
-} // end namespace Catch
-
-#endif // CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED

src/catch2/interfaces/catch_interfaces_test_invoker.hpp

@@ -1,21 +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_INTERFACES_TEST_INVOKER_HPP_INCLUDED
-#define CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
-
-namespace Catch {
-
-    class ITestInvoker {
-    public:
-        virtual void invoke() const = 0;
-        virtual ~ITestInvoker(); // = default
-    };
-
-} // namespace Catch
-
-#endif // CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED

src/catch2/interfaces/catch_interfaces_testcase.cpp

@@ -9,5 +9,5 @@
 #include <catch2/interfaces/catch_interfaces_testcase.hpp>
 
 namespace Catch {
-    ITestCaseRegistry::~ITestCaseRegistry() = default;
+    ITestInvoker::~ITestInvoker() = default;
 }

src/catch2/interfaces/catch_interfaces_testcase.hpp

@@ -8,21 +8,12 @@
 #ifndef CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
 #define CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
 
-#include <vector>
-
 namespace Catch {
 
-    struct TestCaseInfo;
-    class TestCaseHandle;
-    class IConfig;
-
-    class ITestCaseRegistry {
+    class ITestInvoker {
     public:
-        virtual ~ITestCaseRegistry(); // = default
-        // TODO: this exists only for adding filenames to test cases -- let's expose this in a saner way later
-        virtual std::vector<TestCaseInfo* > const& getAllInfos() const = 0;
-        virtual std::vector<TestCaseHandle> const& getAllTests() const = 0;
-        virtual std::vector<TestCaseHandle> const& getAllTestsSorted( IConfig const& config ) const = 0;
+        virtual void invoke () const = 0;
+        virtual ~ITestInvoker(); // = default
     };
 
 }

src/catch2/internal/catch_assertion_handler.cpp

@@ -11,7 +11,8 @@
 #include <catch2/internal/catch_enforce.hpp>
 #include <catch2/internal/catch_debugger.hpp>
 #include <catch2/internal/catch_test_failure_exception.hpp>
-#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
+#include <catch2/internal/catch_registry_hub.hpp>
+#include <catch2/internal/catch_run_context.hpp>
 #include <catch2/matchers/catch_matchers_string.hpp>
 
 namespace Catch {
@@ -23,9 +24,7 @@ namespace Catch {
             ResultDisposition::Flags resultDisposition )
     :   m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
         m_resultCapture( getResultCapture() )
-    {
-        m_resultCapture.notifyAssertionStarted( m_assertionInfo );
-    }
+    {}
 
     void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
         m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );

src/catch2/internal/catch_assertion_handler.hpp

@@ -10,12 +10,15 @@
 
 #include <catch2/catch_assertion_info.hpp>
 #include <catch2/internal/catch_decomposer.hpp>
-#include <catch2/interfaces/catch_interfaces_capture.hpp>
+#include <catch2/internal/catch_run_context.hpp>
+#include <catch2/internal/catch_lazy_expr.hpp>
 
 #include <string>
 
 namespace Catch {
 
+    class RunContext;
+
     struct AssertionReaction {
         bool shouldDebugBreak = false;
         bool shouldThrow = false;
@@ -26,7 +29,7 @@ namespace Catch {
         AssertionInfo m_assertionInfo;
         AssertionReaction m_reaction;
         bool m_completed = false;
-        IResultCapture& m_resultCapture;
+        RunContext& m_resultCapture;
 
     public:
         AssertionHandler

src/catch2/internal/catch_commandline.cpp

@@ -9,7 +9,7 @@
 
 #include <catch2/catch_config.hpp>
 #include <catch2/internal/catch_string_manip.hpp>
-#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
+#include <catch2/internal/catch_registry_hub.hpp>
 #include <catch2/internal/catch_reporter_registry.hpp>
 #include <catch2/internal/catch_console_colour.hpp>
 #include <catch2/internal/catch_parse_numbers.hpp>

src/catch2/internal/catch_compiler_capabilities.hpp

@@ -50,18 +50,12 @@
 #    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
          _Pragma( "GCC diagnostic ignored \"-Wparentheses\"" )
 
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
-         _Pragma( "GCC diagnostic ignored \"-Wunused-result\"" )
-
 #    define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
          _Pragma( "GCC diagnostic ignored \"-Wunused-variable\"" )
 
 #    define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
          _Pragma( "GCC diagnostic ignored \"-Wuseless-cast\"" )
 
-#    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
-         _Pragma( "GCC diagnostic ignored \"-Wshadow\"" )
-
 #    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
 
 #endif
@@ -134,9 +128,6 @@
 #    define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wcomma\"" )
 
-#    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
-        _Pragma( "clang diagnostic ignored \"-Wshadow\"" )
-
 #endif // __clang__
 
 
@@ -374,9 +365,6 @@
 #if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
 #   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
 #endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT)
-#   define CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT
-#endif
 #if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS)
 #   define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS
 #endif
@@ -386,16 +374,6 @@
 #if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
 #   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
 #endif
-#if !defined( CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS )
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#endif
-#if !defined( CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS )
-#    define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS
-#endif
-#if !defined( CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS )
-#    define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS
-#endif
-
 
 // The goal of this macro is to avoid evaluation of the arguments, but
 // still have the compiler warn on problems inside...
@@ -409,6 +387,13 @@
 #   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
 #endif
 
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#endif
+
+#if !defined(CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS
+#endif
 
 #if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
 #define CATCH_TRY if ((true))

src/catch2/internal/catch_config_counter.hpp

@@ -18,8 +18,6 @@
 #ifndef CATCH_CONFIG_COUNTER_HPP_INCLUDED
 #define CATCH_CONFIG_COUNTER_HPP_INCLUDED
 
-#include <catch2/catch_user_config.hpp>
-
 #if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
     #define CATCH_INTERNAL_CONFIG_COUNTER
 #endif

src/catch2/internal/catch_config_static_analysis_support.hpp

@@ -1,34 +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 the STATIC_ANALYSIS_SUPPORT configuration option
- *
- * Some of Catch2's macros can be defined differently to work better with
- * static analysis tools, like clang-tidy or coverity.
- * Currently the main use case is to show that `SECTION`s are executed
- * exclusively, and not all in one run of a `TEST_CASE`.
- */
-
-#ifndef CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
-#define CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
-
-#include <catch2/catch_user_config.hpp>
-
-#if defined(__clang_analyzer__) || defined(__COVERITY__)
-    #define CATCH_INTERNAL_CONFIG_STATIC_ANALYSIS_SUPPORT
-#endif
-
-#if defined( CATCH_INTERNAL_CONFIG_STATIC_ANALYSIS_SUPPORT ) && \
-    !defined( CATCH_CONFIG_NO_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT ) && \
-    !defined( CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT )
-#    define CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
-#endif
-
-
-#endif // CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED

src/catch2/internal/catch_config_uncaught_exceptions.hpp

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

src/catch2/internal/catch_config_wchar.hpp

@@ -17,8 +17,6 @@
 #ifndef CATCH_CONFIG_WCHAR_HPP_INCLUDED
 #define CATCH_CONFIG_WCHAR_HPP_INCLUDED
 
-#include <catch2/catch_user_config.hpp>
-
 // We assume that WCHAR should be enabled by default, and only disabled
 // for a shortlist (so far only DJGPP) of compilers.
 

src/catch2/internal/catch_context.cpp

@@ -27,7 +27,7 @@ namespace Catch {
         return *Context::currentContext;
     }
 
-    void Context::setResultCapture( IResultCapture* resultCapture ) {
+    void Context::setResultCapture( RunContext* resultCapture ) {
         m_resultCapture = resultCapture;
     }
 

src/catch2/internal/catch_context.hpp

@@ -12,12 +12,12 @@
 
 namespace Catch {
 
-    class IResultCapture;
+    class RunContext;
     class IConfig;
 
     class Context {
         IConfig const* m_config = nullptr;
-        IResultCapture* m_resultCapture = nullptr;
+        RunContext* m_resultCapture = nullptr;
 
         CATCH_EXPORT static Context* currentContext;
         friend Context& getCurrentMutableContext();
@@ -26,9 +26,9 @@ namespace Catch {
         friend void cleanUpContext();
 
     public:
-        IResultCapture* getResultCapture() const { return m_resultCapture; }
+        RunContext* getResultCapture() const { return m_resultCapture; }
         IConfig const* getConfig() const { return m_config; }
-        void setResultCapture( IResultCapture* resultCapture );
+        void setResultCapture( RunContext* resultCapture );
         void setConfig( IConfig const* config );
     };
 

src/catch2/internal/catch_enum_values_registry.cpp

@@ -12,44 +12,47 @@
 
 namespace Catch {
 
-    IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() = default;
-
     namespace Detail {
 
         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) {
+            // In other words, it returns the Blue part of
+            // Bikeshed::Colour::Blue
+            static StringRef extractInstanceName( StringRef enumInstance ) {
                 // Find last occurrence of ":"
                 size_t name_start = enumInstance.size();
-                while (name_start > 0 && enumInstance[name_start - 1] != ':') {
+                while ( name_start > 0 &&
+                        enumInstance[name_start - 1] != ':' ) {
                     --name_start;
                 }
-                return enumInstance.substr(name_start, enumInstance.size() - name_start);
+                return enumInstance.substr( name_start,
+                                            enumInstance.size() - name_start );
             }
-        }
+        } // end unnamed namespace
 
         std::vector<StringRef> parseEnums( StringRef enums ) {
             auto enumValues = splitStringRef( enums, ',' );
             std::vector<StringRef> parsed;
             parsed.reserve( enumValues.size() );
-            for( auto const& enumValue : enumValues ) {
-                parsed.push_back(trim(extractInstanceName(enumValue)));
+            for ( auto const& enumValue : enumValues ) {
+                parsed.push_back( trim( extractInstanceName( enumValue ) ) );
             }
             return parsed;
         }
 
-        EnumInfo::~EnumInfo() {}
+        EnumInfo::~EnumInfo() = default;
 
         StringRef EnumInfo::lookup( int value ) const {
-            for( auto const& valueToName : m_values ) {
-                if( valueToName.first == value )
-                    return valueToName.second;
+            for ( auto const& valueToName : m_values ) {
+                if ( valueToName.first == value ) { return valueToName.second; }
             }
             return "{** unexpected enum value **}"_sr;
         }
 
-        Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+        Catch::Detail::unique_ptr<EnumInfo>
+        makeEnumInfo( StringRef enumName,
+                      StringRef allValueNames,
+                      std::vector<int> const& values ) {
             auto enumInfo = Catch::Detail::make_unique<EnumInfo>();
             enumInfo->m_name = enumName;
             enumInfo->m_values.reserve( values.size() );
@@ -57,17 +60,22 @@ namespace Catch {
             const auto valueNames = Catch::Detail::parseEnums( allValueNames );
             assert( valueNames.size() == values.size() );
             std::size_t i = 0;
-            for( auto value : values )
-                enumInfo->m_values.emplace_back(value, valueNames[i++]);
+            for ( auto value : values ) {
+                enumInfo->m_values.emplace_back( value, valueNames[i++] );
+            }
 
             return enumInfo;
         }
 
-        EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
-            m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
-            return *m_enumInfos.back();
-        }
+    } // namespace Detail
 
-    } // Detail
-} // Catch
+    Detail::EnumInfo const&
+    EnumValuesRegistry::registerEnum( StringRef enumName,
+                                      StringRef allValueNames,
+                                      std::vector<int> const& values ) {
+        m_enumInfos.push_back(
+            Detail::makeEnumInfo( enumName, allValueNames, values ) );
+        return *m_enumInfos.back();
+    }
 
+} // namespace Catch

src/catch2/internal/catch_enum_values_registry.hpp

@@ -8,29 +8,54 @@
 #ifndef CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
 #define CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
 
-#include <catch2/interfaces/catch_interfaces_enum_values_registry.hpp>
-#include <catch2/internal/catch_unique_ptr.hpp>
 #include <catch2/internal/catch_stringref.hpp>
+#include <catch2/internal/catch_unique_ptr.hpp>
 
 #include <vector>
 
 namespace Catch {
 
     namespace Detail {
+        struct EnumInfo {
+            StringRef m_name;
+            std::vector<std::pair<int, StringRef>> m_values;
 
-        Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
+            ~EnumInfo();
 
-        class EnumValuesRegistry : public IMutableEnumValuesRegistry {
-
-            std::vector<Catch::Detail::unique_ptr<EnumInfo>> m_enumInfos;
-
-            EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values) override;
+            StringRef lookup( int value ) const;
         };
 
+        Detail::unique_ptr<EnumInfo>
+        makeEnumInfo( StringRef enumName,
+                      StringRef allValueNames,
+                      std::vector<int> const& values );
         std::vector<StringRef> parseEnums( StringRef enums );
 
-    } // Detail
+    } // namespace Detail
 
-} // Catch
+    class EnumValuesRegistry {
+        std::vector<Catch::Detail::unique_ptr<Detail::EnumInfo>> m_enumInfos;
+
+    public:
+        Detail::EnumInfo const& registerEnum( StringRef enumName,
+                                              StringRef allEnums,
+                                              std::vector<int> const& values );
+        template <typename E>
+        Detail::EnumInfo const&
+        registerEnum( StringRef enumName,
+                      StringRef 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() );
+            for ( auto enumValue : values ) {
+                intValues.push_back( static_cast<int>( enumValue ) );
+            }
+            return registerEnum( enumName, allEnums, intValues );
+        }
+    };
+
+} // namespace Catch
 
 #endif // CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED

src/catch2/internal/catch_exception_translator_registry.cpp

@@ -6,19 +6,20 @@
 
 // SPDX-License-Identifier: BSL-1.0
 #include <catch2/internal/catch_exception_translator_registry.hpp>
+#include <catch2/interfaces/catch_interfaces_exception.hpp>
 #include <catch2/internal/catch_compiler_capabilities.hpp>
 #include <catch2/internal/catch_enforce.hpp>
 #include <catch2/internal/catch_test_failure_exception.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>
 
-#include <exception>
+#include <vector>
 
 namespace Catch {
 
     namespace {
         static std::string tryTranslators(
-            std::vector<
-                Detail::unique_ptr<IExceptionTranslator const>> const& translators ) {
+            std::vector<Detail::unique_ptr<IExceptionTranslator const>> const&
+                translators ) {
             if ( translators.empty() ) {
                 std::rethrow_exception( std::current_exception() );
             } else {
@@ -26,14 +27,20 @@ namespace Catch {
                                                   translators.end() );
             }
         }
-
     }
 
-    ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() {
-    }
+
+    struct ExceptionTranslatorRegistry::ExceptionTranslatorRegistryImpl {
+        std::vector<Detail::unique_ptr<IExceptionTranslator const>>
+            translators;
+    };
+
+    ExceptionTranslatorRegistry::ExceptionTranslatorRegistry():
+        m_impl( Detail::make_unique<ExceptionTranslatorRegistryImpl>() ) {}
+    ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() = default;
 
     void ExceptionTranslatorRegistry::registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) {
-        m_translators.push_back( CATCH_MOVE( translator ) );
+        m_impl->translators.push_back( CATCH_MOVE( translator ) );
     }
 
 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
@@ -53,7 +60,7 @@ namespace Catch {
         // First we try user-registered translators. If none of them can
         // handle the exception, it will be rethrown handled by our defaults.
         try {
-            return tryTranslators(m_translators);
+            return tryTranslators(m_impl->translators);
         }
         // To avoid having to handle TFE explicitly everywhere, we just
         // rethrow it so that it goes back up the caller.
@@ -83,4 +90,5 @@ namespace Catch {
     }
 #endif
 
+
 }

src/catch2/internal/catch_exception_translator_registry.hpp

@@ -8,22 +8,22 @@
 #ifndef CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
 #define CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
 
-#include <catch2/interfaces/catch_interfaces_exception.hpp>
 #include <catch2/internal/catch_unique_ptr.hpp>
 
-#include <vector>
 #include <string>
 
 namespace Catch {
+    class IExceptionTranslator;
+
+    class ExceptionTranslatorRegistry {
+        struct ExceptionTranslatorRegistryImpl;
+        Detail::unique_ptr<ExceptionTranslatorRegistryImpl> m_impl;
 
-    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
     public:
-        ~ExceptionTranslatorRegistry() override;
+        ExceptionTranslatorRegistry();
+        ~ExceptionTranslatorRegistry();
         void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator );
-        std::string translateActiveException() const override;
-
-    private:
-        ExceptionTranslators m_translators;
+        std::string translateActiveException() const;
     };
 }
 

src/catch2/internal/catch_fatal_condition_handler.cpp

@@ -28,7 +28,7 @@
 
 #include <catch2/internal/catch_context.hpp>
 #include <catch2/internal/catch_enforce.hpp>
-#include <catch2/interfaces/catch_interfaces_capture.hpp>
+#include <catch2/internal/catch_run_context.hpp>
 #include <catch2/internal/catch_windows_h_proxy.hpp>
 #include <catch2/internal/catch_stdstreams.hpp>
 

src/catch2/internal/catch_leak_detector.cpp

@@ -7,7 +7,7 @@
 // SPDX-License-Identifier: BSL-1.0
 
 #include <catch2/internal/catch_leak_detector.hpp>
-#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
+#include <catch2/internal/catch_registry_hub.hpp>
 #include <catch2/catch_user_config.hpp>
 
 #ifdef CATCH_CONFIG_WINDOWS_CRTDBG

src/catch2/internal/catch_list.cpp

@@ -7,14 +7,14 @@
 // SPDX-License-Identifier: BSL-1.0
 #include <catch2/internal/catch_list.hpp>
 
-#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
+#include <catch2/internal/catch_registry_hub.hpp>
 #include <catch2/interfaces/catch_interfaces_reporter.hpp>
+#include <catch2/interfaces/catch_interfaces_testcase.hpp>
 #include <catch2/interfaces/catch_interfaces_reporter_factory.hpp>
-#include <catch2/internal/catch_test_case_registry_impl.hpp>
 #include <catch2/internal/catch_reporter_registry.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>
 #include <catch2/internal/catch_case_insensitive_comparisons.hpp>
-
+#include <catch2/internal/catch_test_case_registry_impl.hpp>
 #include <catch2/internal/catch_context.hpp>
 #include <catch2/catch_config.hpp>
 #include <catch2/catch_test_spec.hpp>

src/catch2/internal/catch_optional.hpp

@@ -8,8 +8,6 @@
 #ifndef CATCH_OPTIONAL_HPP_INCLUDED
 #define CATCH_OPTIONAL_HPP_INCLUDED
 
-#include <catch2/internal/catch_move_and_forward.hpp>
-
 #include <cassert>
 
 namespace Catch {
@@ -18,50 +16,35 @@ namespace Catch {
     template<typename T>
     class Optional {
     public:
-        Optional(): nullableValue( nullptr ) {}
-        ~Optional() { reset(); }
+        Optional() : nullableValue( nullptr ) {}
+        Optional( T const& _value )
+        : nullableValue( new( storage ) T( _value ) )
+        {}
+        Optional( Optional const& _other )
+        : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
+        {}
 
-        Optional( T const& _value ):
-            nullableValue( new ( storage ) T( _value ) ) {}
-        Optional( T&& _value ):
-            nullableValue( new ( storage ) T( CATCH_MOVE( _value ) ) ) {}
-
-        Optional& operator=( T const& _value ) {
+        ~Optional() {
             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 ) {
+        Optional& operator= ( Optional const& _other ) {
+            if( &_other != this ) {
                 reset();
-                if ( _other ) { nullableValue = new ( storage ) T( *_other ); }
+                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 ) );
-                }
-            }
+        Optional& operator = ( T const& _value ) {
+            reset();
+            nullableValue = new( storage ) T( _value );
             return *this;
         }
 
         void reset() {
-            if ( nullableValue ) { nullableValue->~T(); }
+            if( nullableValue )
+                nullableValue->~T();
             nullableValue = nullptr;
         }
 
@@ -108,7 +91,7 @@ namespace Catch {
         }
 
     private:
-        T* nullableValue;
+        T *nullableValue;
         alignas(alignof(T)) char storage[sizeof(T)];
     };
 

src/catch2/internal/catch_preprocessor_internal_stringify.hpp

@@ -1,19 +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_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
-#define CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
-
-#include <catch2/catch_user_config.hpp>
-
-#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
-  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__##_catch_sr
-#else
-  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"_catch_sr
-#endif
-
-#endif // CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED

src/catch2/internal/catch_registry_hub.cpp

@@ -0,0 +1,114 @@
+
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#include <catch2/internal/catch_registry_hub.hpp>
+
+#include <catch2/internal/catch_context.hpp>
+#include <catch2/internal/catch_enforce.hpp>
+#include <catch2/internal/catch_test_case_registry_impl.hpp>
+#include <catch2/internal/catch_reporter_registry.hpp>
+#include <catch2/internal/catch_exception_translator_registry.hpp>
+#include <catch2/internal/catch_tag_alias_registry.hpp>
+#include <catch2/internal/catch_startup_exception_registry.hpp>
+#include <catch2/internal/catch_singletons.hpp>
+#include <catch2/internal/catch_enum_values_registry.hpp>
+#include <catch2/catch_test_case_info.hpp>
+#include <catch2/internal/catch_noncopyable.hpp>
+#include <catch2/interfaces/catch_interfaces_reporter_factory.hpp>
+#include <catch2/internal/catch_move_and_forward.hpp>
+#include <catch2/internal/catch_reporter_registry.hpp>
+
+namespace Catch {
+
+    struct RegistryHub::RegistryHubImpl {
+        TestCaseRegistry testCaseRegistry;
+        ReporterRegistry reporterRegistry;
+        ExceptionTranslatorRegistry exceptionTranslatorRegistry;
+        TagAliasRegistry tagAliasRegistry;
+        StartupExceptionRegistry exceptionRegistry;
+        EnumValuesRegistry enumValuesRegistry;
+    };
+
+    RegistryHub::RegistryHub():
+        m_impl( Detail::make_unique<RegistryHubImpl>() ) {}
+    RegistryHub::~RegistryHub() = default;
+
+    ReporterRegistry const&
+    RegistryHub::getReporterRegistry() const {
+        return m_impl->reporterRegistry;
+    }
+    TestCaseRegistry const&
+    RegistryHub::getTestCaseRegistry() const {
+        return m_impl->testCaseRegistry;
+    }
+    ExceptionTranslatorRegistry const&
+    RegistryHub::getExceptionTranslatorRegistry() const {
+        return m_impl->exceptionTranslatorRegistry;
+    }
+    TagAliasRegistry const&
+    RegistryHub::getTagAliasRegistry() const {
+        return m_impl->tagAliasRegistry;
+    }
+    StartupExceptionRegistry const&
+    RegistryHub::getStartupExceptionRegistry() const {
+        return m_impl->exceptionRegistry;
+    }
+    void
+    RegistryHub::registerReporter( std::string const& name,
+                           IReporterFactoryPtr factory ) {
+        m_impl->reporterRegistry.registerReporter( name, CATCH_MOVE( factory ) );
+    }
+    void RegistryHub::registerListener(
+        Detail::unique_ptr<EventListenerFactory> factory ) {
+        m_impl->reporterRegistry.registerListener( CATCH_MOVE( factory ) );
+    }
+    void RegistryHub::registerTest(
+        Detail::unique_ptr<TestCaseInfo>&& testInfo,
+                       Detail::unique_ptr<ITestInvoker>&& invoker ) {
+        m_impl->testCaseRegistry.registerTest( CATCH_MOVE( testInfo ),
+                                         CATCH_MOVE( invoker ) );
+    }
+    void RegistryHub::registerTranslator(
+        Detail::unique_ptr<IExceptionTranslator>&& translator ) {
+        m_impl->exceptionTranslatorRegistry.registerTranslator(
+            CATCH_MOVE( translator ) );
+    }
+    void RegistryHub::registerTagAlias( std::string const& alias,
+                           std::string const& tag,
+                           SourceLineInfo const& lineInfo ) {
+        m_impl->tagAliasRegistry.add( alias, tag, lineInfo );
+    }
+    void RegistryHub::registerStartupException() noexcept {
+#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS )
+        m_impl->exceptionRegistry.add( std::current_exception() );
+#else
+        CATCH_INTERNAL_ERROR( "Attempted to register active exception under "
+                              "CATCH_CONFIG_DISABLE_EXCEPTIONS!" );
+#endif
+    }
+    EnumValuesRegistry& RegistryHub::getMutableEnumValuesRegistry() {
+        return m_impl->enumValuesRegistry;
+    }
+
+    using RegistryHubSingleton = Singleton<RegistryHub>;
+
+    RegistryHub const& getRegistryHub() {
+        return RegistryHubSingleton::get();
+    }
+    RegistryHub& getMutableRegistryHub() {
+        return RegistryHubSingleton::getMutable();
+    }
+    void cleanUp() {
+        cleanupSingletons();
+        cleanUpContext();
+    }
+    std::string translateActiveException() {
+        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
+    }
+
+
+} // end namespace Catch

src/catch2/internal/catch_registry_hub.hpp

@@ -0,0 +1,67 @@
+
+//              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_REGISTRY_HUB_HPP_INCLUDED
+#define CATCH_REGISTRY_HUB_HPP_INCLUDED
+
+#include <catch2/internal/catch_unique_ptr.hpp>
+
+#include <string>
+
+namespace Catch {
+
+    class TestCaseHandle;
+    struct TestCaseInfo;
+    class TestCaseRegistry;
+    class ExceptionTranslatorRegistry;
+    class IExceptionTranslator;
+    class ReporterRegistry;
+    class IReporterFactory;
+    class TagAliasRegistry;
+    class ITestInvoker;
+    class EnumValuesRegistry;
+    struct SourceLineInfo;
+
+    class StartupExceptionRegistry;
+    class EventListenerFactory;
+
+    using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
+
+    class RegistryHub {
+        struct RegistryHubImpl;
+        Detail::unique_ptr<RegistryHubImpl> m_impl;
+    public:
+        RegistryHub();
+        ~RegistryHub();
+
+        ReporterRegistry const& getReporterRegistry() const;
+        TestCaseRegistry const& getTestCaseRegistry() const;
+        TagAliasRegistry const& getTagAliasRegistry() const;
+        ExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const;
+        StartupExceptionRegistry const& getStartupExceptionRegistry() const;
+
+        void registerReporter( std::string const& name,
+                               IReporterFactoryPtr factory );
+        void registerListener( Detail::unique_ptr<EventListenerFactory> factory );
+        void registerTest( Detail::unique_ptr<TestCaseInfo>&& testInfo,
+                           Detail::unique_ptr<ITestInvoker>&& invoker );
+        void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator );
+        void registerTagAlias( std::string const& alias,
+                               std::string const& tag,
+                               SourceLineInfo const& lineInfo );
+        void registerStartupException() noexcept;
+        EnumValuesRegistry& getMutableEnumValuesRegistry();
+    };
+
+    RegistryHub const& getRegistryHub();
+    RegistryHub& getMutableRegistryHub();
+    void cleanUp();
+    std::string translateActiveException();
+
+}
+
+#endif // CATCH_REGISTRY_HUB_HPP_INCLUDED

src/catch2/internal/catch_reporter_registry.cpp

@@ -57,6 +57,8 @@ namespace Catch {
         auto it = m_impl->factories.find( name );
         if ( it == m_impl->factories.end() ) return nullptr;
         return it->second->create( CATCH_MOVE( config ) );
+
+        return IEventListenerPtr();
     }
 
     void ReporterRegistry::registerReporter( std::string const& name,

src/catch2/internal/catch_reporter_spec_parser.cpp

@@ -21,9 +21,9 @@ namespace Catch {
         };
 
         kvPair splitKVPair(StringRef kvString) {
-            auto splitPos = static_cast<size_t>(
-                std::find( kvString.begin(), kvString.end(), '=' ) -
-                kvString.begin() );
+            auto splitPos = static_cast<size_t>( std::distance(
+                kvString.begin(),
+                std::find( kvString.begin(), kvString.end(), '=' ) ) );
 
             return { kvString.substr( 0, splitPos ),
                      kvString.substr( splitPos + 1, kvString.size() ) };

src/catch2/internal/catch_run_context.cpp

@@ -7,19 +7,26 @@
 // SPDX-License-Identifier: BSL-1.0
 #include <catch2/internal/catch_run_context.hpp>
 
-#include <catch2/catch_user_config.hpp>
-#include <catch2/interfaces/catch_interfaces_config.hpp>
-#include <catch2/interfaces/catch_interfaces_generatortracker.hpp>
 #include <catch2/interfaces/catch_interfaces_reporter.hpp>
+#include <catch2/catch_test_case_info.hpp>
+#include <catch2/catch_assertion_result.hpp>
+#include <catch2/catch_user_config.hpp>
+#include <catch2/catch_timer.hpp>
+#include <catch2/interfaces/catch_interfaces_generatortracker.hpp>
+#include <catch2/interfaces/catch_interfaces_config.hpp>
 #include <catch2/internal/catch_compiler_capabilities.hpp>
 #include <catch2/internal/catch_context.hpp>
 #include <catch2/internal/catch_enforce.hpp>
 #include <catch2/internal/catch_fatal_condition_handler.hpp>
 #include <catch2/internal/catch_random_number_generator.hpp>
-#include <catch2/catch_timer.hpp>
 #include <catch2/internal/catch_output_redirect.hpp>
 #include <catch2/internal/catch_assertion_handler.hpp>
 #include <catch2/internal/catch_test_failure_exception.hpp>
+#include <catch2/internal/catch_optional.hpp>
+#include <catch2/internal/catch_move_and_forward.hpp>
+#include <catch2/internal/catch_fatal_condition_handler.hpp>
+#include <catch2/internal/catch_test_case_tracker.hpp>
+#include <catch2/catch_message.hpp>
 
 #include <cassert>
 #include <algorithm>
@@ -165,30 +172,44 @@ namespace Catch {
         } // namespace
     }
 
-    RunContext::RunContext(IConfig const* _config, IEventListenerPtr&& reporter)
-    :   m_runInfo(_config->name()),
+
+    struct RunContext::RunContextImpl {
+        Optional<AssertionResult> lastResult;
+        FatalConditionHandler fatalConditionhandler;
+        TrackerContext trackerContext;
+        std::vector<MessageInfo> messages;
+        // Fake owners for unscoped messages
+        std::vector<ScopedMessage> messageScopes;
+        IEventListenerPtr reporter;
+        std::vector<SectionEndInfo> unfinishedSections;
+        std::vector<ITracker*> activeSections;
+    };
+
+    RunContext::RunContext(IConfig const* _config, IEventListenerPtr&& reporter):
+        m_impl( Detail::make_unique<RunContextImpl>() ),
+        m_runInfo(_config->name()),
         m_config(_config),
-        m_reporter(CATCH_MOVE(reporter)),
         m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
-        m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
+        m_includeSuccessfulResults( m_config->includeSuccessfulResults() || reporter->getPreferences().shouldReportAllAssertions )
     {
-        getCurrentMutableContext().setResultCapture( this );
-        m_reporter->testRunStarting(m_runInfo);
+        getCurrentMutableContext().setResultCapture(this);
+        m_impl->reporter = CATCH_MOVE( reporter );
+        m_impl->reporter->testRunStarting(m_runInfo);
     }
 
     RunContext::~RunContext() {
-        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
+        m_impl->reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
     }
 
     Totals RunContext::runTest(TestCaseHandle const& testCase) {
         const Totals prevTotals = m_totals;
 
         auto const& testInfo = testCase.getTestCaseInfo();
-        m_reporter->testCaseStarting(testInfo);
+        m_impl->reporter->testCaseStarting( testInfo );
         m_activeTestCase = &testCase;
 
 
-        ITracker& rootTracker = m_trackerContext.startRun();
+        ITracker& rootTracker = m_impl->trackerContext.startRun();
         assert(rootTracker.isSectionTracker());
         static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
 
@@ -229,10 +250,10 @@ namespace Catch {
         std::string redirectedCout;
         std::string redirectedCerr;
         do {
-            m_trackerContext.startCycle();
-            m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocationRef(testInfo.name, testInfo.lineInfo));
+            m_impl->trackerContext.startCycle();
+            m_testCaseTracker = &SectionTracker::acquire(m_impl->trackerContext, TestCaseTracking::NameAndLocationRef(testInfo.name, testInfo.lineInfo));
 
-            m_reporter->testCasePartialStarting(testInfo, testRuns);
+            m_impl->reporter->testCasePartialStarting( testInfo, testRuns );
 
             const auto beforeRunTotals = m_totals;
             std::string oneRunCout, oneRunCerr;
@@ -243,7 +264,7 @@ namespace Catch {
             const auto singleRunTotals = m_totals.delta(beforeRunTotals);
             auto statsForOneRun = TestCaseStats(testInfo, singleRunTotals, CATCH_MOVE(oneRunCout), CATCH_MOVE(oneRunCerr), aborting());
 
-            m_reporter->testCasePartialEnded(statsForOneRun, testRuns);
+            m_impl->reporter->testCasePartialEnded( statsForOneRun, testRuns );
             ++testRuns;
         } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
 
@@ -254,11 +275,12 @@ namespace Catch {
             deltaTotals.testCases.failed++;
         }
         m_totals.testCases += deltaTotals.testCases;
-        m_reporter->testCaseEnded(TestCaseStats(testInfo,
-                                  deltaTotals,
-                                  CATCH_MOVE(redirectedCout),
-                                  CATCH_MOVE(redirectedCerr),
-                                  aborting()));
+        m_impl->reporter->testCaseEnded(
+            TestCaseStats( testInfo,
+                           deltaTotals,
+                           CATCH_MOVE( redirectedCout ),
+                           CATCH_MOVE( redirectedCerr ),
+                           aborting() ) );
 
         m_activeTestCase = nullptr;
         m_testCaseTracker = nullptr;
@@ -267,7 +289,7 @@ namespace Catch {
     }
 
 
-    void RunContext::assertionEnded(AssertionResult&& result) {
+    void RunContext::assertionEnded(AssertionResult const & result) {
         if (result.getResultType() == ResultWas::Ok) {
             m_totals.assertions.passed++;
             m_lastAssertionPassed = true;
@@ -287,41 +309,35 @@ namespace Catch {
             m_lastAssertionPassed = true;
         }
 
-        m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals));
+        m_impl->reporter->assertionEnded(AssertionStats(result, m_impl->messages, m_totals));
 
         if ( result.getResultType() != ResultWas::Warning ) {
-            m_messageScopes.clear();
+            m_impl->messageScopes.clear();
         }
 
         // Reset working state
         resetAssertionInfo();
-        m_lastResult = CATCH_MOVE( result );
+        m_impl->lastResult = result;
     }
     void RunContext::resetAssertionInfo() {
         m_lastAssertionInfo.macroName = StringRef();
         m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
     }
 
-    void RunContext::notifyAssertionStarted( AssertionInfo const& info ) {
-        m_reporter->assertionStarting( info );
-    }
-
-    bool RunContext::sectionStarted( StringRef sectionName,
-                                     SourceLineInfo const& sectionLineInfo,
-                                     Counts& assertions ) {
+    bool RunContext::sectionStarted(StringRef sectionName, SourceLineInfo const& sectionLineInfo, Counts & assertions) {
         ITracker& sectionTracker =
-            SectionTracker::acquire( m_trackerContext,
+            SectionTracker::acquire( m_impl->trackerContext,
                                      TestCaseTracking::NameAndLocationRef(
                                          sectionName, sectionLineInfo ) );
 
         if (!sectionTracker.isOpen())
             return false;
-        m_activeSections.push_back(&sectionTracker);
+        m_impl->activeSections.push_back(&sectionTracker);
 
         SectionInfo sectionInfo( sectionLineInfo, static_cast<std::string>(sectionName) );
         m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
 
-        m_reporter->sectionStarting(sectionInfo);
+        m_impl->reporter->sectionStarting( sectionInfo );
 
         assertions = m_totals.assertions;
 
@@ -332,7 +348,7 @@ namespace Catch {
                                          SourceLineInfo const& lineInfo ) {
         using namespace Generators;
         GeneratorTracker* tracker = GeneratorTracker::acquire(
-            m_trackerContext,
+            m_impl->trackerContext,
             TestCaseTracking::NameAndLocationRef(
                  generatorName, lineInfo ) );
         m_lastAssertionInfo.lineInfo = lineInfo;
@@ -345,13 +361,13 @@ namespace Catch {
         Generators::GeneratorBasePtr&& generator ) {
 
         auto nameAndLoc = TestCaseTracking::NameAndLocation( static_cast<std::string>( generatorName ), lineInfo );
-        auto& currentTracker = m_trackerContext.currentTracker();
+        auto& currentTracker = m_impl->trackerContext.currentTracker();
         assert(
             currentTracker.nameAndLocation() != nameAndLoc &&
             "Trying to create tracker for a genreator that already has one" );
 
         auto newTracker = Catch::Detail::make_unique<Generators::GeneratorTracker>(
-            CATCH_MOVE(nameAndLoc), m_trackerContext, &currentTracker );
+            CATCH_MOVE(nameAndLoc), m_impl->trackerContext, &currentTracker );
         auto ret = newTracker.get();
         currentTracker.addChild( CATCH_MOVE( newTracker ) );
 
@@ -365,7 +381,7 @@ namespace Catch {
             return false;
         if (!m_config->warnAboutMissingAssertions())
             return false;
-        if (m_trackerContext.currentTracker().hasChildren())
+        if (m_impl->trackerContext.currentTracker().hasChildren())
             return false;
         m_totals.assertions.failed++;
         assertions.failed++;
@@ -376,50 +392,57 @@ namespace Catch {
         Counts assertions = m_totals.assertions - endInfo.prevAssertions;
         bool missingAssertions = testForMissingAssertions(assertions);
 
-        if (!m_activeSections.empty()) {
-            m_activeSections.back()->close();
-            m_activeSections.pop_back();
+        if (!m_impl->activeSections.empty()) {
+            m_impl->activeSections.back()->close();
+            m_impl->activeSections.pop_back();
         }
 
-        m_reporter->sectionEnded(SectionStats(CATCH_MOVE(endInfo.sectionInfo), assertions, endInfo.durationInSeconds, missingAssertions));
-        m_messages.clear();
-        m_messageScopes.clear();
+        m_impl->reporter->sectionEnded(
+            SectionStats( CATCH_MOVE( endInfo.sectionInfo ),
+                          assertions,
+                          endInfo.durationInSeconds,
+                          missingAssertions ) );
+        m_impl->messages.clear();
+        m_impl->messageScopes.clear();
     }
 
     void RunContext::sectionEndedEarly(SectionEndInfo&& endInfo) {
-        if ( m_unfinishedSections.empty() ) {
-            m_activeSections.back()->fail();
+        if ( m_impl->unfinishedSections.empty() ) {
+            m_impl->activeSections.back()->fail();
         } else {
-            m_activeSections.back()->close();
+            m_impl->activeSections.back()->close();
         }
-        m_activeSections.pop_back();
+        m_impl->activeSections.pop_back();
 
-        m_unfinishedSections.push_back(CATCH_MOVE(endInfo));
+        m_impl->unfinishedSections.push_back(CATCH_MOVE(endInfo));
     }
 
     void RunContext::benchmarkPreparing( StringRef name ) {
-        m_reporter->benchmarkPreparing(name);
+        m_impl->reporter->benchmarkPreparing( name );
     }
     void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
-        m_reporter->benchmarkStarting( info );
+        m_impl->reporter->benchmarkStarting( info );
     }
     void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
-        m_reporter->benchmarkEnded( stats );
+        m_impl->reporter->benchmarkEnded( stats );
     }
     void RunContext::benchmarkFailed( StringRef error ) {
-        m_reporter->benchmarkFailed( error );
+        m_impl->reporter->benchmarkFailed( error );
     }
 
     void RunContext::pushScopedMessage(MessageInfo const & message) {
-        m_messages.push_back(message);
+        m_impl->messages.push_back(message);
     }
 
     void RunContext::popScopedMessage(MessageInfo const & message) {
-        m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
+        m_impl->messages.erase( std::remove( m_impl->messages.begin(),
+                                             m_impl->messages.end(),
+                                             message ),
+                                m_impl->messages.end() );
     }
 
     void RunContext::emplaceUnscopedMessage( MessageBuilder&& builder ) {
-        m_messageScopes.emplace_back( CATCH_MOVE(builder) );
+        m_impl->messageScopes.emplace_back( CATCH_MOVE(builder) );
     }
 
     std::string RunContext::getCurrentTestName() const {
@@ -429,7 +452,7 @@ namespace Catch {
     }
 
     const AssertionResult * RunContext::getLastResult() const {
-        return &(*m_lastResult);
+        return &(*m_impl->lastResult);
     }
 
     void RunContext::exceptionEarlyReported() {
@@ -438,7 +461,7 @@ namespace Catch {
 
     void RunContext::handleFatalErrorCondition( StringRef message ) {
         // First notify reporter that bad things happened
-        m_reporter->fatalErrorEncountered(message);
+        m_impl->reporter->fatalErrorEncountered(message);
 
         // Don't rebuild the result -- the stringification itself can cause more fatal errors
         // Instead, fake a result data.
@@ -446,7 +469,7 @@ namespace Catch {
         tempResult.message = static_cast<std::string>(message);
         AssertionResult result(m_lastAssertionInfo, CATCH_MOVE(tempResult));
 
-        assertionEnded(CATCH_MOVE(result) );
+        assertionEnded(result);
 
         handleUnfinishedSections();
 
@@ -457,20 +480,20 @@ namespace Catch {
         Counts assertions;
         assertions.failed = 1;
         SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, 0, false);
-        m_reporter->sectionEnded(testCaseSectionStats);
+        m_impl->reporter->sectionEnded(testCaseSectionStats);
 
         auto const& testInfo = m_activeTestCase->getTestCaseInfo();
 
         Totals deltaTotals;
         deltaTotals.testCases.failed = 1;
         deltaTotals.assertions.failed = 1;
-        m_reporter->testCaseEnded(TestCaseStats(testInfo,
+        m_impl->reporter->testCaseEnded(TestCaseStats(testInfo,
                                   deltaTotals,
                                   std::string(),
                                   std::string(),
                                   false));
         m_totals.testCases.failed++;
-        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
+        m_impl->reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
     }
 
     bool RunContext::lastAssertionPassed() {
@@ -481,7 +504,7 @@ namespace Catch {
         m_lastAssertionPassed = true;
         ++m_totals.assertions.passed;
         resetAssertionInfo();
-        m_messageScopes.clear();
+        m_impl->messageScopes.clear();
     }
 
     bool RunContext::aborting() const {
@@ -491,7 +514,7 @@ namespace Catch {
     void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
         auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
         SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
-        m_reporter->sectionStarting(testCaseSection);
+        m_impl->reporter->sectionStarting(testCaseSection);
         Counts prevAssertions = m_totals.assertions;
         double duration = 0;
         m_shouldReportUnexpected = true;
@@ -499,7 +522,7 @@ namespace Catch {
 
         Timer timer;
         CATCH_TRY {
-            if (m_reporter->getPreferences().shouldRedirectStdOut) {
+            if (m_impl->reporter->getPreferences().shouldRedirectStdOut) {
 #if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
                 RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
 
@@ -532,18 +555,18 @@ namespace Catch {
 
         m_testCaseTracker->close();
         handleUnfinishedSections();
-        m_messages.clear();
-        m_messageScopes.clear();
+        m_impl->messages.clear();
+        m_impl->messageScopes.clear();
 
         SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, duration, missingAssertions);
-        m_reporter->sectionEnded(testCaseSectionStats);
+        m_impl->reporter->sectionEnded(testCaseSectionStats);
     }
 
     void RunContext::invokeActiveTestCase() {
         // We need to engage a handler for signals/structured exceptions
         // before running the tests themselves, or the binary can crash
         // without failed test being reported.
-        FatalConditionHandlerGuard _(&m_fatalConditionhandler);
+        FatalConditionHandlerGuard _(&m_impl->fatalConditionhandler);
         // We keep having issue where some compilers warn about an unused
         // variable, even though the type has non-trivial constructor and
         // destructor. This is annoying and ugly, but it makes them stfu.
@@ -555,12 +578,12 @@ namespace Catch {
     void RunContext::handleUnfinishedSections() {
         // If sections ended prematurely due to an exception we stored their
         // infos here so we can tear them down outside the unwind process.
-        for (auto it = m_unfinishedSections.rbegin(),
-             itEnd = m_unfinishedSections.rend();
+        for (auto it = m_impl->unfinishedSections.rbegin(),
+             itEnd = m_impl->unfinishedSections.rend();
              it != itEnd;
              ++it)
             sectionEnded(CATCH_MOVE(*it));
-        m_unfinishedSections.clear();
+        m_impl->unfinishedSections.clear();
     }
 
     void RunContext::handleExpr(
@@ -568,6 +591,8 @@ namespace Catch {
         ITransientExpression const& expr,
         AssertionReaction& reaction
     ) {
+        m_impl->reporter->assertionStarting( info );
+
         bool negated = isFalseTest( info.resultDisposition );
         bool result = expr.getResult() != negated;
 
@@ -596,7 +621,7 @@ namespace Catch {
         AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
         assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
 
-        assertionEnded( CATCH_MOVE(assertionResult) );
+        assertionEnded( assertionResult );
     }
 
     void RunContext::handleMessage(
@@ -605,16 +630,16 @@ namespace Catch {
             StringRef message,
             AssertionReaction& reaction
     ) {
+        m_impl->reporter->assertionStarting( info );
+
         m_lastAssertionInfo = info;
 
         AssertionResultData data( resultType, LazyExpression( false ) );
         data.message = static_cast<std::string>(message);
         AssertionResult assertionResult{ m_lastAssertionInfo,
                                          CATCH_MOVE( data ) };
-
-        const auto isOk = assertionResult.isOk();
-        assertionEnded( CATCH_MOVE(assertionResult) );
-        if ( !isOk ) {
+        assertionEnded( assertionResult );
+        if ( !assertionResult.isOk() ) {
             populateReaction( reaction );
         } else if ( resultType == ResultWas::ExplicitSkip ) {
             // TODO: Need to handle this explicitly, as ExplicitSkip is
@@ -639,7 +664,7 @@ namespace Catch {
         AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
         data.message = CATCH_MOVE(message);
         AssertionResult assertionResult{ info, CATCH_MOVE(data) };
-        assertionEnded( CATCH_MOVE(assertionResult) );
+        assertionEnded( assertionResult );
         populateReaction( reaction );
     }
 
@@ -657,7 +682,7 @@ namespace Catch {
         AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
         data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE"s;
         AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
-        assertionEnded( CATCH_MOVE(assertionResult) );
+        assertionEnded( assertionResult );
     }
     void RunContext::handleNonExpr(
             AssertionInfo const &info,
@@ -668,14 +693,14 @@ namespace Catch {
 
         AssertionResultData data( resultType, LazyExpression( false ) );
         AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
+        assertionEnded( assertionResult );
 
-        const auto isOk = assertionResult.isOk();
-        assertionEnded( CATCH_MOVE(assertionResult) );
-        if ( !isOk ) { populateReaction( reaction ); }
+        if( !assertionResult.isOk() )
+            populateReaction( reaction );
     }
 
 
-    IResultCapture& getResultCapture() {
+    RunContext& getResultCapture() {
         if (auto* capture = getCurrentContext().getResultCapture())
             return *capture;
         else

src/catch2/internal/catch_run_context.hpp

@@ -8,39 +8,60 @@
 #ifndef CATCH_RUN_CONTEXT_HPP_INCLUDED
 #define CATCH_RUN_CONTEXT_HPP_INCLUDED
 
-#include <catch2/interfaces/catch_interfaces_capture.hpp>
-#include <catch2/internal/catch_test_registry.hpp>
-#include <catch2/internal/catch_test_run_info.hpp>
-#include <catch2/internal/catch_fatal_condition_handler.hpp>
-#include <catch2/catch_test_case_info.hpp>
-#include <catch2/catch_message.hpp>
+#include <catch2/catch_test_run_info.hpp>
 #include <catch2/catch_totals.hpp>
-#include <catch2/internal/catch_test_case_tracker.hpp>
 #include <catch2/catch_assertion_info.hpp>
-#include <catch2/catch_assertion_result.hpp>
-#include <catch2/internal/catch_optional.hpp>
-#include <catch2/internal/catch_move_and_forward.hpp>
+#include <catch2/internal/catch_benchmark_stats_fwd.hpp>
+#include <catch2/internal/catch_unique_ptr.hpp>
 
 #include <string>
+#include <chrono>
 
 namespace Catch {
 
+    class TestCaseHandle;
+    class AssertionResult;
+    struct AssertionInfo;
+    struct SectionInfo;
+    struct SectionEndInfo;
+    struct MessageInfo;
+    struct MessageBuilder;
+    struct Counts;
+    struct AssertionReaction;
+    struct SourceLineInfo;
+
+    class ITransientExpression;
+    class IGeneratorTracker;
+
+    struct BenchmarkInfo;
+
+    namespace Generators {
+        class GeneratorUntypedBase;
+        using GeneratorBasePtr = Catch::Detail::unique_ptr<GeneratorUntypedBase>;
+    }
+
+
     class IGeneratorTracker;
     class IConfig;
+    // Fixme: Take out the namespace?
+    namespace TestCaseTracking {
+        class ITracker;
+    }
+    using TestCaseTracking::ITracker;
+
     class IEventListener;
     using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
 
-    ///////////////////////////////////////////////////////////////////////////
-
-    class RunContext final : public IResultCapture {
-
+    class RunContext {
+        struct RunContextImpl;
+        Detail::unique_ptr<RunContextImpl> m_impl;
     public:
         RunContext( RunContext const& ) = delete;
         RunContext& operator =( RunContext const& ) = delete;
 
         explicit RunContext( IConfig const* _config, IEventListenerPtr&& reporter );
 
-        ~RunContext() override;
+        ~RunContext();
 
         Totals runTest(TestCaseHandle const& testCase);
 
@@ -50,64 +71,63 @@ namespace Catch {
         void handleExpr
                 (   AssertionInfo const& info,
                     ITransientExpression const& expr,
-                    AssertionReaction& reaction ) override;
+                    AssertionReaction& reaction );
         void handleMessage
                 (   AssertionInfo const& info,
                     ResultWas::OfType resultType,
                     StringRef message,
-                    AssertionReaction& reaction ) override;
+                    AssertionReaction& reaction );
         void handleUnexpectedExceptionNotThrown
                 (   AssertionInfo const& info,
-                    AssertionReaction& reaction ) override;
+                    AssertionReaction& reaction );
         void handleUnexpectedInflightException
                 (   AssertionInfo const& info,
                     std::string&& message,
-                    AssertionReaction& reaction ) override;
+                    AssertionReaction& reaction );
         void handleIncomplete
-                (   AssertionInfo const& info ) override;
+                (   AssertionInfo const& info );
         void handleNonExpr
                 (   AssertionInfo const &info,
                     ResultWas::OfType resultType,
-                    AssertionReaction &reaction ) override;
+                    AssertionReaction &reaction );
 
-        void notifyAssertionStarted( AssertionInfo const& info ) override;
         bool sectionStarted( StringRef sectionName,
                              SourceLineInfo const& sectionLineInfo,
-                             Counts& assertions ) override;
+                             Counts& assertions );
 
-        void sectionEnded( SectionEndInfo&& endInfo ) override;
-        void sectionEndedEarly( SectionEndInfo&& endInfo ) override;
+        void sectionEnded( SectionEndInfo&& endInfo );
+        void sectionEndedEarly( SectionEndInfo&& endInfo );
 
         IGeneratorTracker*
         acquireGeneratorTracker( StringRef generatorName,
-                                 SourceLineInfo const& lineInfo ) override;
+                                 SourceLineInfo const& lineInfo );
         IGeneratorTracker* createGeneratorTracker(
             StringRef generatorName,
             SourceLineInfo lineInfo,
-            Generators::GeneratorBasePtr&& generator ) override;
+            Generators::GeneratorBasePtr&& generator );
 
 
-        void benchmarkPreparing( StringRef name ) override;
-        void benchmarkStarting( BenchmarkInfo const& info ) override;
-        void benchmarkEnded( BenchmarkStats<> const& stats ) override;
-        void benchmarkFailed( StringRef error ) override;
+        void benchmarkPreparing( StringRef name );
+        void benchmarkStarting( BenchmarkInfo const& info );
+        void benchmarkEnded( BenchmarkStats<> const& stats );
+        void benchmarkFailed( StringRef error );
 
-        void pushScopedMessage( MessageInfo const& message ) override;
-        void popScopedMessage( MessageInfo const& message ) override;
+        void pushScopedMessage( MessageInfo const& message );
+        void popScopedMessage( MessageInfo const& message );
 
-        void emplaceUnscopedMessage( MessageBuilder&& builder ) override;
+        void emplaceUnscopedMessage( MessageBuilder&& builder );
 
-        std::string getCurrentTestName() const override;
+        std::string getCurrentTestName() const;
 
-        const AssertionResult* getLastResult() const override;
+        const AssertionResult* getLastResult() const;
 
-        void exceptionEarlyReported() override;
+        void exceptionEarlyReported();
 
-        void handleFatalErrorCondition( StringRef message ) override;
+        void handleFatalErrorCondition( StringRef message );
 
-        bool lastAssertionPassed() override;
+        bool lastAssertionPassed();
 
-        void assertionPassed() override;
+        void assertionPassed();
 
     public:
         // !TBD We need to do this another way!
@@ -121,7 +141,7 @@ namespace Catch {
         void resetAssertionInfo();
         bool testForMissingAssertions( Counts& assertions );
 
-        void assertionEnded( AssertionResult&& result );
+        void assertionEnded( AssertionResult const& result );
         void reportExpr
                 (   AssertionInfo const &info,
                     ResultWas::OfType resultType,
@@ -137,18 +157,10 @@ namespace Catch {
         TestRunInfo m_runInfo;
         TestCaseHandle const* m_activeTestCase = nullptr;
         ITracker* m_testCaseTracker = nullptr;
-        Optional<AssertionResult> m_lastResult;
 
         IConfig const* m_config;
         Totals m_totals;
-        IEventListenerPtr m_reporter;
-        std::vector<MessageInfo> m_messages;
-        std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
         AssertionInfo m_lastAssertionInfo;
-        std::vector<SectionEndInfo> m_unfinishedSections;
-        std::vector<ITracker*> m_activeSections;
-        TrackerContext m_trackerContext;
-        FatalConditionHandler m_fatalConditionhandler;
         bool m_lastAssertionPassed = false;
         bool m_shouldReportUnexpected = true;
         bool m_includeSuccessfulResults;
@@ -156,6 +168,9 @@ namespace Catch {
 
     void seedRng(IConfig const& config);
     unsigned int rngSeed();
+
+    RunContext& getResultCapture();
+
 } // end namespace Catch
 
 #endif // CATCH_RUN_CONTEXT_HPP_INCLUDED

src/catch2/internal/catch_section.hpp

@@ -9,7 +9,6 @@
 #define CATCH_SECTION_HPP_INCLUDED
 
 #include <catch2/internal/catch_compiler_capabilities.hpp>
-#include <catch2/internal/catch_config_static_analysis_support.hpp>
 #include <catch2/internal/catch_noncopyable.hpp>
 #include <catch2/catch_section_info.hpp>
 #include <catch2/catch_timer.hpp>
@@ -39,62 +38,16 @@ namespace Catch {
 
 } // end namespace Catch
 
-#if !defined(CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT)
-#    define INTERNAL_CATCH_SECTION( ... )                                 \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                         \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                  \
-        if ( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME(            \
-                 catch_internal_Section ) =                               \
-                 Catch::Section( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-#    define INTERNAL_CATCH_DYNAMIC_SECTION( ... )                     \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                     \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS              \
-        if ( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME(        \
-                 catch_internal_Section ) =                           \
-                 Catch::SectionInfo(                                  \
-                     CATCH_INTERNAL_LINEINFO,                         \
-                     ( Catch::ReusableStringStream() << __VA_ARGS__ ) \
-                         .str() ) )                                   \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-#else
-
-// These section definitions imply that at most one section at one level
-// will be intered (because only one section's __LINE__ can be equal to
-// the dummy `catchInternalSectionHint` variable from `TEST_CASE`).
-
-namespace Catch {
-    namespace Detail {
-        // Intentionally without linkage, as it should only be used as a dummy
-        // symbol for static analysis.
-        int GetNewSectionHint();
-    } // namespace Detail
-} // namespace Catch
-
-
-#    define INTERNAL_CATCH_SECTION( ... )                                   \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                           \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                    \
-        CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS                             \
-        if ( [[maybe_unused]] int catchInternalPreviousSectionHint =        \
-                 catchInternalSectionHint,                                  \
-             catchInternalSectionHint = Catch::Detail::GetNewSectionHint(); \
-             catchInternalPreviousSectionHint == __LINE__ )                 \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-#    define INTERNAL_CATCH_DYNAMIC_SECTION( ... )                           \
-        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                           \
-        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                    \
-        CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS                             \
-        if ( [[maybe_unused]] int catchInternalPreviousSectionHint =        \
-                 catchInternalSectionHint,                                  \
-             catchInternalSectionHint = Catch::Detail::GetNewSectionHint(); \
-             catchInternalPreviousSectionHint == __LINE__ )                 \
-        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-#endif
+#define INTERNAL_CATCH_SECTION( ... ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::Section( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
 
+#define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, (Catch::ReusableStringStream() << __VA_ARGS__).str() ) ) \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
 
 #endif // CATCH_SECTION_HPP_INCLUDED

src/catch2/internal/catch_stream_end_stop.hpp

@@ -17,10 +17,10 @@ namespace Catch {
     // as well as
     //    << stuff +StreamEndStop
     struct StreamEndStop {
-        constexpr StringRef operator+() const { return StringRef(); }
+        StringRef operator+() const { return StringRef(); }
 
         template <typename T>
-        constexpr friend T const& operator+( T const& value, StreamEndStop ) {
+        friend T const& operator+( T const& value, StreamEndStop ) {
             return value;
         }
     };

src/catch2/internal/catch_string_manip.cpp

@@ -8,6 +8,7 @@
 #include <catch2/internal/catch_string_manip.hpp>
 #include <catch2/internal/catch_stringref.hpp>
 
+#include <algorithm>
 #include <ostream>
 #include <cstring>
 #include <cctype>
@@ -31,9 +32,9 @@ namespace Catch {
         return s.find( infix ) != std::string::npos;
     }
     void toLowerInPlace( std::string& s ) {
-        for ( char& c : s ) {
-            c = toLower( c );
-        }
+        std::transform( s.begin(), s.end(), s.begin(), []( char c ) {
+            return toLower( c );
+        } );
     }
     std::string toLower( std::string const& s ) {
         std::string lc = s;

src/catch2/internal/catch_tag_alias_registry.cpp

@@ -8,16 +8,24 @@
 #include <catch2/internal/catch_tag_alias_registry.hpp>
 #include <catch2/internal/catch_console_colour.hpp>
 #include <catch2/internal/catch_enforce.hpp>
-#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
+#include <catch2/internal/catch_registry_hub.hpp>
 #include <catch2/internal/catch_string_manip.hpp>
 
-namespace Catch {
+#include <map>
 
-    TagAliasRegistry::~TagAliasRegistry() {}
+namespace Catch {
+    struct TagAliasRegistry::TagAliasRegistryImpl {
+        std::map<std::string, TagAlias> registry;
+    };
+
+
+    TagAliasRegistry::TagAliasRegistry():
+        m_impl( Detail::make_unique<TagAliasRegistryImpl>() ){}
+    TagAliasRegistry::~TagAliasRegistry() = default;
 
     TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
-        auto it = m_registry.find( alias );
-        if( it != m_registry.end() )
+        auto it = m_impl->registry.find( alias );
+        if( it != m_impl->registry.end() )
             return &(it->second);
         else
             return nullptr;
@@ -25,7 +33,7 @@ namespace Catch {
 
     std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
         std::string expandedTestSpec = unexpandedTestSpec;
-        for( auto const& registryKvp : m_registry ) {
+        for( auto const& registryKvp : m_impl->registry ) {
             std::size_t pos = expandedTestSpec.find( registryKvp.first );
             if( pos != std::string::npos ) {
                 expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
@@ -40,15 +48,13 @@ namespace Catch {
         CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
                       "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
 
-        CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
+        CATCH_ENFORCE( m_impl->registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
                       "error: tag alias, '" << alias << "' already registered.\n"
                       << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
                       << "\tRedefined at: " << lineInfo );
     }
 
-    ITagAliasRegistry::~ITagAliasRegistry() = default;
-
-    ITagAliasRegistry const& ITagAliasRegistry::get() {
+    TagAliasRegistry const& TagAliasRegistry::get() {
         return getRegistryHub().getTagAliasRegistry();
     }
 

src/catch2/internal/catch_tag_alias_registry.hpp

@@ -8,24 +8,30 @@
 #ifndef CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
 #define CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
 
-#include <catch2/interfaces/catch_interfaces_tag_alias_registry.hpp>
 #include <catch2/catch_tag_alias.hpp>
+#include <catch2/internal/catch_unique_ptr.hpp>
 
-#include <map>
 #include <string>
 
 namespace Catch {
     struct SourceLineInfo;
 
-    class TagAliasRegistry : public ITagAliasRegistry {
+    class TagAliasRegistry {
+        struct TagAliasRegistryImpl;
+        Detail::unique_ptr<TagAliasRegistryImpl> m_impl;
     public:
-        ~TagAliasRegistry() override;
-        TagAlias const* find( std::string const& alias ) const override;
-        std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
+        TagAliasRegistry();
+        ~TagAliasRegistry(); // = default;
+
+        //! Nullptr if not present
+        TagAlias const* find( std::string const& alias ) const;
+        //! Returns the test spec but with expanded aliases
+        std::string expandAliases( std::string const& unexpandedTestSpec ) const;
         void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
 
+        static TagAliasRegistry const& get();
+
     private:
-        std::map<std::string, TagAlias> m_registry;
     };
 
 } // end namespace Catch

src/catch2/internal/catch_test_case_registry_impl.cpp

@@ -10,7 +10,7 @@
 #include <catch2/internal/catch_context.hpp>
 #include <catch2/internal/catch_enforce.hpp>
 #include <catch2/interfaces/catch_interfaces_config.hpp>
-#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
+#include <catch2/internal/catch_registry_hub.hpp>
 #include <catch2/internal/catch_random_number_generator.hpp>
 #include <catch2/internal/catch_run_context.hpp>
 #include <catch2/internal/catch_sharding.hpp>
@@ -25,6 +25,13 @@
 namespace Catch {
 
     namespace {
+        static bool matchTest( TestCaseHandle const& testCase,
+                               TestSpec const& testSpec,
+                               IConfig const& config ) {
+            return testSpec.matches( testCase.getTestCaseInfo() ) &&
+                   isThrowSafe( testCase, config );
+        }
+
         static void enforceNoDuplicateTestCases(
             std::vector<TestCaseHandle> const& tests ) {
             auto testInfoCmp = []( TestCaseInfo const* lhs,
@@ -46,15 +53,24 @@ namespace Catch {
                                    << "\tRedefined at " << infoPtr->lineInfo );
             }
         }
+    } // namespace
 
-        static bool matchTest( TestCaseHandle const& testCase,
-                               TestSpec const& testSpec,
-                               IConfig const& config ) {
-            return testSpec.matches( testCase.getTestCaseInfo() ) &&
-                   isThrowSafe( testCase, config );
-        }
+    struct TestCaseRegistry::TestCaseRegistryImpl {
+        std::vector<Detail::unique_ptr<TestCaseInfo>> owned_test_infos;
+        // Keeps a materialized vector for `getAllInfos`.
+        // We should get rid of that eventually (see interface note)
+        std::vector<TestCaseInfo*> viewed_test_infos;
+
+        std::vector<Detail::unique_ptr<ITestInvoker>> invokers;
+        std::vector<TestCaseHandle> handles;
+        mutable TestRunOrder currentSortOrder = TestRunOrder::Declared;
+        mutable std::vector<TestCaseHandle> sortedFunctions;
+    };
+
+    TestCaseRegistry::TestCaseRegistry():
+        m_impl( Detail::make_unique<TestCaseRegistryImpl>() ) {}
+    TestCaseRegistry ::~TestCaseRegistry() = default;
 
-    } // end unnamed namespace
 
     std::vector<TestCaseHandle> sortTests( IConfig const& config, std::vector<TestCaseHandle> const& unsortedTestCases ) {
         switch (config.runOrder()) {
@@ -127,29 +143,29 @@ namespace Catch {
         return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
     }
 
-    void TestRegistry::registerTest(Detail::unique_ptr<TestCaseInfo> testInfo, Detail::unique_ptr<ITestInvoker> testInvoker) {
-        m_handles.emplace_back(testInfo.get(), testInvoker.get());
-        m_viewed_test_infos.push_back(testInfo.get());
-        m_owned_test_infos.push_back(CATCH_MOVE(testInfo));
-        m_invokers.push_back(CATCH_MOVE(testInvoker));
+    void TestCaseRegistry::registerTest(Detail::unique_ptr<TestCaseInfo> testInfo, Detail::unique_ptr<ITestInvoker> testInvoker) {
+        m_impl->handles.emplace_back(testInfo.get(), testInvoker.get());
+        m_impl->viewed_test_infos.push_back(testInfo.get());
+        m_impl->owned_test_infos.push_back(CATCH_MOVE(testInfo));
+        m_impl->invokers.push_back(CATCH_MOVE(testInvoker));
     }
 
-    std::vector<TestCaseInfo*> const& TestRegistry::getAllInfos() const {
-        return m_viewed_test_infos;
+    std::vector<TestCaseInfo*> const& TestCaseRegistry::getAllInfos() const {
+        return m_impl->viewed_test_infos;
     }
 
-    std::vector<TestCaseHandle> const& TestRegistry::getAllTests() const {
-        return m_handles;
+    std::vector<TestCaseHandle> const& TestCaseRegistry::getAllTests() const {
+        return m_impl->handles;
     }
-    std::vector<TestCaseHandle> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
-        if( m_sortedFunctions.empty() )
-            enforceNoDuplicateTestCases( m_handles );
+    std::vector<TestCaseHandle> const& TestCaseRegistry::getAllTestsSorted( IConfig const& config ) const {
+        if( m_impl->sortedFunctions.empty() )
+            enforceNoDuplicateTestCases( m_impl->handles );
 
-        if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
-            m_sortedFunctions = sortTests( config, m_handles );
-            m_currentSortOrder = config.runOrder();
+        if(  m_impl->currentSortOrder != config.runOrder() || m_impl->sortedFunctions.empty() ) {
+            m_impl->sortedFunctions = sortTests( config, m_impl->handles );
+            m_impl->currentSortOrder = config.runOrder();
         }
-        return m_sortedFunctions;
+        return m_impl->sortedFunctions;
     }
 
 } // end namespace Catch