Bump version to v3.0.0 preview 3

The problem was that Catch2 did not reliably include `<exception>`
before it checked for the feature test macro for
`std::uncaught_exceptions`. To avoid overhead of including
`<exception>` everywhere, the configuration check was split out
into a separate header.

Closes #2021

.clang-format

@@ -0,0 +1,25 @@
+---
+AccessModifierOffset: '-4'
+AlignEscapedNewlines: Left
+AllowAllConstructorInitializersOnNextLine: 'true'
+BinPackArguments: 'false'
+BinPackParameters: 'false'
+BreakConstructorInitializers: AfterColon
+ConstructorInitializerAllOnOneLineOrOnePerLine: 'true'
+DerivePointerAlignment: 'false'
+FixNamespaceComments: 'true'
+IncludeBlocks: Regroup
+IndentCaseLabels: 'false'
+IndentPPDirectives: AfterHash
+IndentWidth: '4'
+Language: Cpp
+NamespaceIndentation: All
+PointerAlignment: Left
+SpaceBeforeCtorInitializerColon: 'false'
+SpaceInEmptyParentheses: 'false'
+SpacesInParentheses: 'true'
+Standard: Cpp11
+TabWidth: '4'
+UseTab: Never
+
+...

.conan/build.py

@@ -31,7 +31,7 @@ class BuilderSettings(object):
             not match the stable pattern. Otherwise it will upload to stable
             channel.
         """
-        return os.getenv("CONAN_UPLOAD", "https://api.bintray.com/conan/catchorg/Catch2")
+        return os.getenv("CONAN_UPLOAD", "https://api.bintray.com/conan/catchorg/catch2")
 
     @property
     def upload_only_when_stable(self):
@@ -49,7 +49,7 @@ class BuilderSettings(object):
     def reference(self):
         """ Read project version from branch create Conan reference
         """
-        return os.getenv("CONAN_REFERENCE", "Catch2/{}".format(self._version))
+        return os.getenv("CONAN_REFERENCE", "catch2/{}".format(self._version))
 
     @property
     def channel(self):
@@ -85,7 +85,7 @@ if __name__ == "__main__":
         reference=settings.reference,
         channel=settings.channel,
         upload=settings.upload,
-        upload_only_when_stable=settings.upload_only_when_stable,
+        upload_only_when_stable=False,
         stable_branch_pattern=settings.stable_branch_pattern,
         login_username=settings.login_username,
         username=settings.username,

.conan/test_package/CMakeLists.txt

@@ -1,11 +1,19 @@
 cmake_minimum_required(VERSION 3.2.0)
 project(test_package CXX)
 
-include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
-conan_basic_setup(TARGETS)
+# We set it only for the convenience of calling the executable
+# in the package test function
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/bin)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_MINSIZEREL ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
 
 find_package(Catch2 REQUIRED CONFIG)
 
 add_executable(${PROJECT_NAME} test_package.cpp)
-target_link_libraries(${PROJECT_NAME} CONAN_PKG::Catch2)
+# Note: Conan 1.21 doesn't support granular target generation yet.
+# The Main library would be included into the unified target.
+# It's controlled by the `with_main` option in the recipe.
+target_link_libraries(${PROJECT_NAME} Catch2::Catch2)
 set_target_properties(${PROJECT_NAME} PROPERTIES CXX_STANDARD 14)

.conan/test_package/conanfile.py

@@ -6,7 +6,7 @@ import os
 
 class TestPackageConan(ConanFile):
     settings = "os", "compiler", "build_type", "arch"
-    generators = "cmake"
+    generators = "cmake_find_package_multi"
 
     def build(self):
         cmake = CMake(self)
@@ -14,6 +14,6 @@ class TestPackageConan(ConanFile):
         cmake.build()
 
     def test(self):
-        assert os.path.isfile(os.path.join(self.deps_cpp_info["Catch2"].rootpath, "licenses", "LICENSE.txt"))
+        assert os.path.isfile(os.path.join(self.deps_cpp_info["catch2"].rootpath, "licenses", "LICENSE.txt"))
         bin_path = os.path.join("bin", "test_package")
         self.run("%s -s" % bin_path, run_environment=True)

.conan/test_package/test_package.cpp

@@ -1,6 +1,4 @@
-#define CATCH_CONFIG_MAIN
-
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 
 int Factorial( int number ) {
     return number <= 1 ? 1 : Factorial( number - 1 ) * number;

.github/FUNDING.yml

@@ -1 +1 @@
-patreon: horenmar
+custom: "https://www.paypal.me/horenmar"

.gitignore

@@ -28,3 +28,5 @@ Build
 cmake-build-*
 benchmark-dir
 .conan/test_package/build
+bazel-*
+build-fuzzers

.travis.yml

@@ -158,22 +158,28 @@ matrix:
 
 
 
-#    # Special builds, e.g. conan
-#    - language: python
-#      python:
-#        - "3.7"
-#      install:
-#        - pip install conan-package-tools
-#      env:
-#        - CONAN_GCC_VERSIONS=8
-#        - CONAN_DOCKER_IMAGE=conanio/gcc8
-#        - CPP14=1
-#      script:
-#        - python .conan/build.py
+    # Special builds, e.g. conan
+    - language: python
+      python:
+        - "3.7"
+      install:
+        - pip install conan-package-tools
+      env:
+        - CONAN_GCC_VERSIONS=8
+        - CONAN_DOCKER_IMAGE=conanio/gcc8
+        - CPP14=1
+      script:
+        - python .conan/build.py
 
 before_script:
   - export CXX=${COMPILER}
   - cd ${TRAVIS_BUILD_DIR}
+  # We want to regenerate the amalgamated header if the extra tests
+  # are enabled.
+  - |
+    if [[ ${EXTRAS} -eq 1 ]]; then
+      python3 ./tools/scripts/generateAmalgamatedFiles.py
+    fi
 
   - |
     if [[ ${CPP17} -eq 1 ]]; then
@@ -185,9 +191,9 @@ before_script:
     fi
 
     # Use Debug builds for running Valgrind and building examples
-  - cmake -H. -BBuild-Debug -DCMAKE_BUILD_TYPE=Debug -Wdev -DCATCH_USE_VALGRIND=${VALGRIND} -DCATCH_BUILD_EXAMPLES=${EXAMPLES} -DCATCH_ENABLE_COVERAGE=${COVERAGE} -DCATCH_BUILD_EXTRA_TESTS=${EXTRAS} -DCMAKE_CXX_STANDARD=${CPP_STANDARD} -DCMAKE_CXX_STANDARD_REQUIRED=On -DCMAKE_CXX_EXTENSIONS=OFF
+  - cmake -H. -BBuild-Debug -DCMAKE_BUILD_TYPE=Debug -Wdev -DCATCH_USE_VALGRIND=${VALGRIND} -DCATCH_BUILD_EXAMPLES=${EXAMPLES} -DCATCH_ENABLE_COVERAGE=${COVERAGE} -DCATCH_BUILD_EXTRA_TESTS=${EXTRAS} -DCMAKE_CXX_STANDARD=${CPP_STANDARD} -DCMAKE_CXX_STANDARD_REQUIRED=On -DCMAKE_CXX_EXTENSIONS=OFF -DCATCH_DEVELOPMENT_BUILD=ON
     # Don't bother with release build for coverage build
-  - cmake -H. -BBuild-Release -DCMAKE_BUILD_TYPE=Release -Wdev -DCMAKE_CXX_STANDARD=${CPP_STANDARD} -DCMAKE_CXX_STANDARD_REQUIRED=On -DCMAKE_CXX_EXTENSIONS=OFF
+  - cmake -H. -BBuild-Release -DCMAKE_BUILD_TYPE=Release -Wdev -DCMAKE_CXX_STANDARD=${CPP_STANDARD} -DCMAKE_CXX_STANDARD_REQUIRED=On -DCMAKE_CXX_EXTENSIONS=OFF -DCATCH_DEVELOPMENT_BUILD=ON
 
 
 script:

BUILD.bazel

@@ -0,0 +1,25 @@
+# Load the cc_library rule.
+load("@rules_cc//cc:defs.bzl", "cc_library")
+
+# Static library, without main.
+cc_library(
+    name = "catch2",
+    hdrs = glob(["src/catch2/**/*.hpp"]),
+    srcs = glob(["src/catch2/**/*.cpp"],
+                exclude=[ "src/catch2/internal/catch_main.cpp"]),
+    visibility = ["//visibility:public"],
+    copts = ["-std=c++14"],
+    linkstatic = True,
+    includes = ["src/"],
+)
+
+# Static library, with main.
+cc_library(
+    name = "catch2_main",
+    srcs = ["src/catch2/internal/catch_main.cpp"],
+    deps = [":catch2"],
+    visibility = ["//visibility:public"],
+    linkstatic = True,
+    copts = ["-std=c++14"],
+    includes = ["src/"],
+)

CMake/MiscFunctions.cmake

@@ -1,26 +1,78 @@
-#checks that the given hard-coded list contains all headers + sources in the given folder
-function(CheckFileList LIST_VAR FOLDER)
-  set(MESSAGE " should be added to the variable ${LIST_VAR}")
-  set(MESSAGE "${MESSAGE} in ${CMAKE_CURRENT_LIST_FILE}\n")
-  file(GLOB GLOBBED_LIST "${FOLDER}/*.cpp"
-                         "${FOLDER}/*.hpp"
-                         "${FOLDER}/*.h")
-  list(REMOVE_ITEM GLOBBED_LIST ${${LIST_VAR}})
-  foreach(EXTRA_ITEM ${GLOBBED_LIST})
-    string(REPLACE "${CATCH_DIR}/" "" RELATIVE_FILE_NAME "${EXTRA_ITEM}")
-    message(AUTHOR_WARNING "The file \"${RELATIVE_FILE_NAME}\"${MESSAGE}")
-  endforeach()
+include(CheckCXXCompilerFlag)
+function(add_cxx_flag_if_supported_to_targets flagname targets)
+    check_cxx_compiler_flag("${flagname}" HAVE_FLAG_${flagname})
+
+    if (HAVE_FLAG_${flagname})
+        foreach(target ${targets})
+            target_compile_options(${target} PUBLIC ${flagname})
+        endforeach()
+    endif()
 endfunction()
 
-function(CheckFileListRec LIST_VAR FOLDER)
-  set(MESSAGE " should be added to the variable ${LIST_VAR}")
-  set(MESSAGE "${MESSAGE} in ${CMAKE_CURRENT_LIST_FILE}\n")
-  file(GLOB_RECURSE GLOBBED_LIST "${FOLDER}/*.cpp"
-                                 "${FOLDER}/*.hpp"
-                                 "${FOLDER}/*.h")
-  list(REMOVE_ITEM GLOBBED_LIST ${${LIST_VAR}})
-  foreach(EXTRA_ITEM ${GLOBBED_LIST})
-    string(REPLACE "${CATCH_DIR}/" "" RELATIVE_FILE_NAME "${EXTRA_ITEM}")
-    message(AUTHOR_WARNING "The file \"${RELATIVE_FILE_NAME}\"${MESSAGE}")
-  endforeach()
+# Assumes that it is only called for development builds, where warnings
+# and Werror is desired, so it also enables Werror.
+function(add_warnings_to_targets targets)
+    LIST(LENGTH targets TARGETS_LEN)
+    # For now we just assume 2 possibilities: msvc and msvc-like compilers,
+    # and other.
+    if (MSVC)
+        foreach(target ${targets})
+            # Force MSVC to consider everything as encoded in utf-8
+            target_compile_options( ${target} PRIVATE /utf-8 )
+            # Enable Werror equivalent
+            if (CATCH_ENABLE_WERROR)
+                target_compile_options( ${target} PRIVATE /WX )
+            endif()
+
+            # MSVC is currently handled specially
+            if ( CMAKE_CXX_COMPILER_ID MATCHES "MSVC" )
+                STRING(REGEX REPLACE "/W[0-9]" "/W4" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS}) # override default warning level
+                target_compile_options( ${target} PRIVATE /w44265 /w44061 /w44062 /w45038 )
+            endif()
+        endforeach()
+
+    endif()
+
+    if (NOT MSVC)
+        set(CHECKED_WARNING_FLAGS
+          "-Wall"
+          "-Wextra"
+          "-Wpedantic"
+          "-Wweak-vtables"
+          "-Wunreachable-code"
+          "-Wmissing-declarations"
+          "-Wexit-time-destructors"
+          "-Wglobal-constructors"
+          "-Wmissing-noreturn"
+          "-Wparentheses"
+          "-Wextra-semi-stmt"
+          "-Wunreachable-code"
+          "-Wstrict-aliasing"
+          "-Wreturn-std-move"
+          "-Wmissing-braces"
+          "-Wdeprecated"
+          "-Wvla"
+          "-Wundef"
+          "-Wmisleading-indentation"
+          "-Wcatch-value"
+          "-Wabsolute-value"
+          "-Wreturn-std-move"
+          "-Wunused-parameter"
+          "-Wunused-function"
+          "-Wcall-to-pure-virtual-from-ctor-dtor"
+          "-Wdeprecated-register"
+          "-Wsuggest-override"
+          "-Wshadow"
+        )
+        foreach(warning ${CHECKED_WARNING_FLAGS})
+            add_cxx_flag_if_supported_to_targets(${warning} "${targets}")
+        endforeach()
+
+        if (CATCH_ENABLE_WERROR)
+            foreach(target ${targets})
+                # Enable Werror equivalent
+                target_compile_options( ${target} PRIVATE -Werror )
+            endforeach()
+        endif()
+    endif()
 endfunction()

CMake/catch2-with-main.pc.in

@@ -0,0 +1,10 @@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+pkg_version=@Catch2_VERSION@
+
+Name: Catch2-With-Main
+Description: A modern, C++-native test framework for C++14 and above (links in default main)
+Version: ${pkg_version}
+Requires: catch2 = ${pkg_version}
+Cflags: -I${includedir}
+Libs: -L${libdir} -lCatch2WithMain

CMake/catch2.pc.in

@@ -1,7 +1,9 @@
 includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
 
 Name: Catch2
-Description: A modern, C++-native, header-only, test framework for C++11
+Description: A modern, C++-native, test framework for C++14 and above
 URL: https://github.com/catchorg/Catch2
 Version: @Catch2_VERSION@
 Cflags: -I${includedir}
+Libs: -L${libdir} -lCatch2

CMakeLists.txt

@@ -6,16 +6,17 @@ if(NOT DEFINED PROJECT_NAME)
   set(NOT_SUBPROJECT ON)
 endif()
 
-option(CATCH_BUILD_TESTING "Build SelfTest project" ON)
-option(CATCH_BUILD_EXAMPLES "Build documentation examples" OFF)
-option(CATCH_BUILD_EXTRA_TESTS "Build extra tests" OFF)
-option(CATCH_ENABLE_COVERAGE "Generate coverage for codecov.io" OFF)
 option(CATCH_INSTALL_DOCS "Install documentation alongside library" ON)
 option(CATCH_INSTALL_EXTRAS "Install extras alongside library" ON)
+option(CATCH_DEVELOPMENT_BUILD "Build tests, enable warnings, enable Werror, etc" OFF)
 
-
-set(CATCH_CMAKE_CONFIG_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/Catch2")
-
+include(CMakeDependentOption)
+cmake_dependent_option(CATCH_BUILD_TESTING "Build the SelfTest project" ON "CATCH_DEVELOPMENT_BUILD" OFF)
+cmake_dependent_option(CATCH_BUILD_EXAMPLES "Build code examples" OFF "CATCH_DEVELOPMENT_BUILD" OFF)
+cmake_dependent_option(CATCH_BUILD_EXTRA_TESTS "Build extra tests" OFF "CATCH_DEVELOPMENT_BUILD" OFF)
+cmake_dependent_option(CATCH_BUILD_FUZZERS "Build fuzzers" OFF "CATCH_DEVELOPMENT_BUILD" OFF)
+cmake_dependent_option(CATCH_ENABLE_COVERAGE "Generate coverage for codecov.io" OFF "CATCH_DEVELOPMENT_BUILD" OFF)
+cmake_dependent_option(CATCH_ENABLE_WERROR "Enables Werror during build" ON "CATCH_DEVELOPMENT_BUILD" OFF)
 
 # Catch2's build breaks if done in-tree. You probably should not build
 # things in tree anyway, but we can allow projects that include Catch2
@@ -25,15 +26,27 @@ if (CMAKE_BINARY_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
 endif()
 
 
-project(Catch2 LANGUAGES CXX VERSION 2.10.2)
+project(Catch2 LANGUAGES CXX VERSION 3.0.0)
 
 # Provide path for scripts
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/CMake")
-
 include(GNUInstallDirs)
 include(CMakePackageConfigHelpers)
 include(CTest)
 
+# This variable is used in some subdirectories, so we need it here, rather
+# than later in the install block
+set(CATCH_CMAKE_CONFIG_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/Catch2")
+
+# We have some Windows builds that test `wmain` entry point,
+# and we need this change to be present in all binaries that
+# are built during these tests, so this is required here, before
+# the subdirectories are added.
+if(CATCH_TEST_USE_WMAIN)
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /ENTRY:wmainCRTStartup")
+endif()
+
+
 # Basic paths
 set(CATCH_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(SOURCES_DIR ${CATCH_DIR}/src/catch2)
@@ -46,7 +59,7 @@ add_subdirectory(src)
 
 # Build tests only if requested
 if (BUILD_TESTING AND CATCH_BUILD_TESTING AND NOT_SUBPROJECT)
-    find_package(PythonInterp)
+    find_package(PythonInterp 3 REQUIRED)
     if (NOT PYTHONINTERP_FOUND)
         message(FATAL_ERROR "Python not found, but required for tests")
     endif()
@@ -61,14 +74,20 @@ if(CATCH_BUILD_EXTRA_TESTS)
     add_subdirectory(tests/ExtraTests)
 endif()
 
+if(CATCH_BUILD_FUZZERS)
+    add_subdirectory(fuzzing)
+endif()
+
+if (CATCH_DEVELOPMENT_BUILD)
+    add_warnings_to_targets("${CATCH_WARNING_TARGETS}")
+endif()
+
+
 #option(CATCH_USE_VALGRIND "Perform SelfTests with Valgrind" OFF)
 #option(CATCH_ENABLE_WERROR "Enable all warnings as errors" ON)
 #
 #set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 #
-#if(USE_WMAIN)
-#    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /ENTRY:wmainCRTStartup")
-#endif()
 #
 #
 #
@@ -77,7 +96,6 @@ endif()
 # a subproject via `add_subdirectory`, or the destinations will break,
 # see https://github.com/catchorg/Catch2/issues/1373
 if (NOT_SUBPROJECT)
-
     configure_package_config_file(
         ${CMAKE_CURRENT_LIST_DIR}/CMake/Catch2Config.cmake.in
         ${CMAKE_CURRENT_BINARY_DIR}/Catch2Config.cmake
@@ -125,25 +143,25 @@ if (NOT_SUBPROJECT)
       )
     endif()
 
-    if(CATCH_INSTALL_HELPERS)
-    # Install CMake scripts
-    install(
-      FILES
-        "extras/ParseAndAddCatchTests.cmake"
-        "extras/Catch.cmake"
-        "extras/CatchAddTests.cmake"
-      DESTINATION
-        ${CATCH_CMAKE_CONFIG_DESTINATION}
-    )
-
-    # Install debugger helpers
-    install(
-      FILES
-        "extras/gdbinit"
-        "extras/lldbinit"
-      DESTINATION
-        ${CMAKE_INSTALL_DATAROOTDIR}/Catch2
-    )
+    if(CATCH_INSTALL_EXTRAS)
+        # Install CMake scripts
+        install(
+          FILES
+            "extras/ParseAndAddCatchTests.cmake"
+            "extras/Catch.cmake"
+            "extras/CatchAddTests.cmake"
+          DESTINATION
+            ${CATCH_CMAKE_CONFIG_DESTINATION}
+        )
+    
+        # Install debugger helpers
+        install(
+          FILES
+            "extras/gdbinit"
+            "extras/lldbinit"
+          DESTINATION
+            ${CMAKE_INSTALL_DATAROOTDIR}/Catch2
+        )
     endif()
 
     ## Provide some pkg-config integration
@@ -156,9 +174,15 @@ if (NOT_SUBPROJECT)
       ${CMAKE_CURRENT_BINARY_DIR}/catch2.pc
       @ONLY
     )
+    configure_file(
+      ${CMAKE_CURRENT_SOURCE_DIR}/CMake/catch2-with-main.pc.in
+      ${CMAKE_CURRENT_BINARY_DIR}/catch2-with-main.pc
+      @ONLY
+    )
     install(
       FILES
         "${CMAKE_CURRENT_BINARY_DIR}/catch2.pc"
+        "${CMAKE_CURRENT_BINARY_DIR}/catch2-with-main.pc"
       DESTINATION
         ${PKGCONFIG_INSTALL_DIR}
     )

README.md

@@ -5,12 +5,11 @@
 [![Build Status](https://travis-ci.org/catchorg/Catch2.svg?branch=master)](https://travis-ci.org/catchorg/Catch2)
 [![Build status](https://ci.appveyor.com/api/projects/status/github/catchorg/Catch2?svg=true)](https://ci.appveyor.com/project/catchorg/catch2)
 [![codecov](https://codecov.io/gh/catchorg/Catch2/branch/master/graph/badge.svg)](https://codecov.io/gh/catchorg/Catch2)
-[![Try online](https://img.shields.io/badge/try-online-blue.svg)](https://wandbox.org/permlink/LzYWgcPrcy9yQmed)
+<!-- We can eventually bring this back, but the upload script will have to be more complex -->
+<!-- [![Try online](https://img.shields.io/badge/try-online-blue.svg)](https://wandbox.org/permlink/LzYWgcPrcy9yQmed) -->
 [![Join the chat in Discord: https://discord.gg/4CWS9zD](https://img.shields.io/badge/Discord-Chat!-brightgreen.svg)](https://discord.gg/4CWS9zD)
 
 
-<a href="https://github.com/catchorg/Catch2/releases/download/v2.10.2/catch.hpp">The latest version of the single header can be downloaded directly using this link</a>
-
 ## Catch2 is released!
 
 If you've been using an earlier version of Catch, please see the
@@ -19,10 +18,7 @@ before moving to Catch2. You might also like to read [this blog post](https://le
 
 ## What's the Catch?
 
-Catch2 is a multi-paradigm test framework for C++. which also supports
-Objective-C (and maybe C).
-It is primarily distributed as a single header file, although certain
-extensions may require additional headers.
+Catch2 is a multi-paradigm test framework for C++.
 
 ## How to use it
 This documentation comprises these three parts:

appveyor.yml

@@ -13,7 +13,7 @@ branches:
 
 # We need a more up to date pip because Python 2.7 is EOL soon
 init:
-  - set PATH=C:\Python35\Scripts;%PATH%
+  - set PATH=C:\Python35;C:\Python35\Scripts;%PATH%
 
 
 install:
@@ -23,6 +23,8 @@ install:
 
 before_build:
   - set CXXFLAGS=%additional_flags%
+  # If we are building examples/extra-tests, we need to regenerate the amalgamated files
+  - cmd: if "%examples%"=="1" ( python .\tools\scripts\generateAmalgamatedFiles.py )
   # Indirection because appveyor doesn't handle multiline batch scripts properly
   # https://stackoverflow.com/questions/37627248/how-to-split-a-command-over-multiple-lines-in-appveyor-yml/37647169#37647169
   # https://help.appveyor.com/discussions/questions/3888-multi-line-cmd-or-powershell-warning-ignore
@@ -56,15 +58,10 @@ environment:
       platform: x64
       configuration: Release
 
-    - FLAVOR: VS 2019 x64 Debug Coverage
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      coverage: 1
-      platform: x64
-      configuration: Debug
-
-    - FLAVOR: VS 2019 x64 Debug Examples
+    - FLAVOR: VS 2019 x64 Debug Coverage Examples
       APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
       examples: 1
+      coverage: 1
       platform: x64
       configuration: Debug
 
@@ -107,15 +104,11 @@ environment:
       platform: Win32
       configuration: Debug
 
-# This build causes error after 30 minutes, because the VS2017 image
-# tries to launch just-in-time debugger on call to std::terminate, which
-# is an expected part of the tests in this build.
-# We can reenable it, if we handle disabling that test in CMake.
-#    - FLAVOR: VS 2017 Win32 Debug Examples
-#      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-#      examples: 1
-#      platform: Win32
-#      configuration: Debug
+    - FLAVOR: VS 2017 Win32 Debug Examples
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      examples: 1
+      platform: Win32
+      configuration: Debug
 
     - FLAVOR: VS 2017 Win32 Debug WMain
       APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017

codecov.yml

@@ -11,10 +11,12 @@ coverage:
         target: 80%
   ignore:
     - "**/external/clara.hpp"
+    - "tests"
 
 
 codecov:
   branch: master
+  max_report_age: off
 
 comment:
   layout: "diff"

conanfile.py

@@ -3,25 +3,43 @@ from conans import ConanFile, CMake
 
 
 class CatchConan(ConanFile):
-    name = "Catch2"
-    description = "A modern, C++-native, header-only, framework for unit-tests, TDD and BDD"
-    topics = ("conan", "catch2", "header-only", "unit-test", "tdd", "bdd")
+    name = "catch2"
+    description = "A modern, C++-native, framework for unit-tests, TDD and BDD"
+    topics = ("conan", "catch2", "unit-test", "tdd", "bdd")
     url = "https://github.com/catchorg/Catch2"
     homepage = url
     license = "BSL-1.0"
-    exports = "LICENSE.txt"
-    exports_sources = ("single_include/*", "CMakeLists.txt", "CMake/*", "contrib/*")
-    generators = "cmake"
 
-    def package(self):
+    exports = "LICENSE.txt"
+    exports_sources = ("src/*", "CMakeLists.txt", "CMake/*", "extras/*")
+
+    settings = "os", "compiler", "build_type", "arch"
+
+    options = {"with_main": [True, False]}
+    default_options = {"with_main": True}
+
+    def _configure_cmake(self):
         cmake = CMake(self)
         cmake.definitions["BUILD_TESTING"] = "OFF"
         cmake.definitions["CATCH_INSTALL_DOCS"] = "OFF"
         cmake.definitions["CATCH_INSTALL_HELPERS"] = "ON"
-        cmake.configure(build_folder='build')
+        cmake.configure(build_folder="build")
+        return cmake
+
+    def build(self):
+        cmake = self._configure_cmake()
+        cmake.build()
+
+    def package(self):
+        self.copy(pattern="LICENSE.txt", dst="licenses")
+        cmake = self._configure_cmake()
         cmake.install()
 
-        self.copy(pattern="LICENSE.txt", dst="licenses")
-
     def package_id(self):
-        self.info.header_only()
+        del self.info.options.with_main
+
+    def package_info(self):
+        self.cpp_info.libs = [
+            'Catch2Main', 'Catch2'] if self.options.with_main else ['Catch2']
+        self.cpp_info.names["cmake_find_package"] = "Catch2"
+        self.cpp_info.names["cmake_find_package_multi"] = "Catch2"

docs/Readme.md

@@ -35,6 +35,7 @@ FAQ:
 Other:
 * [Why Catch?](why-catch.md#top)
 * [Open Source Projects using Catch](opensource-users.md#top)
+* [Commercial Projects using Catch](commercial-users.md#top)
 * [Contributing](contributing.md#top)
 * [Release Notes](release-notes.md#top)
 * [Deprecations and incoming changes](deprecations.md#top)

docs/benchmarks.md

@@ -3,10 +3,6 @@
 
 > [Introduced](https://github.com/catchorg/Catch2/issues/1616) in Catch 2.9.0.
 
-_Note that benchmarking support is disabled by default and to enable it,
-you need to define `CATCH_CONFIG_ENABLE_BENCHMARKING`. For more details,
-see the [compile-time configuration documentation](configuration.md#top)._
-
 Writing benchmarks is not easy. Catch simplifies certain aspects but you'll
 always need to take care about various aspects. Understanding a few things about
 the way Catch runs your code will be very helpful when writing your benchmarks.
@@ -168,7 +164,7 @@ Note that it is not possible to simply use the same instance for different runs
 and resetting it between each run since that would pollute the measurements with
 the resetting code.
 
-It is also possible to just provide an argument name to the simple `BENCHMARK` macro to get 
+It is also possible to just provide an argument name to the simple `BENCHMARK` macro to get
 the same semantics as providing a callable to `meter.measure` with `int` argument:
 
 ```c++
@@ -189,19 +185,17 @@ construct and destroy objects without dynamic allocation and in a way that lets
 you measure construction and destruction separately.
 
 ```c++
-BENCHMARK_ADVANCED("construct")(Catch::Benchmark::Chronometer meter)
-{
+BENCHMARK_ADVANCED("construct")(Catch::Benchmark::Chronometer meter) {
     std::vector<Catch::Benchmark::storage_for<std::string>> storage(meter.runs());
     meter.measure([&](int i) { storage[i].construct("thing"); });
-})
+};
 
-BENCHMARK_ADVANCED("destroy", [](Catch::Benchmark::Chronometer meter)
-{
+BENCHMARK_ADVANCED("destroy")(Catch::Benchmark::Chronometer meter) {
     std::vector<Catch::Benchmark::destructable_object<std::string>> storage(meter.runs());
     for(auto&& o : storage)
         o.construct("thing");
     meter.measure([&](int i) { storage[i].destruct(); });
-})
+};
 ```
 
 `Catch::Benchmark::storage_for<T>` objects are just pieces of raw storage suitable for `T`

docs/cmake-integration.md

@@ -6,6 +6,7 @@
 [Automatic test registration](#automatic-test-registration)<br>
 [CMake project options](#cmake-project-options)<br>
 [Installing Catch2 from git repository](#installing-catch2-from-git-repository)<br>
+[Installing Catch2 from vcpkg](#installing-catch2-from-vcpkg)<br>
 
 Because we use CMake to build Catch2, we also provide a couple of
 integration points for our users.
@@ -35,6 +36,20 @@ add_subdirectory(lib/Catch2)
 target_link_libraries(tests Catch2::Catch2)
 ```
 
+Another possibility is to use [FetchContent](https://cmake.org/cmake/help/latest/module/FetchContent.html):
+```cmake
+Include(FetchContent)
+
+FetchContent_Declare(
+  Catch2
+  GIT_REPOSITORY https://github.com/catchorg/Catch2.git
+  GIT_TAG        v2.13.1)
+
+FetchContent_MakeAvailable(Catch2)
+
+target_link_libraries(tests Catch2::Catch2)
+```
+
 ## Automatic test registration
 
 Catch2's repository also contains two CMake scripts that help users
@@ -82,6 +97,10 @@ catch_discover_tests(target
                      [TEST_SUFFIX suffix]
                      [PROPERTIES name1 value1...]
                      [TEST_LIST var]
+                     [REPORTER reporter]
+                     [OUTPUT_DIR dir]
+                     [OUTPUT_PREFIX prefix]
+                     [OUTPUT_SUFFIX suffix]
 )
 ```
 
@@ -128,6 +147,32 @@ default `<target>_TESTS`.  This can be useful when the same test
 executable is being used in multiple calls to `catch_discover_tests()`.
 Note that this variable is only available in CTest.
 
+* `REPORTER reporter`
+
+Use the specified reporter when running the test case. The reporter will
+be passed to the test runner as `--reporter reporter`.
+
+* `OUTPUT_DIR dir`
+
+If specified, the parameter is passed along as
+`--out dir/<test_name>` to test executable. The actual file name is the
+same as the test name. This should be used instead of
+`EXTRA_ARGS --out foo` to avoid race conditions writing the result output
+when using parallel test execution.
+
+* `OUTPUT_PREFIX prefix`
+
+May be used in conjunction with `OUTPUT_DIR`.
+If specified, `prefix` is added to each output file name, like so
+`--out dir/prefix<test_name>`.
+
+* `OUTPUT_SUFFIX suffix`
+
+May be used in conjunction with `OUTPUT_DIR`.
+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".
+
 
 ### `ParseAndAddCatchTests.cmake`
 
@@ -160,7 +205,7 @@ ParseAndAddCatchTests(foo)
 * `PARSE_CATCH_TESTS_VERBOSE` -- When `ON`, the script prints debug
 messages. Defaults to `OFF`.
 * `PARSE_CATCH_TESTS_NO_HIDDEN_TESTS` -- When `ON`, hidden tests (tests
-tagged with any of `[!hide]`, `[.]` or `[.foo]`) will not be registered.
+tagged with either of `[.]` or `[.foo]`) will not be registered.
 Defaults to `OFF`.
 * `PARSE_CATCH_TESTS_ADD_FIXTURE_IN_TEST_NAME` -- When `ON`, adds fixture
 class name to the test name in CTest. Defaults to `ON`.
@@ -220,6 +265,19 @@ when configuring the build, and then modify your calls to
 [find_package](https://cmake.org/cmake/help/latest/command/find_package.html)
 accordingly.
 
+## Installing Catch2 from vcpkg
+
+Alternatively, you can build and install Catch2 using [vcpkg](https://github.com/microsoft/vcpkg/) dependency manager:
+```
+git clone https://github.com/Microsoft/vcpkg.git
+cd vcpkg
+./bootstrap-vcpkg.sh
+./vcpkg integrate install
+./vcpkg install catch2
+```
+
+The catch2 port in vcpkg is kept up to date by microsoft team members and community contributors.
+If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
 
 ---
 

docs/command-line.md

@@ -24,6 +24,7 @@
 [Specify the number of resamples for bootstrapping](#specify-the-number-of-resamples-for-bootstrapping)<br>
 [Specify the confidence-interval for bootstrapping](#specify-the-confidence-interval-for-bootstrapping)<br>
 [Disable statistical analysis of collected benchmark samples](#disable-statistical-analysis-of-collected-benchmark-samples)<br>
+[Specify the amount of time in milliseconds spent on warming up each test](#specify-the-amount-of-time-in-milliseconds-spent-on-warming-up-each-test)<br>
 [Usage](#usage)<br>
 [Specify the section to run](#specify-the-section-to-run)<br>
 [Filenames as tags](#filenames-as-tags)<br>
@@ -64,6 +65,7 @@ Click one of the following links to take you straight to that option - or scroll
 <a href="#benchmark-resamples">                         `    --benchmark-resamples`</a><br />
 <a href="#benchmark-confidence-interval">               `    --benchmark-confidence-interval`</a><br />
 <a href="#benchmark-no-analysis">                       `    --benchmark-no-analysis`</a><br />
+<a href="#benchmark-warmup-time">                       `    --benchmark-warmup-time`</a><br />
 <a href="#use-colour">                                  `    --use-colour`</a><br />
 
 </br>
@@ -220,6 +222,16 @@ available warnings
 
 When set to ```yes``` Catch will report the duration of each test case, in milliseconds. Note that it does this regardless of whether a test case passes or fails. Note, also, the certain reporters (e.g. Junit) always report test case durations regardless of this option being set or not.
 
+<pre>-D, --min-duration &lt;value></pre>
+
+> `--min-duration` was [introduced](https://github.com/catchorg/Catch2/pull/1910) in Catch 2.13.0
+
+When set, Catch will report the duration of each test case that took more
+than &lt;value> seconds, in milliseconds. This option is overriden by both
+`-d yes` and `-d no`, so that either all durations are reported, or none
+are.
+
+
 <a id="input-file"></a>
 ## Load test names to run from a file
 <pre>-f, --input-file &lt;filename></pre>
@@ -241,15 +253,25 @@ This option lists all available tests in a non-indented form, one on each line.
 
 Test cases are ordered one of three ways:
 
-
 ### decl
-Declaration order (this is the default order if no --order argument is provided). The order the tests were originally declared in. Note that ordering between files is not guaranteed and is implementation dependent.
+Declaration order (this is the default order if no --order argument is provided).
+Tests in the same TU are sorted using their declaration orders, different
+TUs are in an implementation (linking) dependent order.
+
 
 ### lex
-Lexicographically sorted. Tests are sorted, alpha-numerically, by name.
+Lexicographic order. Tests are sorted by their name, their tags are ignored.
+
 
 ### rand
-Randomly sorted. Test names are sorted using ```std::random_shuffle()```. By default the random number generator is seeded with 0 - and so the order is repeatable. To control the random seed see <a href="#rng-seed">rng-seed</a>.
+
+Randomly sorted. The order is dependent on Catch2's random seed (see
+[`--rng-seed`](#rng-seed)), and is subset invariant. What this means
+is that as long as the random seed is fixed, running only some tests
+(e.g. via tag) does not change their relative order.
+
+> The subset stability was introduced in Catch2 v2.12.0
+
 
 <a id="rng-seed"></a>
 ## Specify a seed for the Random Number Generator
@@ -269,7 +291,7 @@ See [The LibIdentify repo for more information and examples](https://github.com/
 
 <a id="wait-for-keypress"></a>
 ## Wait for key before continuing
-<pre>--wait-for-keypress &lt;start|exit|both&gt;</pre>
+<pre>--wait-for-keypress &lt;never|start|exit|both&gt;</pre>
 
 Will cause the executable to print a message and wait until the return/ enter key is pressed before continuing -
 either before running any tests, after running all tests - or both, depending on the argument.
@@ -317,6 +339,14 @@ Must be between 0 and 1 and defaults to 0.95.
 When this flag is specified no bootstrapping or any other statistical analysis is performed.
 Instead the user code is only measured and the plain mean from the samples is reported.
 
+<a id="benchmark-warmup-time"></a>
+## Specify the amount of time in milliseconds spent on warming up each test
+<pre>--benchmark-warmup-time</pre>
+
+> [Introduced](https://github.com/catchorg/Catch2/pull/1844) in Catch 2.11.2.
+
+Configure the amount of time spent warming up each test.
+
 <a id="usage"></a>
 ## Usage
 <pre>-h, -?, --help</pre>

docs/commercial-users.md

@@ -17,4 +17,6 @@ fact then please let us know - either directly, via a PR or
  - NASA
  - [Inscopix Inc.](https://www.inscopix.com/)
  - [Makimo](https://makimo.pl/)
- - [UX3D] (https://ux3d.io)
+ - [UX3D](https://ux3d.io)
+ - [King](https://king.com)
+ 

docs/configuration.md

@@ -2,8 +2,6 @@
 # Compile-time configuration
 
 **Contents**<br>
-[main()/ implementation](#main-implementation)<br>
-[Reporter / Listener interfaces](#reporter--listener-interfaces)<br>
 [Prefixing Catch macros](#prefixing-catch-macros)<br>
 [Terminal colour](#terminal-colour)<br>
 [Console width](#console-width)<br>
@@ -16,25 +14,12 @@
 [Windows header clutter](#windows-header-clutter)<br>
 [Enabling stringification](#enabling-stringification)<br>
 [Disabling exceptions](#disabling-exceptions)<br>
+[Overriding Catch's debug break (`-b`)](#overriding-catchs-debug-break--b)<br>
 
 Catch is designed to "just work" as much as possible. For most people the only configuration needed is telling Catch which source file should host all the implementation code (```CATCH_CONFIG_MAIN```).
 
 Nonetheless there are still some occasions where finer control is needed. For these occasions Catch exposes a set of macros for configuring how it is built.
 
-## main()/ implementation
-
-    CATCH_CONFIG_MAIN      // Designates this as implementation file and defines main()
-    CATCH_CONFIG_RUNNER    // Designates this as implementation file
-
-Although Catch is header only it still, internally, maintains a distinction between interface headers and headers that contain implementation. Only one source file in your test project should compile the implementation headers and this is controlled through the use of one of these macros - one of these identifiers should be defined before including Catch in *exactly one implementation file in your project*.
-
-## Reporter / Listener interfaces
-
-    CATCH_CONFIG_EXTERNAL_INTERFACES  // Brings in necessary headers for Reporter/Listener implementation
-
-Brings in various parts of Catch that are required for user defined Reporters and Listeners. This means that new Reporters and Listeners can be defined in this file as well as in the main file.
-
-Implied by both `CATCH_CONFIG_MAIN` and `CATCH_CONFIG_RUNNER`.
 
 ## Prefixing Catch macros
 
@@ -126,8 +111,8 @@ Catch's selection, by defining either `CATCH_CONFIG_CPP11_TO_STRING` or
 
 ## C++17 toggles
 
-    CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS  // Use std::uncaught_exceptions instead of std::uncaught_exception
-    CATCH_CONFIG_CPP17_STRING_VIEW          // Override std::string_view support detection(Catch provides a StringMaker specialization by default)
+    CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS  // Override std::uncaught_exceptions (instead of std::uncaught_exception) support detection
+    CATCH_CONFIG_CPP17_STRING_VIEW          // Override std::string_view support detection (Catch provides a StringMaker specialization by default)
     CATCH_CONFIG_CPP17_VARIANT              // Override std::variant support detection (checked by CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER)
     CATCH_CONFIG_CPP17_OPTIONAL             // Override std::optional support detection (checked by CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER)
     CATCH_CONFIG_CPP17_BYTE                 // Override std::byte support detection (Catch provides a StringMaker specialization by default)
@@ -146,14 +131,12 @@ by using `_NO_` in the macro, e.g. `CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS`.
     CATCH_CONFIG_COUNTER                    // Use __COUNTER__ to generate unique names for test cases
     CATCH_CONFIG_WINDOWS_SEH                // Enable SEH handling on Windows
     CATCH_CONFIG_FAST_COMPILE               // Sacrifices some (rather minor) features for compilation speed
-    CATCH_CONFIG_DISABLE_MATCHERS           // Do not compile Matchers in this compilation unit
     CATCH_CONFIG_POSIX_SIGNALS              // Enable handling POSIX signals
     CATCH_CONFIG_WINDOWS_CRTDBG             // Enable leak checking using Windows's CRT Debug Heap
     CATCH_CONFIG_DISABLE_STRINGIFICATION    // Disable stringifying the original expression
     CATCH_CONFIG_DISABLE                    // Disables assertions and test case registration
     CATCH_CONFIG_WCHAR                      // Enables use of wchart_t
     CATCH_CONFIG_EXPERIMENTAL_REDIRECT      // Enables the new (experimental) way of capturing stdout/stderr
-    CATCH_CONFIG_ENABLE_BENCHMARKING        // Enables the integrated benchmarking features (has a significant effect on compilation speed)
     CATCH_CONFIG_USE_ASYNC                  // Force parallel statistical processing of samples during benchmarking
     CATCH_CONFIG_ANDROID_LOGWRITE           // Use android's logging system for debug output
     CATCH_CONFIG_GLOBAL_NEXTAFTER           // Use nextafter{,f,l} instead of std::nextafter
@@ -164,7 +147,10 @@ Currently Catch enables `CATCH_CONFIG_WINDOWS_SEH` only when compiled with MSVC,
 
 `CATCH_CONFIG_POSIX_SIGNALS` is on by default, except when Catch is compiled under `Cygwin`, where it is disabled by default (but can be force-enabled by defining `CATCH_CONFIG_POSIX_SIGNALS`).
 
-`CATCH_CONFIG_WINDOWS_CRTDBG` is off by default. If enabled, Windows's CRT is used to check for memory leaks, and displays them after the tests finish running.
+`CATCH_CONFIG_WINDOWS_CRTDBG` is off by default. If enabled, Windows's
+CRT is used to check for memory leaks, and displays them after the tests
+finish running. This option only works when linking against the default
+main, and must be defined for the whole library build.
 
 `CATCH_CONFIG_WCHAR` is on by default, but can be disabled. Currently
 it is only used in support for DJGPP cross-compiler.
@@ -183,11 +169,6 @@ should not lead to false negatives.
 `CATCH_CONFIG_FAST_COMPILE` has to be either defined, or not defined,
 in all translation units that are linked into single test binary.
 
-### `CATCH_CONFIG_DISABLE_MATCHERS`
-When `CATCH_CONFIG_DISABLE_MATCHERS` is defined, all mentions of Catch's Matchers are ifdef-ed away from the translation unit. Doing so will speed up compilation of that TU.
-
-_Note: If you define `CATCH_CONFIG_DISABLE_MATCHERS` in the same file as Catch's main is implemented, your test executable will fail to link if you use Matchers anywhere._
-
 ### `CATCH_CONFIG_DISABLE_STRINGIFICATION`
 This toggle enables a workaround for VS 2017 bug. For details see [known limitations](limitations.md#visual-studio-2017----raw-string-literal-in-assert-fails-to-compile).
 
@@ -212,7 +193,6 @@ By default, Catch does not stringify some types from the standard library. This
 
     CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER     // Provide StringMaker specialization for std::pair
     CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER    // Provide StringMaker specialization for std::tuple
-    CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER   // Provide StringMaker specialization for std::chrono::duration, std::chrono::timepoint
     CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER  // Provide StringMaker specialization for std::variant, std::monostate (on C++17)
     CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER // Provide StringMaker specialization for std::optional (on C++17)
     CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS     // Defines all of the above
@@ -257,6 +237,18 @@ namespace Catch {
 }
 ```
 
+## Overriding Catch's debug break (`-b`)
+
+> [Introduced](https://github.com/catchorg/Catch2/pull/1846) in Catch 2.11.2.
+
+You can override Catch2's break-into-debugger code by defining the
+`CATCH_BREAK_INTO_DEBUGGER()` macro. This can be used if e.g. Catch2 does
+not know your platform, or your platform is misdetected.
+
+The macro will be used as is, that is, `CATCH_BREAK_INTO_DEBUGGER();`
+must compile and must break into debugger.
+
+
 ---
 
 [Home](Readme.md#top)

docs/contributing.md

@@ -1,100 +1,138 @@
 <a id="top"></a>
-# Contributing to Catch
+# Contributing to Catch2
 
 **Contents**<br>
-[Branches](#branches)<br>
-[Directory structure](#directory-structure)<br>
+[Using Git(Hub)](#using-github)<br>
 [Testing your changes](#testing-your-changes)<br>
-[Documenting your code](#documenting-your-code)<br>
-[Code constructs to watch out for](#code-constructs-to-watch-out-for)<br>
+[Writing documentation](#writing-documentation)<br>
+[Writing code](#writing-code)<br>
+[CoC](#coc)<br>
 
-So you want to contribute something to Catch? That's great! Whether it's a bug fix, a new feature, support for
-additional compilers - or just a fix to the documentation - all contributions are very welcome and very much appreciated.
-Of course so are bug reports and other comments and questions.
+So you want to contribute something to Catch2? That's great! Whether it's
+a bug fix, a new feature, support for additional compilers - or just
+a fix to the documentation - all contributions are very welcome and very
+much appreciated. Of course so are bug reports, other comments, and
+questions, but generally it is a better idea to ask questions in our
+[Discord](https://discord.gg/4CWS9zD), than in the issue tracker.
 
-If you are contributing to the code base there are a few simple guidelines to keep in mind. This also includes notes to
-help you find your way around. As this is liable to drift out of date please raise an issue or, better still, a pull
-request for this file, if you notice that.
 
-## Branches
+This page covers some guidelines and helpful tips for contributing
+to the codebase itself.
 
-Ongoing development is currently on _master_. At some point an integration branch will be set-up and PRs should target
- that - but for now it's all against master. You may see feature branches come and go from time to time, too.
+## Using Git(Hub)
 
-## Directory structure
+Ongoing development happens in the `devel` branch for Catch2 v3, and in
+`v2.x` for maintenance updates to the v2 versions.
 
-_Users_ of Catch primarily use the single header version. _Maintainers_ should work with the full source (which is still,
-primarily, in headers). This can be found in the `include` folder. There are a set of test files, currently under
-`projects/SelfTest`. The test app can be built via CMake from the `CMakeLists.txt` file in the root, or you can generate
-project files for Visual Studio, XCode, and others (instructions in the `projects` folder). If you have access to CLion,
-it can work with the CMake file directly.
+Commits should be small and atomic. A commit is atomic when, after it is
+applied, the codebase, tests and all, still works as expected. Small
+commits are also prefered, as they make later operations with git history,
+whether it is bisecting, reverting, or something else, easier.
 
-As well as the runtime test files you'll also see a `SurrogateCpps` directory under `projects/SelfTest`.
-This contains a set of .cpp files that each `#include` a single header.
-While these files are not essential to compilation they help to keep the implementation headers self-contained.
-At time of writing this set is not complete but has reasonable coverage.
-If you add additional headers please try to remember to add a surrogate cpp for it.
+_When submitting a pull request please do not include changes to the
+amalgamated distribution files. This means do not include them in your
+git commits!_
 
-The other directories are `tools/scripts` which contains a set of python scripts to help in testing Catch as well as
-generating the single include, and `docs`, which contains the documentation as a set of markdown files.
+When addressing review comments in a MR, please do not rebase/squash the
+commits immediately. Doing so makes it harder to review the new changes,
+slowing down the process of merging a MR. Instead, when addressing review
+comments, you should append new commits to the branch and only squash
+them into other commits when the MR is ready to be merged. We recommend
+creating new commits with `git commit --fixup` (or `--squash`) and then
+later squashing them with `git rebase --autosquash` to make things easier.
 
-__When submitting a pull request please do not include changes to the single include, or to the version number file
-as these are managed by the scripts!__
 
 
 ## Testing your changes
 
-Obviously all changes to Catch's code should be tested. If you added new
-functionality, you should add tests covering and showcasing it. Even if you have
-only made changes to Catch internals (i.e. you implemented some performance
-improvements), you should still test your changes.
+_Note: Running Catch2's tests requires Python3_
 
-This means 2 things
 
-* Compiling Catch's SelfTest project:
+Catch2 has multiple layers of tests that are then run as part of our CI.
+The most obvious one are the unit tests compiled into the `SelfTest`
+binary. These are then used in "Approval tests", which run (almost) all
+tests from `SelfTest` through a specific reporter and then compare the
+generated output with a known good output ("Baseline"). By default, new
+tests should be placed here.
+
+However, not all tests can be written as plain unit tests. For example,
+checking that Catch2 orders tests randomly when asked to, and that this
+random ordering is subset-invariant, is better done as an integration
+test using an external check script. Catch2 integration tests are written
+using CTest, either as a direct command invocation + pass/fail regex,
+or by delegating the check to a Python script.
+
+There are also two more kinds of tests, examples and "ExtraTests".
+Examples present a small and self-contained snippets of code that
+use Catch2's facilities for specific purpose. Currently they are assumed
+passing if they compile. ExtraTests then are expensive tests, that we
+do not want to run all the time. This can be either because they take
+a long time to run, or because they take a long time to compile, e.g.
+because they test compile time configuration and require separate
+compilation.
+
+Examples and ExtraTests are not compiled by default. To compile them,
+add `-DCATCH_BUILD_EXAMPLES=ON` and `-DCATCH_BUILD_EXTRA_TESTS=ON` to
+the invocation of CMake configuration step.
+
+Bringing this all together, the steps below should configure, build,
+and run all tests in the `Debug` compilation.
+
+1. Regenerate the amalgamated distribution
 ```
 $ cd Catch2
-$ cmake -Bdebug-build -H. -DCMAKE_BUILD_TYPE=Debug
+$ ./tools/scripts/generateAmalgamatedFiles.py
+```
+2. Configure the full test build
+```
+$ cmake -Bdebug-build -H. -DCMAKE_BUILD_TYPE=Debug -DCATCH_BUILD_EXAMPLES=ON -DCATCH_BUILD_EXTRA_TESTS=ON
+```
+3. Run the actual build
+```
 $ cmake --build debug-build
 ```
-because code that does not compile is evidently incorrect. Obviously,
-you are not expected to have access to all the compilers and platforms
-supported by Catch2, but you should at least smoke test your changes
-on your platform. Our CI pipeline will check your PR against most of
-the supported platforms, but it takes an hour to finish -- compiling
-locally takes just a few minutes.
-
-
-* Running the tests via CTest:
+4. Run the tests using CTest
 ```
 $ cd debug-build
-$ ctest -j 2 --output-on-failure
+$ ctest -j 4 --output-on-failure -C Debug
 ```
-__Note:__ When running your tests with multi-configuration generators like
-Visual Studio, you might get errors "Test not available without configuration."
-You then have to pick one configuration (e.g. ` -C Debug`) in the `ctest` call.
 
-If you added new tests, approval tests are very likely to fail. If they
-do not, it means that your changes weren't run as part of them. This
-_might_ be intentional, but usually is not.
-
-The approval tests compare current output of the SelfTest binary in various
-configurations against known good outputs. The reason it fails is,
-_usually_, that you've added new tests but have not yet approved the changes
-they introduce. This is done with the `scripts/approve.py` script, but
-before you do so, you need to check that the introduced changes are indeed
-intentional.
+If you added new tests, you will likely see `ApprovalTests` failure.
+After you check that the output difference is expected, you should
+run `tools/scripts/approve.py` to confirm them, and include these changes
+in your commit.
 
 
-## Documenting your code
+## Writing documentation
 
 If you have added new feature to Catch2, it needs documentation, so that
 other people can use it as well. This section collects some technical
 information that you will need for updating Catch2's documentation, and
 possibly some generic advise as well.
 
+
+### Technicalities 
+
 First, the technicalities:
 
+* If you have introduced a new document, there is a simple template you
+should use. It provides you with the top anchor mentioned to link to
+(more below), and also with a backlink to the top of the documentation:
+```markdown
+<a id="top"></a>
+# Cool feature
+
+Text that explains how to use the cool feature.
+
+
+---
+
+[Home](Readme.md#top)
+```
+
+* Crosslinks to different pages should target the `top` anchor, like this
+`[link to contributing](contributing.md#top)`.
+
 * We introduced version tags to the documentation, which show users in
 which version a specific feature was introduced. This means that newly
 written documentation should be tagged with a placeholder, that will
@@ -106,23 +144,8 @@ tags for other features).
   placeholder is usually used after a section heading
   * `> X (Y and Z) was [introduced](link-to-issue-or-PR) in Catch X.Y.Z`
   - this placeholder is used when you need to tag a subpart of something,
-  e.g. list
-* Crosslinks to different pages should target the `top` anchor, like this
-`[link to contributing](contributing.md#top)`.
-* If you have introduced a new document, there is a simple template you
-should use. It provides you with the top anchor mentioned above, and also
-with a backlink to the top of the documentation:
-```markdown
-<a id="top"></a>
-# Cool feature
+  e.g. a list
 
-Text that explains how to use the cool feature.
-
-
----
-
-[Home](Readme.md#top)
-```
 * For pages with more than 4 subheadings, we provide a table of contents
 (ToC) at the top of the page. Because GitHub markdown does not support
 automatic generation of ToC, it has to be handled semi-manually. Thus,
@@ -130,21 +153,54 @@ if you've added a new subheading to some page, you should add it to the
 ToC. This can be done either manually, or by running the
 `updateDocumentToC.py` script in the `scripts/` folder.
 
+### Contents
 
-Now, for the generic tips:
-  * Usage examples are good
-  * Don't be afraid to introduce new pages
-  * Try to be reasonably consistent with the surrounding documentation
+Now, for some content tips:
+
+* Usage examples are good. However, having large code snippets inline
+can make the documentation less readable, and so the inline snippets
+should be kept reasonably short. To provide more complex compilable
+examples, consider adding new .cpp file to `examples/`.
+
+* Don't be afraid to introduce new pages. The current documentation
+tends towards long pages, but a lot of that is caused by legacy, and
+we know that some of the pages are overly big and unfocused.
+
+* When adding information to an existing page, please try to keep your
+formatting, style and changes consistent with the rest of the page.
+
+* Any documentation has multiple different audiences, that desire
+different information from the text. The 3 basic user-types to try and
+cover are:
+  * A beginner to Catch2, who requires closer guidance for the usage of Catch2.
+  * Advanced user of Catch2, who want to customize their usage.
+  * Experts, looking for full reference of Catch2's capabilities.
 
 
+## Writing code
+
+If want to contribute code, this section contains some simple rules
+and tips on things like code formatting, code constructions to avoid,
+and so on.
 
 
-## Code constructs to watch out for
+### Formatting
+
+To make code formatting simpler for the contributors, Catch2 provides
+its own config for `clang-format`. However, because it is currently
+impossible to replicate existing Catch2's formatting in clang-format,
+using it to reformat a whole file would cause massive diffs. To keep
+the size of your diffs reasonable, you should only use clang-format
+on the newly changed code.
+
+
+### Code constructs to watch out for
 
 This section is a (sadly incomplete) listing of various constructs that
 are problematic and are not always caught by our CI infrastructure.
 
-### Naked exceptions and exceptions-related function
+
+#### Naked exceptions and exceptions-related function
 
 If you are throwing an exception, it should be done via `CATCH_ERROR`
 or `CATCH_RUNTIME_ERROR` in `catch_enforce.h`. These macros will handle
@@ -155,7 +211,8 @@ CI, but luckily there should not be too many reasons to use these.
 However, if you do, they should be kept behind a
 `CATCH_CONFIG_DISABLE_EXCEPTIONS` macro.
 
-### Unqualified usage of functions from C's stdlib
+
+#### Unqualified usage of functions from C's stdlib
 
 If you are using a function from C's stdlib, please include the header
 as `<cfoo>` and call the function qualified. The common knowledge that
@@ -163,7 +220,32 @@ there is no difference is wrong, QNX and VxWorks won't compile if you
 include the header as `<cfoo>` and call the function unqualified.
 
 
-----
+### New source file template
+
+If you are adding new source file, there is a template you should use.
+Specifically, every source file should start with the licence header:
+```cpp
+
+    //              Copyright Catch2 Authors
+    // Distributed under the Boost Software License, Version 1.0.
+    //   (See accompanying file LICENSE_1_0.txt or copy at
+    //        https://www.boost.org/LICENSE_1_0.txt)
+
+    // SPDX-License-Identifier: BSL-1.0
+```
+
+The include guards for header files should follow the pattern `{FILENAME}_INCLUDED`.
+This means that for file `catch_matchers_foo`, the include guard should
+be `CATCH_MATCHERS_FOO_INCLUDED`, for `catch_generators_bar`, the include
+guard should be `CATCH_GENERATORS_BAR_INCLUDED`, and so on.
+
+
+## CoC
+
+This project has a [CoC](../CODE_OF_CONDUCT.md). Please adhere to it
+while contributing to Catch2.
+
+-----------
 
 _This documentation will always be in-progress as new information comes
 up, but we are trying to keep it as up to date as possible._

docs/deprecations.md

@@ -9,6 +9,7 @@ either of these is a breaking change, and thus will not happen until
 at least the next major release.
 
 
+
 ## Planned changes
 
 ### `CHECKED_IF` and `CHECKED_ELSE`

docs/generators.md

@@ -12,23 +12,88 @@ are run once per each value in a generator.
 This is best explained with an example:
 ```cpp
 TEST_CASE("Generators") {
-    auto i = GENERATE(1, 2, 3);
-    SECTION("one") {
-        auto j = GENERATE( -3, -2, -1 );
-        REQUIRE(j < i);
-    }
+    auto i = GENERATE(1, 3, 5);
+    REQUIRE(is_odd(i));
 }
 ```
 
-The assertion in this test case will be run 9 times, because there
-are 3 possible values for `i` (1, 2, and 3) and there are 3 possible
-values for `j` (-3, -2, and -1).
+The "Generators" `TEST_CASE` will be entered 3 times, and the value of
+`i` will be 1, 3, and 5 in turn. `GENERATE`s can also be used multiple
+times at the same scope, in which case the result will be a cartesian
+product of all elements in the generators. This means that in the snippet
+below, the test case will be run 6 (2\*3) times.
 
+```cpp
+TEST_CASE("Generators") {
+    auto i = GENERATE(1, 2);
+    auto j = GENERATE(3, 4, 5);
+}
+```
 
 There are 2 parts to generators in Catch2, the `GENERATE` macro together
 with the already provided generators, and the `IGenerator<T>` interface
 that allows users to implement their own generators.
 
+
+## Combining `GENERATE` and `SECTION`.
+
+`GENERATE` can be seen as an implicit `SECTION`, that goes from the place
+`GENERATE` is used, to the end of the scope. This can be used for various
+effects. The simplest usage is shown below, where the `SECTION` "one"
+runs 4 (2\*2) times, and `SECTION` "two" is run 6 times (2\*3).
+
+```cpp
+TEST_CASE("Generators") {
+    auto i = GENERATE(1, 2);
+    SECTION("one") {
+        auto j = GENERATE(-3, -2);
+        REQUIRE(j < i);
+    }
+    SECTION("two") {
+        auto k = GENERATE(4, 5, 6);
+        REQUIRE(i != k);
+    }
+}
+```
+
+The specific order of the `SECTION`s will be "one", "one", "two", "two",
+"two", "one"...
+
+
+The fact that `GENERATE` introduces a virtual `SECTION` can also be used
+to make a generator replay only some `SECTION`s, without having to
+explicitly add a `SECTION`. As an example, the code below reports 3
+assertions, because the "first" section is run once, but the "second"
+section is run twice.
+
+```cpp
+TEST_CASE("GENERATE between SECTIONs") {
+    SECTION("first") { REQUIRE(true); }
+    auto _ = GENERATE(1, 2);
+    SECTION("second") { REQUIRE(true); }
+}
+```
+
+This can lead to surprisingly complex test flows. As an example, the test
+below will report 14 assertions:
+
+```cpp
+TEST_CASE("Complex mix of sections and generates") {
+    auto i = GENERATE(1, 2);
+    SECTION("A") {
+        SUCCEED("A");
+    }
+    auto j = GENERATE(3, 4);
+    SECTION("B") {
+        SUCCEED("B");
+    }
+    auto k = GENERATE(5, 6);
+    SUCCEED();
+}
+```
+
+> The ability to place `GENERATE` between two `SECTION`s was [introduced](https://github.com/catchorg/Catch2/issues/1938) in Catch 2.13.0.
+
 ## Provided generators
 
 Catch2's provided generator functionality consists of three parts,
@@ -78,7 +143,7 @@ type, making their usage much nicer. These are
 
 > `from_range` has been introduced in Catch 2.10.0
 
-> `range()` for floating point numbers has been introduced in Catch X.Y.Z
+> `range()` for floating point numbers has been introduced in Catch 2.11.0
 
 And can be used as shown in the example below to create a generator
 that returns 100 odd random number:

docs/list-of-examples.md

@@ -14,6 +14,7 @@
 - Configuration: [Provide your own output streams](../examples/231-Cfg-OutputStreams.cpp)
 - Generators: [Create your own generator](../examples/300-Gen-OwnGenerator.cpp)
 - Generators: [Use map to convert types in GENERATE expression](../examples/301-Gen-MapTypeConversion.cpp)
+- Generators: [Run test with a table of input values](../examples/302-Gen-Table.cpp)
 - Generators: [Use variables in generator expressions](../examples/310-Gen-VariablesInGenerators.cpp)
 - Generators: [Use custom variable capture in generator expressions](../examples/311-Gen-CustomCapture.cpp)
 

docs/matchers.md

@@ -1,77 +1,123 @@
 <a id="top"></a>
 # Matchers
 
-Matchers are an alternative way to do assertions which are easily extensible and composable.
-This makes them well suited to use with more complex types (such as collections) or your own custom types.
-Matchers were first popularised by the [Hamcrest](https://en.wikipedia.org/wiki/Hamcrest) family of frameworks.
+**Contents**<br>
+[Using Matchers](#using-matchers)<br>
+[Built-in matchers](#built-in-matchers)<br>
+[Writing custom matchers (old style)](#writing-custom-matchers-old-style)<br>
+[Writing custom matchers (new style)](#writing-custom-matchers-new-style)<br>
 
-## In use
+Matchers, as popularized by the [Hamcrest](https://en.wikipedia.org/wiki/Hamcrest)
+framework are an alternative way to write assertions, useful for tests
+where you work with complex types or need to assert more complex
+properties. Matchers are easily composable and users can write their
+own and combine them with the Catch2-provided matchers seamlessly.
 
-Matchers are introduced with the `REQUIRE_THAT` or `CHECK_THAT` macros, which take two arguments.
-The first argument is the thing (object or value) under test. The second part is a match _expression_,
-which consists of either a single matcher or one or more matchers combined using `&&`, `||` or `!` operators.
 
-For example, to assert that a string ends with a certain substring:
+## Using Matchers
 
- ```c++
-using Catch::Matchers::EndsWith; // or Catch::EndsWith
-std::string str = getStringFromSomewhere();
-REQUIRE_THAT( str, EndsWith( "as a service" ) );
-```
+Matchers are most commonly used in tandem with the `REQUIRE_THAT` or
+`CHECK_THAT` macros. The `REQUIRE_THAT` macro takes two arguments,
+the first one is the input (object/value) to test, the second argument
+is the matcher itself.
 
-The matcher objects can take multiple arguments, allowing more fine tuning.
-The built-in string matchers, for example, take a second argument specifying whether the comparison is
-case sensitive or not:
-
-```c++
-REQUIRE_THAT( str, EndsWith( "as a service", Catch::CaseSensitive::No ) );
- ```
-
-And matchers can be combined:
-
-```c++
-REQUIRE_THAT( str,
-    EndsWith( "as a service" ) ||
-    (StartsWith( "Big data" ) && !Contains( "web scale" ) ) );
-```
-
-_The combining operators do not take ownership of the matcher objects.
-This means that if you store the combined object, you have to ensure that
-the matcher objects outlive its last use. What this means is that code
-like this leads to a use-after-free and (hopefully) a crash:_
+For example, to assert that a string ends with the "as a service"
+substring, you can write the following assertion
 
 ```cpp
+using Catch::Matchers::EndsWith;
+
+REQUIRE_THAT( getSomeString(), EndsWith("as a service") );
+```
+
+Individual matchers can also be combined using the C++ logical
+operators, that is `&&`, `||`, and `!`, like so:
+
+```cpp
+using Catch::Matchers::EndsWith;
+using Catch::Matchers::Contains;
+
+REQUIRE_THAT( getSomeString(),
+              EndsWith("as a service") && Contains("web scale"));
+```
+
+The example above asserts that the string returned from `getSomeString`
+_both_ ends with the suffix "as a service" _and_ contains the string
+"web scale" somewhere.
+
+
+Both of the string matchers used in the examples above live in the
+`catch_matchers_string.hpp` header, so to compile the code above also
+requires `#include <catch2/matchers/catch_matchers_string.hpp>`.
+
+**IMPORTANT**: The combining operators do not take ownership of the
+matcher objects being combined. This means that if you store combined
+matcher object, you have to ensure that the matchers being combined
+outlive its last use. What this means is that the following code leads
+to a use-after-free (UAF):
+
+```cpp
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers_string.h>
+
 TEST_CASE("Bugs, bugs, bugs", "[Bug]"){
     std::string str = "Bugs as a service";
 
-    auto match_expression = Catch::EndsWith( "as a service" ) ||
-        (Catch::StartsWith( "Big data" ) && !Catch::Contains( "web scale" ) );
+    auto match_expression = Catch::Matchers::EndsWith( "as a service" ) ||
+        (Catch::Matchers::StartsWith( "Big data" ) && !Catch::Matchers::Contains( "web scale" ) );
     REQUIRE_THAT(str, match_expression);
 }
 ```
 
 
-## Built in matchers
-Catch2 provides some matchers by default. They can be found in the
-`Catch::Matchers::foo` namespace and are imported into the `Catch`
-namespace as well.
+## Built-in matchers
 
-There are two parts to each of the built-in matchers, the matcher
-type itself and a helper function that provides template argument
-deduction when creating templated matchers. As an example, the matcher
-for checking that two instances of `std::vector` are identical is
-`EqualsMatcher<T>`, but the user is expected to use the `Equals`
-helper function instead.
+Every matcher provided by Catch2 is split into 2 parts, a factory
+function that lives in the `Catch::Matchers` namespace, and the actual
+matcher type that is in some deeper namespace and should not be used by
+the user. In the examples above, we used `Catch::Matchers::Contains`.
+This is the factory function for the
+`Catch::Matchers::StdString::ContainsMatcher` type that does the actual
+matching.
+
+Out of the box, Catch2 provides the following matchers:
 
 
-### String matchers
-The string matchers are `StartsWith`, `EndsWith`, `Contains`, `Equals` and `Matches`. The first four match a literal (sub)string against a result, while `Matches` takes and matches an ECMAScript regex. Do note that `Matches` matches the string as a whole, meaning that "abc" will not match against "abcd", but "abc.*" will.
+### `std::string` matchers
 
-Each of the provided `std::string` matchers also takes an optional second argument, that decides case sensitivity (by-default, they are case sensitive).
+Catch2 provides 5 different matchers that work with `std::string`,
+* `StartsWith(std::string str, CaseSensitive)`,
+* `EndsWith(std::string str, CaseSensitive)`,
+* `Contains(std::string str, CaseSensitive)`,
+* `Equals(std::string str, CaseSensitive)`, and
+* `Matches(std::string str, CaseSensitive)`.
+
+The first three should be fairly self-explanatory, they succeed if
+the argument starts with `str`, ends with `str`, or contains `str`
+somewhere inside it.
+
+The `Equals` matcher matches a string if (and only if) the argument
+string is equal to `str`.
+
+Finally, the `Matches` matcher performs an ECMASCript regex match using
+`str` against the argument string. It is important to know that
+the match is performed agains the string as a whole, meaning that
+the regex `"abc"` will not match input string `"abcd"`. To match
+`"abcd"`, you need to use e.g. `"abc.*"` as your regex.
+
+The second argument sets whether the matching should be case-sensitive
+or not. By default, it is case-sensitive.
+
+> `std::string` matchers live in `catch2/matchers/catch_matchers_string.hpp`
 
 
 ### Vector matchers
-Catch2 currently provides 5 built-in matchers that work on `std::vector`.
+
+_Vector matchers have been deprecated in favour of the generic
+range matchers with the same functionality._
+
+Catch2 provides 5 built-in matchers that work on `std::vector`.
+
 These are
 
  * `Contains` which checks whether a specified vector is present in the result
@@ -81,40 +127,82 @@ These are
  * `Approx` which checks whether the result is "approx-equal" (order matters, but comparison is done via `Approx`) to a specific vector
 > Approx matcher was [introduced](https://github.com/catchorg/Catch2/issues/1499) in Catch 2.7.2.
 
+An example usage:
+```cpp
+    std::vector<int> some_vec{ 1, 2, 3 };
+    REQUIRE_THAT(some_vec, Catch::Matchers::UnorderedEquals(std::vector<int>{ 3, 2, 1 }));
+```
+
+This assertions will pass, because the elements given to the matchers
+are a permutation of the ones in `some_vec`.
+
+> vector matchers live in `catch2/matchers/catch_matchers_vector.hpp`
+
 
 ### Floating point matchers
-Catch2 provides 3 matchers for working with floating point numbers. These
-are `WithinAbsMatcher`, `WithinUlpsMatcher` and `WithinRelMatcher`.
 
-The `WithinAbsMatcher` matcher accepts floating point numbers that are
-within a certain distance of target. It should be constructed with the
-`WithinAbs(double target, double margin)` helper.
+Catch2 provides 3 matchers that target floating point numbers. These
+are:
 
-The `WithinUlpsMatcher` matcher accepts floating point numbers that are
-within a certain number of [ULPs](https://en.wikipedia.org/wiki/Unit_in_the_last_place)
-of the target. Because ULP comparisons need to be done differently for
-`float`s and for `double`s, there are two overloads of the helpers for
-this matcher, `WithinULP(float target, int64_t ULPs)`, and
-`WithinULP(double target, int64_t ULPs)`.
-
-The `WithinRelMatcher` matcher accepts floating point numbers that are
-_approximately equal_ with the target number with some specific tolerance.
-In other words, it checks that `|lhs - rhs| <= epsilon * max(|lhs|, |rhs|)`,
-with special casing for `INFINITY` and `NaN`. There are _4_ overloads of
-the helpers for this matcher, `WithinRel(double target, double margin)`,
-`WithinRel(float target, float margin)`, `WithinRel(double target)`, and
-`WithinRel(float target)`. The latter two provide a default epsilon of
-machine epsilon * 100.
+* `WithinAbs(double target, double margin)`,
+* `WithinUlps(FloatingPoint target, uint64_t maxUlpDiff)`, and
+* `WithinRel(FloatingPoint target, FloatingPoint eps)`.
 
 > `WithinRel` matcher was introduced in Catch 2.10.0
 
-### Generic matchers
-Catch also aims to provide a set of generic matchers. Currently this set
-contains only a matcher that takes arbitrary callable predicate and applies
-it onto the provided object.
 
-Because of type inference limitations, the argument type of the predicate
-has to be provided explicitly. Example:
+`WithinAbs` creates a matcher that accepts floating point numbers whose
+difference with `target` is less than the `margin`.
+
+`WithinULP` creates a matcher that accepts floating point numbers that
+are no more than `maxUlpDiff`
+[ULPs](https://en.wikipedia.org/wiki/Unit_in_the_last_place)
+away from the `target` value. The short version of what this means
+is that there is no more than `maxUlpDiff - 1` representeable floating
+point numbers between the argument for matching and the `target` value.
+
+`WithinRel` creates a matcher that accepts floating point numbers that
+are _approximately equal_ with the `target` with tolerance of `eps.`
+Specifically, it matches if
+`|arg - target| <= eps * max(|arg|, |target|)` holds. If you do not
+specify `eps`, `std::numeric_limits<FloatingPoint>::epsilon * 100`
+is used as the default.
+
+
+In practice, you will often want to combine multiple of these matchers,
+together for an assertion, because all 3 options have edge cases where
+they behave differently than you would expect. As an example, under
+the `WithinRel` matcher, a `0.` only ever matches a `0.` (or `-0.`),
+regardless of the relative tolerance specified. Thus, if you want to
+handle numbers that are "close enough to 0 to be 0", you have to combine
+it with the `WithinAbs` matcher.
+
+For example, to check that our computation matches known good value
+within 0.1%, or is close enough (no different to 5 decimal places)
+to zero, we would write this assertion:
+```cpp
+    REQUIRE_THAT( computation(input),
+        Catch::Matchers::WithinRel(expected, 0.001)
+     || Catch::Matchers::WithinAbs(0, 0.000001) );
+```
+
+
+> floating point matchers live in `catch2/matchers/catch_matchers_floating.hpp`
+
+
+### Miscellaneous matchers
+
+Catch2 also provides some matchers and matcher utilities that do not
+quite fit into other categories.
+
+The first one of them is the `Predicate(Callable pred, std::string description)`
+matcher. It creates a matcher object that calls `pred` for the provided
+argument. The `description` argument allows users to set what the
+resulting matcher should self-describe as if required.
+
+Do note that you will need to explicitly specify the type of the
+argument, like in this example:
+
 ```cpp
 REQUIRE_THAT("Hello olleH",
              Predicate<std::string>(
@@ -123,84 +211,205 @@ REQUIRE_THAT("Hello olleH",
 );
 ```
 
-The second argument is an optional description of the predicate, and is
-used only during reporting of the result.
+> the predicate matcher lives in `catch2/matchers/catch_matchers_predicate.hpp`
 
 
-### Exception matchers
-Catch2 also provides an exception matcher that can be used to verify
-that an exception's message exactly matches desired string. The matcher
-is `ExceptionMessageMatcher`, and we also provide a helper function
-`Message`.
+The other miscellaneous matcher utility is exception matching.
 
-The matched exception must publicly derive from `std::exception` and
-the message matching is done _exactly_, including case.
 
-> `ExceptionMessageMatcher` was introduced in Catch 2.10.0
+#### Matching exceptions
+
+Catch2 provides an utility macro for asserting that an expression
+throws exception of specific type, and that the exception has desired
+properties. The macro is `REQUIRE_THROWS_MATCHES(expr, ExceptionType, Matcher)`.
+
+> `REQUIRE_THROWS_MATCHES` macro lives in `catch2/matchers/catch_matchers.hpp`
+
+
+Catch2 currently provides only one matcher for exceptions,
+`Message(std::string message)`. `Message` checks that the exception's
+message, as returned from `what` is exactly equal to `message`.
 
 Example use:
 ```cpp
 REQUIRE_THROWS_MATCHES(throwsDerivedException(),  DerivedException,  Message("DerivedException::what"));
 ```
 
-## Custom matchers
-It's easy to provide your own matchers to extend Catch or just to work with your own types.
+Note that `DerivedException` in the example above has to derive from
+`std::exception` for the example to work.
 
-You need to provide two things:
-1. A matcher class, derived from `Catch::MatcherBase<T>` - where `T` is the type being tested.
-The constructor takes and stores any arguments needed (e.g. something to compare against) and you must
-override two methods: `match()` and `describe()`.
-2. A simple builder function. This is what is actually called from the test code and allows overloading.
+> the exception message matcher lives in `catch2/matchers/catch_matchers_exception.hpp`
 
-Here's an example for asserting that an integer falls within a given range
-(note that it is all inline for the sake of keeping the example short):
+
+### Generic range Matchers
+
+> Generic range matchers were introduced in Catch X.Y.Z
+
+Catch2 also provides some matchers that use the new style matchers
+definitions to handle generic range-like types. These are:
+
+* `IsEmpty()`
+* `SizeIs(size_t target_size)`
+* `SizeIs(Matcher size_matcher)`
+* `Contains(T&& target_element, Comparator = std::equal_to<>{})`
+* `Contains(Matcher element_matcher)`
+
+`IsEmpty` should be self-explanatory. It successfully matches objects
+that are empty according to either `std::empty`, or ADL-found `empty`
+free function.
+
+`SizeIs` checks range's size. If constructed with `size_t` arg, the
+matchers accepts ranges whose size is exactly equal to the arg. If
+constructed from another matcher, then the resulting matcher accepts
+ranges whose size is accepted by the provided matcher.
+
+`Contains` accepts ranges that contain specific element. There are
+again two variants, one that accepts the desired element directly,
+in which case a range is accepted if any of its elements is equal to
+the target element. The other variant is constructed from a matcher,
+in which case a range is accepted if any of its elements is accepted
+by the provided matcher.
+
+
+## Writing custom matchers (old style)
+
+The old style of writing matchers has been introduced back in Catch
+Classic. To create an old-style matcher, you have to create your own
+type that derives from `Catch::Matchers::MatcherBase<ArgT>`, where
+`ArgT` is the type your matcher works for. Your type has to override
+two methods, `bool match(ArgT const&) const`,
+and `std::string describe() const`.
+
+As the name suggests, `match` decides whether the provided argument
+is matched (accepted) by the matcher. `describe` then provides a
+human-oriented description of what the matcher does.
+
+We also recommend that you create factory function, just like Catch2
+does, but that is mostly useful for template argument deduction for
+templated matchers (assuming you do not have CTAD available).
+
+To combine these into an example, let's say that you want to write
+a matcher that decides whether the provided argument is a number
+within certain range. We will call it `IsBetweenMatcher<T>`:
 
 ```c++
-// The matcher class
-class IntRange : public Catch::MatcherBase<int> {
-    int m_begin, m_end;
-public:
-    IntRange( int begin, int end ) : m_begin( begin ), m_end( end ) {}
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers.h>
+// ...
 
-    // Performs the test for this matcher
-    bool match( int const& i ) const override {
-        return i >= m_begin && i <= m_end;
+
+template <typename T>
+class IsBetweenMatcher : public Catch::Matchers::MatcherBase<T> {
+    T m_begin, m_end;
+public:
+    IsBetweenMatcher(T begin, T end) : m_begin(begin), m_end(end) {}
+
+    bool match(T const& in) const override {
+        return in >= m_begin && in <= m_end;
     }
 
-    // Produces a string describing what this matcher does. It should
-    // include any provided data (the begin/ end in this case) and
-    // be written as if it were stating a fact (in the output it will be
-    // preceded by the value under test).
-    virtual std::string describe() const override {
+    std::string describe() const override {
         std::ostringstream ss;
         ss << "is between " << m_begin << " and " << m_end;
         return ss.str();
     }
 };
 
-// The builder function
-inline IntRange IsBetween( int begin, int end ) {
-    return IntRange( begin, end );
+template <typename T>
+IsBetweenMatcher<T> IsBetween(T begin, T end) {
+    return { begin, end };
 }
 
 // ...
 
-// Usage
-TEST_CASE("Integers are within a range")
-{
-    CHECK_THAT( 3, IsBetween( 1, 10 ) );
-    CHECK_THAT( 100, IsBetween( 1, 10 ) );
+TEST_CASE("Numbers are within range") {
+    // infers `double` for the argument type of the matcher
+    CHECK_THAT(3., IsBetween(1., 10.));
+    // infers `int` for the argument type of the matcher
+    CHECK_THAT(100, IsBetween(1, 10));
 }
 ```
 
-Running this test gives the following in the console:
+Obviously, the code above can be improved somewhat, for example you
+might want to `static_assert` over the fact that `T` is an arithmetic
+type... or generalize the matcher to cover any type for which the user
+can provide a comparison function object.
 
+Note that while any matcher written using the old style can also be
+written using the new style, combining old style matchers should
+generally compile faster. Also note that you can combine old and new
+style matchers arbitrarily.
+
+> `MatcherBase` lives in `catch2/matchers/catch_matchers.hpp`
+
+
+## Writing custom matchers (new style)
+
+> New style matchers were introduced in Catch X.Y.Z
+
+To create a new-style matcher, you have to create your own type that
+derives from `Catch::Matchers::MatcherGenericBase`. Your type has to
+also provide two methods, `bool match( ... ) const` and overriden
+`std::string describe() const`.
+
+Unlike with old-style matchers, there are no requirements on how
+the `match` member function takes its argument. This means that the
+argument can be taken by value or by mutating reference, but also that
+the matcher's `match` member function can be templated.
+
+This allows you to write more complex matcher, such as a matcher that
+can compare one range-like (something that responds to `begin` and
+`end`) object to another, like in the following example:
+
+```cpp
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers_templated.hpp>
+// ...
+
+template<typename Range>
+struct EqualsRangeMatcher : Catch::Matchers::MatcherGenericBase {
+    EqualsRangeMatcher(Range const& range):
+        range{ range }
+    {}
+
+    template<typename OtherRange>
+    bool match(OtherRange const& other) const {
+        using std::begin; using std::end;
+
+        return std::equal(begin(range), end(range), begin(other), end(other));
+    }
+
+    std::string describe() const override {
+        return "Equals: " + Catch::rangeToString(range);
+    }
+
+private:
+    Range const& range;
+};
+
+template<typename Range>
+auto EqualsRange(const Range& range) -> EqualsRangeMatcher<Range> {
+    return EqualsRangeMatcher<Range>{range};
+}
+
+TEST_CASE("Combining templated matchers", "[matchers][templated]") {
+    std::array<int, 3> container{{ 1,2,3 }};
+
+    std::array<int, 3> a{{ 1,2,3 }};
+    std::vector<int> b{ 0,1,2 };
+    std::list<int> c{ 4,5,6 };
+
+    REQUIRE_THAT(container, EqualsRange(a) || EqualsRange(b) || EqualsRange(c));
+}
 ```
-/**/TestFile.cpp:123: FAILED:
-  CHECK_THAT( 100, IsBetween( 1, 10 ) )
-with expansion:
-  100 is between 1 and 10
-```
+
+Do note that while you can rewrite any matcher from the old style to
+a new style matcher, combining new style matchers is more expensive
+in terms of compilation time. Also note that you can combine old style
+and new style matchers arbitrarily.
+
+> `MatcherGenericBase` lives in `catch2/matchers/catch_matchers_templated.hpp`
+
 
 ---
 

docs/opensource-users.md

@@ -20,18 +20,21 @@ Listing a project here does not imply endorsement and the plan is to keep these
 ### [ApprovalTests.cpp](https://github.com/approvals/ApprovalTests.cpp)
 C++11 implementation of Approval Tests, for quick, convenient testing of legacy code.
 
+### [args](https://github.com/Taywee/args)
+A simple header-only C++ argument parser library.
+
 ### [Azmq](https://github.com/zeromq/azmq)
 Boost Asio style bindings for ZeroMQ.
 
 ### [Cataclysm: Dark Days Ahead](https://github.com/CleverRaven/Cataclysm-DDA)
 Post-apocalyptic survival RPG.
 
-### [ChakraCore](https://github.com/Microsoft/ChakraCore)
-The core part of the Chakra JavaScript engine that powers Microsoft Edge.
-
 ### [ChaiScript](https://github.com/ChaiScript/ChaiScript)
 A, header-only, embedded scripting language designed from the ground up to directly target C++ and take advantage of modern C++ development techniques.
 
+### [ChakraCore](https://github.com/Microsoft/ChakraCore)
+The core part of the Chakra JavaScript engine that powers Microsoft Edge.
+
 ### [Clara](https://github.com/philsquared/Clara)
 A, single-header-only, type-safe, command line parser - which also prints formatted usage strings.
 
@@ -65,9 +68,6 @@ A small C++ library wrapper for the native C ODBC API.
 ### [Nonius](https://github.com/libnonius/nonius)
 A header-only framework for benchmarking small snippets of C++ code.
 
-### [SOCI](https://github.com/SOCI/soci)
-The C++ Database Access Library.
-
 ### [polymorphic_value](https://github.com/jbcoe/polymorphic_value)
 A polymorphic value-type for C++.
 
@@ -77,18 +77,21 @@ 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.
 
-### [thor](https://github.com/xorz57/thor)
-Wrapper Library for CUDA.
+### [SOCI](https://github.com/SOCI/soci)
+The C++ Database Access Library.
 
 ### [TextFlowCpp](https://github.com/philsquared/textflowcpp)
 A small, single-header-only, library for wrapping and composing columns of text.
 
+### [thor](https://github.com/xorz57/thor)
+Wrapper Library for CUDA.
+
+### [toml++](https://github.com/marzer/tomlplusplus)
+A header-only TOML parser and serializer for modern C++.
+
 ### [Trompeloeil](https://github.com/rollbear/trompeloeil)
 A thread-safe header-only mocking framework for C++14.
 
-### [args](https://github.com/Taywee/args)
-A simple header-only C++ argument parser library.
-
 ## Applications & Tools
 
 ### [ArangoDB](https://github.com/arangodb/arangodb)
@@ -103,6 +106,9 @@ MAME originally stood for Multiple Arcade Machine Emulator.
 ### [Newsbeuter](https://github.com/akrennmair/newsbeuter)
 Newsbeuter is an open-source RSS/Atom feed reader for text terminals.
 
+### [PopHead](https://github.com/SPC-Some-Polish-Coders/PopHead)
+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 microcontrolers (just RPi + Stepsticks).
 
@@ -112,9 +118,6 @@ SpECTRE is a code for multi-scale, multi-physics problems in astrophysics and gr
 ### [Standardese](https://github.com/foonathan/standardese)
 Standardese aims to be a nextgen Doxygen.
 
-### [PopHead](https://github.com/SPC-Some-Polish-Coders/PopHead)
-A 2D, Zombie, RPG game which is being made on our own engine.
-
 ---
 
 [Home](Readme.md#top)

docs/release-notes.md

@@ -2,6 +2,19 @@
 
 # Release notes
 **Contents**<br>
+[3.0.1](#301)<br>
+[2.13.2](#2132)<br>
+[2.13.1](#2131)<br>
+[2.13.0](#2130)<br>
+[2.12.4](#2124)<br>
+[2.12.3](#2123)<br>
+[2.12.2](#2122)<br>
+[2.12.1](#2121)<br>
+[2.12.0](#2120)<br>
+[2.11.3](#2113)<br>
+[2.11.2](#2112)<br>
+[2.11.1](#2111)<br>
+[2.11.0](#2110)<br>
 [2.10.2](#2102)<br>
 [2.10.1](#2101)<br>
 [2.10.0](#2100)<br>
@@ -30,9 +43,42 @@
 [Older versions](#older-versions)<br>
 [Even Older versions](#even-older-versions)<br>
 
-## 3.0.0 (in progress)
+
+## 3.0.1 (in progress)
+
+
+**Catch2 now uses statically compiled library as its distribution model.
+This also means that to get all of Catch2's functionality in a test file,
+you have to include multiple headers.**
+
+For quick'n'dirty migration, you can replace the old `#include <catch2/catch.hpp>`
+with `#include <catch2/catch_all.hpp>`. This is a (one of) convenience
+header(s) that brings in _all_ of headers in Catch2. By doing this,
+you should be able to migrate instantly, but at the cost of (significantly)
+increased compilation times. You should prefer piecemeal including
+headers that are actually required by your test code.
+
+The basic set of functionality (`TEST_CASE`, `SECTION`, `REQUIRE`) is in
+`catch2/catch_test_macros.hpp`. Matchers are in `matchers` subfolder,
+generators in `generators` subfolder, and so on.
+
+Note that documentation has not yet been updated to account for the
+new design.
+
+
+### FAQ
+
+* Why is Catch2 moving to separate headers?
+  * The short answer is future extensibility and scalability. The long answer is complex and can be found on my blog, but at the most basic level, it is that providing single-header distribution is at odds with providing variety of useful features. When Catch2 was distributed in a single header, adding a new Matcher would cause overhead for everyone, but was useful only to a subset of users. This meant that the barrier to entry for new Matchers/Generators/etc is high in single header model, but much smaller in the new model.
+* Will Catch2 again distribute single-header version in the future?
+  * No. But we do provide sqlite-style amalgamated distribution option. This means that you can download just 1 .cpp file and 1 header and place them next to your own sources. However, doing this has downsides similar to using the `catch_all.hpp` header.
+* Why the big breaking change caused by replacing `catch.hpp` with `catch_all.hpp`?
+  * The convenience header `catch_all.hpp` exists for two reasons. One of them is to provide a way for quick migration from Catch2, the second one is to provide a simple way to test things with Catch2. Using it for migration has one drawback in that it is **big**. This means that including it _will_ cause significant compile time drag, and so using it to migrate should be a concious decision by the user, not something they can just stumble into unknowingly.
+
 
 ### (Potentially) Breaking changes
+* **Catch2 now uses statically compiled library as its distribution model**
+  * **Including `catch.hpp` no longer works**
 * `ANON_TEST_CASE` has been removed, use `TEST_CASE` with no arguments instead (#1220)
 * `--list*` commands no longer have non-zero return code (#1410)
 * `--list-test-names-only` has been removed (#1190)
@@ -48,7 +94,45 @@
   * This means that the type of the provided predicate is part of the `PredicateMatcher`'s type
 * `SectionInfo` no longer contains section description as a member (#1319)
   * You can still write `SECTION("ShortName", "Long and wordy description")`, but the description is thrown away
-  * The description type now must be a `const char*` or implicitly convertible to it
+  * The description type now must be a `const char*` or be implicitly convertible to it
+* The `[!hide]` tag has been removed.
+  * Use `[.]` or `[.foo]` instead.
+* Lvalues of composed matchers cannot be composed further
+* Uses of `REGISTER_TEST_CASE` macro need to be followed by a semicolon
+  * This does not change `TEST_CASE` and friends in any way
+* `IStreamingReporter::IsMulti` member function was removed
+  * This is _very_ unlikely to actually affect anyone, as it was default-implemented in the interface, and only used internally
+* Various classes not designed for user-extension have been made final
+  * `ListeningReporter` is now `final`
+  * Concrete Matchers (e.g. `UnorderedEquals` vector matcher) are now `final`
+  * All Generators are now `final`
+* Matcher namespacing has been redone
+  * Matcher types are no longer in deeply nested namespaces
+  * Matcher factory functions are no longer brought into `Catch` namespace
+  * This means that all public-facing matcher-related functionality is now in `Catch::Matchers` namespace
+* Defining `CATCH_CONFIG_MAIN` will no longer create main in that TU.
+  * Link with `libCatch2Main.a`, or the proper CMake/pkg-config target
+  * If you want to write custom main, include `catch2/catch_session.hpp`
+* `CATCH_CONFIG_EXTERNAL_INTERFACES` has been removed.
+  * You should instead include the appropriate headers as needed.
+* `CATCH_CONFIG_IMPL` has been removed.
+  * The implementation is now compiled into a static library.
+* Event Listener interface has changed
+  * `TestEventListenerBase` was renamed to `EventListenerBase`
+  * `EventListenerBase` now directly derives from `IStreamingReporter`, instead of deriving from `StreamingReporterBase`
+
+
+
+### Improvements
+* Matchers have been extended with the ability to use different signatures of `match` (#1307, #1553, #1554, #1843)
+  * This includes having templated `match` member function
+  * See the [rewritten Matchers documentation](matchers.md#top) for details
+  * Catch2 currently provides _some_ generic matchers, but there should be more before final release of v3
+    * So far, `IsEmpty`, `SizeIs`, and `Contains` are provided.
+    * At least `ElementsAre` and `UnorderedElementsAre` are planned.
+* Some runtime performance improvements
+* Significant compilation time improvements
+  * including `catch_test_macros.hpp` is 80% cheaper than including `catch.hpp`
 
 
 ### Fixes
@@ -56,6 +140,199 @@
 * The `--list*` family of command line flags now return 0 on success (#1410, #1146)
 
 
+### Other changes
+* `CATCH_CONFIG_DISABLE_MATCHERS` no longer exists.
+  * If you do not want to use Matchers in a TU, do not include their header.
+* `CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER` no longer exists.
+  * `StringMaker` specializations for `<chrono>` are always provided
+* Catch2's CMake now provides 2 targets, `Catch2` and `Catch2WithMain`.
+  * `Catch2` is the statically compiled implementation by itself
+  * `Catch2WithMain` also links in the default main
+* Catch2's pkg-config integration also provides 2 packages
+  * `catch2` is the statically compiled implementation by itself
+  * `catch2-with-main` also links in the default main
+
+
+
+## 2.13.2
+
+### Improvements
+* Implemented workaround for AppleClang shadowing bug (#2030)
+* Implemented workaround for NVCC ICE (#2005, #2027)
+
+### Fixes
+* Fixed detection of `std::uncaught_exceptions` support under non-msvc platforms (#2021)
+* Fixed the experimental stdout/stderr capture under Windows (#2013)
+
+### Miscellaneous
+* `catch_discover_tests` has been improved significantly (#2023, #2039)
+  * You can now specify which reporter should be used
+  * You can now modify where the output will be written
+  * `WORKING_DIRECTORY` setting is respected
+* `ParseAndAddCatchTests` now supports `TEMPLATE_TEST_CASE` macros (#2031)
+* Various documentation fixes and improvements (#2022, #2028, #2034)
+
+
+## 2.13.1
+
+### Improvements
+* `ParseAndAddCatchTests` handles CMake v3.18.0 correctly (#1984)
+* Improved autodetection of `std::byte` (#1992)
+* Simplified implementation of templated test cases (#2007)
+  * This should have a tiny positive effect on its compilation throughput
+
+### Fixes
+* Automatic stringification of ranges handles sentinel ranges properly (#2004)
+
+
+## 2.13.0
+
+### Improvements
+* `GENERATE` can now follow a `SECTION` at the same level of nesting (#1938)
+  * 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 overriden by setting `-d`/`--duration`.
+
+### Fixes
+* `TAPReporter` no longer skips successful assertions (#1983)
+
+
+## 2.12.4
+
+### Improvements
+* Added support for MacOS on ARM (#1971)
+
+
+## 2.12.3
+
+### Fixes
+* `GENERATE` nested in a for loop no longer creates multiple generators (#1913)
+* Fixed copy paste error breaking `TEMPLATE_TEST_CASE_SIG` for 6 or more arguments (#1954)
+* Fixed potential UB when handling non-ASCII characters in CLI args (#1943)
+
+### Improvements
+* There can be multiple calls to `GENERATE` on a single line
+* Improved `fno-except` support for platforms that do not provide shims for exception-related std functions (#1950)
+  * E.g. the Green Hills C++ compiler
+* XmlReporter now also reports test-case-level statistics (#1958)
+  * This is done via a new element, `OverallResultsCases`
+
+### Miscellaneous
+* Added `.clang-format` file to the repo (#1182, #1920)
+* Rewrote contributing docs
+  * They should explain the different levels of testing and so on much better
+
+
+## 2.12.2
+
+### Fixes
+* Fixed compilation failure if `is_range` ADL found deleted function (#1929)
+* Fixed potential UB in `CAPTURE` if the expression contained non-ASCII characters (#1925)
+
+### Improvements
+* `std::result_of` is not used if `std::invoke_result` is available (#1934)
+* JUnit reporter writes out `status` attribute for tests (#1899)
+* Suppresed clang-tidy's `hicpp-vararg` warning (#1921)
+  * Catch2 was already suppressing the `cppcoreguidelines-pro-type-vararg` alias of the warning
+
+
+## 2.12.1
+
+### Fixes
+* Vector matchers now support initializer list literals better
+
+### Improvements
+* Added support for `^` (bitwise xor) to `CHECK` and `REQUIRE`
+
+
+
+## 2.12.0
+
+### Improvements
+* Running tests in random order (`--order rand`) has been reworked significantly (#1908)
+  * Given same seed, all platforms now produce the same order
+  * Given same seed, the relative order of tests does not change if you select only a subset of them
+* Vector matchers support custom allocators (#1909)
+* `|` and `&` (bitwise or and bitwise and) are now supported in `CHECK` and `REQUIRE`
+  * The resulting type must be convertible to `bool`
+
+### 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 trigered by the new warning support workaround
+* Fixed bug in test specification parser handling of OR'd patterns using escaping (#1905)
+
+### Miscellaneous
+* Worked around IBM XL's codegen bug (#1907)
+  * It would emit code for _destructors_ of temporaries in an unevaluated context
+* Improved detection of stdlib's support for `std::uncaught_exceptions` (#1911)
+
+
+
+## 2.11.3
+
+### Fixes
+* Fixed compilation error caused by lambdas in assertions under MSVC
+
+
+## 2.11.2
+
+### Improvements
+* GCC and Clang now issue warnings for suspicious code in assertions (#1880)
+  * E.g. `REQUIRE( int != unsigned int )` will now issue mixed signedness comparison warning
+  * This has always worked on MSVC, but it now also works for GCC and current Clang versions
+* Colorization of "Test filters" output should be more robust now
+* `--wait-for-keypress` now also accepts `never` as an option (#1866)
+* Reporters no longer round-off nanoseconds when reporting benchmarking results (#1876)
+* Catch2's debug break now supports iOS while using Thumb instruction set (#1862)
+* It is now possible to customize benchmark's warm-up time when running the test binary (#1844)
+  * `--benchmark-warmup-time {ms}`
+* User can now specify how Catch2 should break into debugger (#1846)
+
+### Fixes
+* Fixes missing `<random>` include in benchmarking (#1831)
+* Fixed missing `<iterator>` include in benchmarking (#1874)
+* Hidden test cases are now also tagged with `[!hide]` as per documentation (#1847)
+* Detection of whether libc provides `std::nextafter` has been improved (#1854)
+* Detection of `wmain` no longer incorrectly looks for `WIN32` macro (#1849)
+  * Now it just detects Windows platform
+* Composing already-composed matchers no longer modifies the partially-composed matcher expression
+  * This bug has been present for the last ~2 years and nobody reported it
+
+
+
+## 2.11.1
+
+### Improvements
+* Breaking into debugger is supported on iOS (#1817)
+* `google-build-using-namespace` clang-tidy warning is suppressed (#1799)
+
+### Fixes
+* Clang on Windows is no longer assumed to implement MSVC's traditional preprocessor (#1806)
+* `ObjectStorage` now behaves properly in `const` contexts (#1820)
+* `GENERATE_COPY(a, b)` now compiles properly (#1809, #1815)
+* Some more cleanups in the benchmarking support
+
+
+
+## 2.11.0
+
+### Improvements
+* JUnit reporter output now contains more details in case of failure (#1347, #1719)
+* Added SonarQube Test Data reporter (#1738)
+  * It is in a separate header, just like the TAP, Automake, and TeamCity reporters
+* `range` generator now allows floating point numbers (#1776)
+* Reworked part of internals to increase throughput
+
+
+### Fixes
+* The single header version should contain full benchmarking support (#1800)
+* `[.foo]` is now properly parsed as `[.][foo]` when used on the command line (#1798)
+* Fixed compilation of benchmarking on platforms where `steady_clock::period` is not `std::nano` (#1794)
+
+
+
 ## 2.10.2
 
 ### Improvements

docs/slow-compiles.md

@@ -22,7 +22,7 @@ But functions and methods can also be written inline in header files. The downsi
 
 Because Catch is implemented *entirely* in headers you might think that the whole of Catch must be compiled into every translation unit that uses it! Actually it's not quite as bad as that. Catch mitigates this situation by effectively maintaining the traditional separation between the implementation code and declarations. Internally the implementation code is protected by ```#ifdef```s and is conditionally compiled into only one translation unit. This translation unit is that one that ```#define```s ```CATCH_CONFIG_MAIN``` or ```CATCH_CONFIG_RUNNER```. Let's call this the main source file.
 
-As a result the main source file *does* compile the whole of Catch every time! So it makes sense to dedicate this file to *only* ```#define```-ing the identifier and ```#include```-ing Catch (and implementing the runner code, if you're doing that). Keep all your test cases in other files. This way you won't pay the recompilation cost for the whole of Catch 
+As a result the main source file *does* compile the whole of Catch every time! So it makes sense to dedicate this file to *only* ```#define```-ing the identifier and ```#include```-ing Catch (and implementing the runner code, if you're doing that). Keep all your test cases in other files. This way you won't pay the recompilation cost for the whole of Catch.
 
 ## Practical example
 Assume you have the `Factorial` function from the [tutorial](tutorial.md#top) in `factorial.cpp` (with forward declaration in `factorial.h`) and want to test it and keep the compile times down when adding new tests. Then you should have 2 files, `tests-main.cpp` and `tests-factorial.cpp`:

docs/test-cases-and-sections.md

@@ -50,7 +50,7 @@ Tag names are not case sensitive and can contain any ASCII characters. This mean
 
 All tag names beginning with non-alphanumeric characters are reserved by Catch. Catch defines a number of "special" tags, which have meaning to the test runner itself. These special tags all begin with a symbol character. Following is a list of currently defined special tags and their meanings.
 
-* `[!hide]` or `[.]` - causes test cases to be skipped from the default list (i.e. when no test cases have been explicitly selected through tag expressions or name wildcards). The hide tag is often combined with another, user, tag (for example `[.][integration]` - so all integration tests are excluded from the default run but can be run by passing `[integration]` on the command line). As a short-cut you can combine these by simply prefixing your user tag with a `.` - e.g. `[.integration]`. Because the hide tag has evolved to have several forms, all forms are added as tags if you use one of them.
+* `[.]` - causes test cases to be skipped from the default list (i.e. when no test cases have been explicitly selected through tag expressions or name wildcards). The hide tag is often combined with another, user, tag (for example `[.][integration]` - so all integration tests are excluded from the default run but can be run by passing `[integration]` on the command line). As a short-cut you can combine these by simply prefixing your user tag with a `.` - e.g. `[.integration]`.
 
 * `[!throws]` - lets Catch know that this test is likely to throw an exception even if successful. This causes the test to be excluded when running with `-e` or `--nothrow`.
 

docs/tostring.md

@@ -64,7 +64,7 @@ namespace Catch {
 By default all exceptions deriving from `std::exception` will be translated to strings by calling the `what()` method. For exception types that do not derive from `std::exception` - or if `what()` does not return a suitable string - use `CATCH_TRANSLATE_EXCEPTION`. This defines a function that takes your exception type, by reference, and returns a string. It can appear anywhere in the code - it doesn't have to be in the same translation unit. For example:
 
 ```cpp
-CATCH_TRANSLATE_EXCEPTION( MyType& ex ) {
+CATCH_TRANSLATE_EXCEPTION( MyType const& ex ) {
     return ex.message();
 }
 ```

docs/tutorial.md

@@ -106,7 +106,7 @@ Of course there are still more issues to deal with. For example we'll hit proble
 Although this was a simple test it's been enough to demonstrate a few things about how Catch is used. Let's take a moment to consider those before we move on.
 
 1. All we did was ```#define``` one identifier and ```#include``` one header and we got everything - even an implementation of ```main()``` that will [respond to command line arguments](command-line.md#top). You can only use that ```#define``` in one implementation file, for (hopefully) obvious reasons. Once you have more than one file with unit tests in you'll just ```#include "catch.hpp"``` and go. Usually it's a good idea to have a dedicated implementation file that just has ```#define CATCH_CONFIG_MAIN``` and ```#include "catch.hpp"```. You can also provide your own implementation of main and drive Catch yourself (see [Supplying-your-own-main()](own-main.md#top)).
-2. We introduce test cases with the ```TEST_CASE``` macro. This macro takes one or two arguments - a free form test name and, optionally, one or more tags (for more see <a href="#test-cases-and-sections">Test cases and Sections</a>, ). The test name must be unique. You can run sets of tests by specifying a wildcarded test name or a tag expression. See the [command line docs](command-line.md#top) for more information on running tests.
+2. We introduce test cases with the ```TEST_CASE``` macro. This macro takes one or two arguments - a free form test name and, optionally, one or more tags (for more see <a href="#test-cases-and-sections">Test cases and Sections</a>). The test name must be unique. You can run sets of tests by specifying a wildcarded test name or a tag expression. See the [command line docs](command-line.md#top) for more information on running tests.
 3. The name and tags arguments are just strings. We haven't had to declare a function or method - or explicitly register the test case anywhere. Behind the scenes a function with a generated name is defined for you, and automatically registered using static registry classes. By abstracting the function name away we can name our tests without the constraints of identifier names.
 4. We write our individual test assertions using the ```REQUIRE``` macro. Rather than a separate macro for each type of condition we express the condition naturally using C/C++ syntax. Behind the scenes a simple set of expression templates captures the left-hand-side and right-hand-side of the expression so we can display the values in our test report. As we'll see later there _are_ other assertion macros - but because of this technique the number of them is drastically reduced.
 

examples/000-CatchMain.cpp

@@ -4,7 +4,7 @@
 // of a testing binary, and other test files to link against it.
 
 // Let Catch provide main():
-#include <catch2/catch_default_main.hpp>
+#include <catch2/internal/catch_default_main.hpp>
 
 // That's it
 

examples/010-TestCase.cpp

@@ -1,12 +1,8 @@
 // 010-TestCase.cpp
-
-// Let Catch provide main():
-#include <catch2/catch_default_main.hpp>
-
 // And write tests in the same file:
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 
-int Factorial( int number ) {
+static int Factorial( int number ) {
    return number <= 1 ? number : Factorial( number - 1 ) * number;  // fail
 // return number <= 1 ? 1      : Factorial( number - 1 ) * number;  // pass
 }

examples/020-TestCase-1.cpp

@@ -1,12 +1,6 @@
 // 020-TestCase-1.cpp
 
-// In a Catch project with multiple files, dedicate one file to compile the
-// source code of Catch itself and reuse the resulting object file for linking.
-
-// Let Catch provide main():
-#include <catch2/catch_default_main.hpp>
-
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 
 TEST_CASE( "1: All test cases reside in other .cpp files (empty)", "[multi-file:1]" ) {
 }

examples/020-TestCase-2.cpp

@@ -2,9 +2,9 @@
 
 // main() provided by Catch in file 020-TestCase-1.cpp.
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 
-int Factorial( int number ) {
+static int Factorial( int number ) {
    return number <= 1 ? number : Factorial( number - 1 ) * number;  // fail
 // return number <= 1 ? 1      : Factorial( number - 1 ) * number;  // pass
 }

examples/030-Asn-Require-Check.cpp

@@ -10,9 +10,9 @@
 
 // main() provided in 000-CatchMain.cpp
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 
-std::string one() {
+static std::string one() {
     return "1";
 }
 

examples/100-Fix-Section.cpp

@@ -6,7 +6,8 @@
 
 // main() provided in 000-CatchMain.cpp
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <vector>
 
 TEST_CASE( "vectors can be sized and resized", "[vector]" ) {
 

examples/110-Fix-ClassFixture.cpp

@@ -6,7 +6,7 @@
 
 // main() provided in 000-CatchMain.cpp
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 
 class DBConnection
 {

examples/120-Bdd-ScenarioGivenWhenThen.cpp

@@ -2,7 +2,7 @@
 
 // main() provided in 000-CatchMain.cpp
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 
 SCENARIO( "vectors can be sized and resized", "[vector]" ) {
 

examples/210-Evt-EventListeners.cpp

@@ -5,18 +5,18 @@
 // 2. My listener and registration
 // 3. Test cases
 
-// main() provided in 000-CatchMain.cpp
-
-// Let Catch provide the required interfaces:
-#define CATCH_CONFIG_EXTERNAL_INTERFACES
-
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/reporters/catch_reporter_event_listener.hpp>
+#include <catch2/catch_reporter_registrars.hpp>
+#include <catch2/catch_test_case_info.hpp>
 #include <iostream>
 
 // -----------------------------------------------------------------------
 // 1. Printing of listener data:
 //
 
+
+namespace {
 std::string ws(int const level) {
     return std::string( 2 * level, ' ' );
 }
@@ -28,11 +28,10 @@ std::ostream& operator<<(std::ostream& out, Catch::Tag t) {
 template< typename T >
 std::ostream& operator<<( std::ostream& os, std::vector<T> const& v ) {
     os << "{ ";
-    for ( auto x : v )
+    for ( const auto& x : v )
         os << x << ", ";
     return os << "}";
 }
-
 // struct SourceLineInfo {
 //     char const* file;
 //     std::size_t line;
@@ -61,7 +60,7 @@ void print( std::ostream& os, int const level, Catch::MessageInfo const& info )
 
 void print( std::ostream& os, int const level, std::string const& title, std::vector<Catch::MessageInfo> const& v ) {
     os << ws(level  ) << title << ":\n";
-    for ( auto x : v )
+    for ( const auto& x : v )
     {
         os << ws(level+1) << "{\n";
         print( os, level+2, x );
@@ -279,8 +278,8 @@ void print( std::ostream& os, int const level, std::string const& title, Catch::
     print( os, level+1 , "- getSourceInfo(): ", info.getSourceInfo() );
     os << ws(level+1) << "- getTestMacroName(): '"  << info.getTestMacroName() << "'\n";
 
-//    print( os, level+1 , "- *** m_info (AssertionInfo)", info.m_info );
-//    print( os, level+1 , "- *** m_resultData (AssertionResultData)", info.m_resultData );
+    print( os, level+1 , "- *** m_info (AssertionInfo)", info.m_info );
+    print( os, level+1 , "- *** m_resultData (AssertionResultData)", info.m_resultData );
 }
 
 // struct AssertionStats {
@@ -303,10 +302,11 @@ void print( std::ostream& os, int const level, std::string const& title, Catch::
 char const * dashed_line =
     "--------------------------------------------------------------------------";
 
-struct MyListener : Catch::TestEventListenerBase {
 
-    using TestEventListenerBase::TestEventListenerBase; // inherit constructor
-    
+struct MyListener : Catch::EventListenerBase {
+
+    using EventListenerBase::EventListenerBase; // inherit constructor
+
     // Get rid of Wweak-tables
     ~MyListener();
 
@@ -373,6 +373,8 @@ struct MyListener : Catch::TestEventListenerBase {
     }
 };
 
+} // end anonymous namespace
+
 CATCH_REGISTER_LISTENER( MyListener )
 
 // Get rid of Wweak-tables

examples/231-Cfg-OutputStreams.cpp

@@ -5,10 +5,7 @@
 // semantic, because it buffers the output. For most uses however,
 // there is no important difference between having `std::cerr` buffered
 // or unbuffered.
-
-#include <catch2/catch_default_main.hpp>
-
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
 
 #include <sstream>
 #include <cstdio>
@@ -18,7 +15,7 @@ class out_buff : public std::stringbuf {
 public:
     out_buff(std::FILE* stream):m_stream(stream) {}
     ~out_buff();
-    int sync() {
+    int sync() override {
         int ret = 0;
         for (unsigned char c : str()) {
             if (putc(c, m_stream) == EOF) {

examples/300-Gen-OwnGenerator.cpp

@@ -4,10 +4,14 @@
 // Specifically we will implement a random number generator for integers
 // It will have infinite capacity and settable lower/upper bound
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/generators/catch_generators.hpp>
+#include <catch2/generators/catch_generators_adapters.hpp>
 
 #include <random>
 
+namespace {
+
 // This class shows how to implement a simple generator for Catch tests
 class RandomIntGenerator : public Catch::Generators::IGenerator<int> {
     std::minstd_rand m_rand;
@@ -38,9 +42,15 @@ int const& RandomIntGenerator::get() const {
 // Notice that it returns an instance of GeneratorWrapper<int>, which
 // is a value-wrapper around std::unique_ptr<IGenerator<int>>.
 Catch::Generators::GeneratorWrapper<int> random(int low, int high) {
-    return Catch::Generators::GeneratorWrapper<int>(std::unique_ptr<Catch::Generators::IGenerator<int>>(new RandomIntGenerator(low, high)));
+    return Catch::Generators::GeneratorWrapper<int>(
+        new RandomIntGenerator(low, high)
+        // Another possibility:
+        // Catch::Detail::make_unique<RandomIntGenerator>(low, high)
+    );
 }
 
+} // end anonymous namespaces
+
 // The two sections in this test case are equivalent, but the first one
 // is much more readable/nicer to use
 TEST_CASE("Generating random ints", "[example][generator]") {
@@ -50,7 +60,7 @@ TEST_CASE("Generating random ints", "[example][generator]") {
         REQUIRE(i <= 100);
     }
     SECTION("Creating the random generator directly") {
-        auto i = GENERATE(take(100, GeneratorWrapper<int>(std::unique_ptr<IGenerator<int>>(new RandomIntGenerator(-100, 100)))));
+        auto i = GENERATE(take(100, GeneratorWrapper<int>(Catch::Detail::make_unique<RandomIntGenerator>(-100, 100))));
         REQUIRE(i >= -100);
         REQUIRE(i <= 100);
     }

examples/301-Gen-MapTypeConversion.cpp

@@ -1,13 +1,18 @@
 // 301-Gen-MapTypeConversion.cpp
 // Shows how to use map to modify generator's return type.
 
-// TODO
+// Specifically we wrap a std::string returning generator with a generator
+// that converts the strings using stoi, so the returned type is actually
+// an int.
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/generators/catch_generators_adapters.hpp>
 
 #include <string>
 #include <sstream>
 
+namespace {
+
 // Returns a line from a stream. You could have it e.g. read lines from
 // a file, but to avoid problems with paths in examples, we will use
 // a fixed stringstream.
@@ -18,12 +23,12 @@ public:
     LineGenerator() {
         m_stream.str("1\n2\n3\n4\n");
         if (!next()) {
-            throw Catch::GeneratorException("Couldn't read a single line");
+            Catch::Generators::Detail::throw_generator_exception("Couldn't read a single line");
         }
     }
 
     std::string const& get() const override;
-    
+
     bool next() override {
         return !!std::getline(m_stream, m_line);
     }
@@ -38,18 +43,17 @@ std::string const& LineGenerator::get() const {
 // is a value-wrapper around std::unique_ptr<IGenerator<std::string>>.
 Catch::Generators::GeneratorWrapper<std::string> lines(std::string /* ignored for example */) {
     return Catch::Generators::GeneratorWrapper<std::string>(
-        std::unique_ptr<Catch::Generators::IGenerator<std::string>>(
-            new LineGenerator()
-        )
+        new LineGenerator()
     );
 }
 
+} // end anonymous namespace
 
 
 TEST_CASE("filter can convert types inside the generator expression", "[example][generator]") {
     auto num = GENERATE(map<int>([](std::string const& line) { return std::stoi(line); },
                                  lines("fake-file")));
-                                 
+
     REQUIRE(num > 0);
 }
 

examples/302-Gen-Table.cpp

@@ -0,0 +1,55 @@
+// 302-Gen-Table.cpp
+// Shows how to use table to run a test many times with different inputs. Lifted from examples on
+// issue #850.
+
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/generators/catch_generators.hpp>
+#include <string>
+
+struct TestSubject {
+    // this is the method we are going to test. It returns the length of the
+    // input string.
+    size_t GetLength( const std::string& input ) const { return input.size(); }
+};
+
+
+TEST_CASE("Table allows pre-computed test inputs and outputs", "[example][generator]") {
+    using std::make_tuple;
+    // do setup here as normal
+    TestSubject subj;
+
+    SECTION("This section is run for each row in the table") {
+        std::string test_input;
+        size_t expected_output;
+        std::tie( test_input, expected_output ) =
+            GENERATE( table<std::string, size_t>(
+                { /* In this case one of the parameters to our test case is the
+                   * expected output, but this is not required. There could be
+                   * multiple expected values in the table, which can have any
+                   * (fixed) number of columns.
+                   */
+                  make_tuple( "one", 3 ),
+                  make_tuple( "two", 3 ),
+                  make_tuple( "three", 5 ),
+                  make_tuple( "four", 4 ) } ) );
+
+        // run the test
+        auto result = subj.GetLength(test_input);
+        // capture the input data to go with the outputs.
+        CAPTURE(test_input);
+        // check it matches the pre-calculated data
+        REQUIRE(result == expected_output);
+    }   // end section
+}
+
+/* Possible simplifications where less legacy toolchain support is needed:
+ *
+ * - 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 preceeding variable delcarations can be
+ * replaced by structured bindings: auto [test_input, expected] = GENERATE(
+ * table<std::string, size_t>({ ...
+ */
+// Compiling and running this file will result in 4 successful assertions

examples/310-Gen-VariablesInGenerators.cpp

@@ -6,7 +6,9 @@
 // _WILL_ outlive the variables -- thus they should be either captured
 // by value directly, or copied by the generators during construction.
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/generators/catch_generators_adapters.hpp>
+#include <catch2/generators/catch_generators_random.hpp>
 
 TEST_CASE("Generate random doubles across different ranges",
           "[generator][example][advanced]") {

examples/311-Gen-CustomCapture.cpp

@@ -9,7 +9,9 @@
 // per-variable custom capture list, this example shows how to achieve
 // that.
 
-#include <catch2/catch.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/generators/catch_generators_adapters.hpp>
+#include <catch2/generators/catch_generators_random.hpp>
 
 TEST_CASE("Generate random doubles across different ranges",
           "[generator][example][advanced]") {
@@ -23,11 +25,11 @@ TEST_CASE("Generate random doubles across different ranges",
     }));
 
     auto r2(r1);
-    
+
     // This will take r1 by reference and r2 by value.
     // Note that there are no advantages for doing so in this example,
     // it is done only for expository purposes.
-    auto number = Catch::Generators::generate( CATCH_INTERNAL_LINEINFO,
+    auto number = Catch::Generators::generate( "custom capture generator", CATCH_INTERNAL_LINEINFO,
         [&r1, r2]{
             using namespace Catch::Generators;
             return makeGenerators(take(50, random(std::get<0>(r1), std::get<1>(r2))));

examples/CMakeLists.txt

@@ -32,6 +32,7 @@ set( SOURCES_IDIOMATIC_EXAMPLES
     210-Evt-EventListeners.cpp
     300-Gen-OwnGenerator.cpp
     301-Gen-MapTypeConversion.cpp
+    302-Gen-Table.cpp
     310-Gen-VariablesInGenerators.cpp
     311-Gen-CustomCapture.cpp
 )
@@ -42,7 +43,6 @@ set( TARGETS_IDIOMATIC_EXAMPLES ${BASENAMES_IDIOMATIC_EXAMPLES} )
 
 foreach( name ${TARGETS_IDIOMATIC_EXAMPLES} )
     add_executable( ${name}
-      000-CatchMain.cpp
       ${EXAMPLES_DIR}/${name}.cpp )
 endforeach()
 
@@ -53,20 +53,11 @@ set(ALL_EXAMPLE_TARGETS
 )
 
 foreach( name ${ALL_EXAMPLE_TARGETS} )
-    target_link_libraries( ${name} Catch2 )
+    target_link_libraries( ${name} Catch2 Catch2WithMain )
     set_property(TARGET ${name} PROPERTY CXX_STANDARD 14)
     set_property(TARGET ${name} PROPERTY CXX_EXTENSIONS OFF)
-
-    # Add desired warnings
-    if ( CMAKE_CXX_COMPILER_ID MATCHES "Clang|AppleClang|GNU" )
-        target_compile_options( ${name}  PRIVATE -Wall -Wextra -Wunreachable-code )
-    endif()
-    # Clang specific warning go here
-    if ( CMAKE_CXX_COMPILER_ID MATCHES "Clang" )
-        # Actually keep these
-        target_compile_options( ${name}  PRIVATE -Wweak-vtables -Wexit-time-destructors -Wglobal-constructors -Wmissing-noreturn )
-    endif()
-    if ( CMAKE_CXX_COMPILER_ID MATCHES "MSVC" )
-        target_compile_options( ${name}  PRIVATE /W4 /w44265 /WX )
-    endif()
 endforeach()
+
+
+list(APPEND CATCH_WARNING_TARGETS ${ALL_EXAMPLE_TARGETS})
+set(CATCH_WARNING_TARGETS ${CATCH_WARNING_TARGETS} PARENT_SCOPE)

extras/Catch.cmake

@@ -33,6 +33,10 @@ same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
                          [TEST_SUFFIX suffix]
                          [PROPERTIES name1 value1...]
                          [TEST_LIST var]
+                         [REPORTER reporter]
+                         [OUTPUT_DIR dir]
+                         [OUTPUT_PREFIX prefix}
+                         [OUTPUT_SUFFIX suffix]
     )
 
   ``catch_discover_tests`` sets up a post-build command on the test executable
@@ -90,6 +94,28 @@ same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
     executable is being used in multiple calls to ``catch_discover_tests()``.
     Note that this variable is only available in CTest.
 
+  ``REPORTER reporter``
+    Use the specified reporter when running the test case. The reporter will
+    be passed to the Catch executable as ``--reporter reporter``.
+
+  ``OUTPUT_DIR dir``
+    If specified, the parameter is passed along as
+    ``--out dir/<test_name>`` to Catch executable. The actual file name is the
+    same as the test name. This should be used instead of
+    ``EXTRA_ARGS --out foo`` to avoid race conditions writing the result output
+    when using parallel test execution.
+
+  ``OUTPUT_PREFIX prefix``
+    May be used in conjunction with ``OUTPUT_DIR``.
+    If specified, ``prefix`` is added to each output file name, like so
+    ``--out dir/prefix<test_name>``.
+
+  ``OUTPUT_SUFFIX suffix``
+    May be used in conjunction with ``OUTPUT_DIR``.
+    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 e.g. ".xml".
+
 #]=======================================================================]
 
 #------------------------------------------------------------------------------
@@ -97,7 +123,7 @@ function(catch_discover_tests TARGET)
   cmake_parse_arguments(
     ""
     ""
-    "TEST_PREFIX;TEST_SUFFIX;WORKING_DIRECTORY;TEST_LIST"
+    "TEST_PREFIX;TEST_SUFFIX;WORKING_DIRECTORY;TEST_LIST;REPORTER;OUTPUT_DIR;OUTPUT_PREFIX;OUTPUT_SUFFIX"
     "TEST_SPEC;EXTRA_ARGS;PROPERTIES"
     ${ARGN}
   )
@@ -110,7 +136,7 @@ function(catch_discover_tests TARGET)
   endif()
 
   ## Generate a unique name based on the extra arguments
-  string(SHA1 args_hash "${_TEST_SPEC} ${_EXTRA_ARGS}")
+  string(SHA1 args_hash "${_TEST_SPEC} ${_EXTRA_ARGS} ${_REPORTER} ${_OUTPUT_DIR} ${_OUTPUT_PREFIX} ${_OUTPUT_SUFFIX}")
   string(SUBSTRING ${args_hash} 0 7 args_hash)
 
   # Define rule to generate test list for aforementioned test executable
@@ -134,6 +160,10 @@ function(catch_discover_tests TARGET)
             -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 "CTEST_FILE=${ctest_tests_file}"
             -P "${_CATCH_DISCOVER_TESTS_SCRIPT}"
     VERBATIM

extras/CatchAddTests.cmake

@@ -6,6 +6,10 @@ 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(script)
 set(suite)
 set(tests)
@@ -29,16 +33,12 @@ if(NOT EXISTS "${TEST_EXECUTABLE}")
   )
 endif()
 execute_process(
-  COMMAND ${TEST_EXECUTOR} "${TEST_EXECUTABLE}" ${spec} --list-test-names-only
+  COMMAND ${TEST_EXECUTOR} "${TEST_EXECUTABLE}" ${spec} --list-tests --verbosity quiet
   OUTPUT_VARIABLE output
   RESULT_VARIABLE result
+  WORKING_DIRECTORY "${TEST_WORKING_DIR}"
 )
-# Catch --list-test-names-only reports the number of tests, so 0 is... surprising
-if(${result} EQUAL 0)
-  message(WARNING
-    "Test executable '${TEST_EXECUTABLE}' contains no tests!\n"
-  )
-elseif(${result} LESS 0)
+if(NOT ${result} EQUAL 0)
   message(FATAL_ERROR
     "Error running test executable '${TEST_EXECUTABLE}':\n"
     "  Result: ${result}\n"
@@ -48,6 +48,44 @@ 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(${reporters_result} EQUAL 0)
+  message(WARNING
+    "Test executable '${TEST_EXECUTABLE}' contains no reporters!\n"
+  )
+elseif(${reporters_result} LESS 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()
+
 # Parse output
 foreach(line ${output})
   set(test ${line})
@@ -56,6 +94,12 @@ foreach(line ${output})
   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}"
@@ -63,6 +107,8 @@ foreach(line ${output})
     "${TEST_EXECUTABLE}"
     "${test_name}"
     ${extra_args}
+    "${reporter_arg}"
+    "${output_dir_arg}"
   )
   add_command(set_tests_properties
     "${prefix}${test}${suffix}"

extras/ParseAndAddCatchTests.cmake

@@ -1,9 +1,11 @@
 #==================================================================================================#
 #  supported macros                                                                                #
 #    - TEST_CASE,                                                                                  #
+#    - TEMPLATE_TEST_CASE                                                                          #
 #    - SCENARIO,                                                                                   #
 #    - TEST_CASE_METHOD,                                                                           #
 #    - CATCH_TEST_CASE,                                                                            #
+#    - CATCH_TEMPLATE_TEST_CASE                                                                    #
 #    - CATCH_SCENARIO,                                                                             #
 #    - CATCH_TEST_CASE_METHOD.                                                                     #
 #                                                                                                  #
@@ -106,7 +108,7 @@ function(ParseAndAddCatchTests_ParseFile SourceFile TestTarget)
     ParseAndAddCatchTests_RemoveComments(Contents)
 
     # Find definition of test names
-    string(REGEX MATCHALL "[ \t]*(CATCH_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)[ \t]*\\([^\)]+\\)+[ \t\n]*{+[ \t]*(//[^\n]*[Tt][Ii][Mm][Ee][Oo][Uu][Tt][ \t]*[0-9]+)*" Tests "${Contents}")
+    string(REGEX MATCHALL "[ \t]*(CATCH_)?(TEMPLATE_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)[ \t]*\\([ \t\n]*\"[^\"]*\"[ \t\n]*,[ \t\n]*\"[^\"]*\"([^\(\)]+(\\([^\)]*\\))*)*\\)+[ \t\n]*{+[ \t]*(//[^\n]*[Tt][Ii][Mm][Ee][Oo][Uu][Tt][ \t]*[0-9]+)*" Tests "${Contents}")
 
     if(PARSE_CATCH_TESTS_ADD_TO_CONFIGURE_DEPENDS AND Tests)
       ParseAndAddCatchTests_PrintDebugMessage("Adding ${SourceFile} to CMAKE_CONFIGURE_DEPENDS property")
@@ -122,8 +124,8 @@ function(ParseAndAddCatchTests_ParseFile SourceFile TestTarget)
         string(REGEX REPLACE "\\\\\n|\n" "" TestName "${TestName}")
 
         # Get test type and fixture if applicable
-        string(REGEX MATCH "(CATCH_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)[ \t]*\\([^,^\"]*" TestTypeAndFixture "${TestName}")
-        string(REGEX MATCH "(CATCH_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)" TestType "${TestTypeAndFixture}")
+        string(REGEX MATCH "(CATCH_)?(TEMPLATE_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)[ \t]*\\([^,^\"]*" TestTypeAndFixture "${TestName}")
+        string(REGEX MATCH "(CATCH_)?(TEMPLATE_)?(TEST_CASE_METHOD|SCENARIO|TEST_CASE)" TestType "${TestTypeAndFixture}")
         string(REGEX REPLACE "${TestType}\\([ \t]*" "" TestFixture "${TestTypeAndFixture}")
 
         # Get string parts of test definition
@@ -144,7 +146,7 @@ function(ParseAndAddCatchTests_ParseFile SourceFile TestTarget)
         if("${TestType}" STREQUAL "SCENARIO")
             set(Name "Scenario: ${Name}")
         endif()
-        if(PARSE_CATCH_TESTS_ADD_FIXTURE_IN_TEST_NAME AND TestFixture)
+        if(PARSE_CATCH_TESTS_ADD_FIXTURE_IN_TEST_NAME AND "${TestType}" MATCHES "(CATCH_)?TEST_CASE_METHOD" AND TestFixture )
             set(CTestName "${TestFixture}:${Name}")
         else()
             set(CTestName "${Name}")
@@ -189,24 +191,35 @@ function(ParseAndAddCatchTests_ParseFile SourceFile TestTarget)
             # Escape commas in the test spec
             string(REPLACE "," "\\," Name ${Name})
 
+            # Work around CMake 3.18.0 change in `add_test()`, before the escaped quotes were neccessary,
+            # only with CMake 3.18.0 the escaped double quotes confuse the call. This change is reverted in 3.18.1
+            if(NOT ${CMAKE_VERSION} VERSION_EQUAL "3.18")
+                set(CTestName "\"${CTestName}\"")
+            endif()
+
+	    # Handle template test cases
+	    if("${TestTypeAndFixture}" MATCHES ".*TEMPLATE_.*")
+	      set(Name "${Name} - *")
+	    endif()
+
             # Add the test and set its properties
-            add_test(NAME "\"${CTestName}\"" COMMAND ${OptionalCatchTestLauncher} $<TARGET_FILE:${TestTarget}> ${Name} ${AdditionalCatchParameters})
+            add_test(NAME "${CTestName}" COMMAND ${OptionalCatchTestLauncher} $<TARGET_FILE:${TestTarget}> ${Name} ${AdditionalCatchParameters})
             # Old CMake versions do not document VERSION_GREATER_EQUAL, so we use VERSION_GREATER with 3.8 instead
             if(PARSE_CATCH_TESTS_NO_HIDDEN_TESTS AND ${HiddenTagFound} AND ${CMAKE_VERSION} VERSION_GREATER "3.8")
                 ParseAndAddCatchTests_PrintDebugMessage("Setting DISABLED test property")
-                set_tests_properties("\"${CTestName}\"" PROPERTIES DISABLED ON)
+                set_tests_properties("${CTestName}" PROPERTIES DISABLED ON)
             else()
-                set_tests_properties("\"${CTestName}\"" PROPERTIES FAIL_REGULAR_EXPRESSION "No tests ran"
+                set_tests_properties("${CTestName}" PROPERTIES FAIL_REGULAR_EXPRESSION "No tests ran"
                                                         LABELS "${Labels}")
             endif()
             set_property(
               TARGET ${TestTarget}
               APPEND
-              PROPERTY ParseAndAddCatchTests_TESTS "\"${CTestName}\"")
+              PROPERTY ParseAndAddCatchTests_TESTS "${CTestName}")
             set_property(
               SOURCE ${SourceFile}
               APPEND
-              PROPERTY ParseAndAddCatchTests_TESTS "\"${CTestName}\"")
+              PROPERTY ParseAndAddCatchTests_TESTS "${CTestName}")
         endif()
 
 

fuzzing/CMakeLists.txt

@@ -0,0 +1,20 @@
+# License: Boost 1.0
+# By Paul Dreik 2020
+
+# add a library that brings in the main() function from libfuzzer
+# and has all the dependencies, so the individual fuzzers can be
+# added one line each.
+add_library(fuzzhelper NullOStream.h NullOStream.cpp)
+target_link_libraries(fuzzhelper PUBLIC Catch2::Catch2)
+
+# use C++17 so we can get string_view
+target_compile_features(fuzzhelper PUBLIC cxx_std_17)
+
+# This should be possible to set from the outside to be oss-fuzz compatible,
+# fix later. For now, target libFuzzer only.
+target_link_options(fuzzhelper PUBLIC "-fsanitize=fuzzer")
+
+foreach(fuzzer TestSpecParser XmlWriter textflow)
+add_executable(fuzz_${fuzzer} fuzz_${fuzzer}.cpp)
+target_link_libraries(fuzz_${fuzzer} PRIVATE fuzzhelper)
+endforeach()

fuzzing/NullOStream.cpp

@@ -0,0 +1,10 @@
+#include "NullOStream.h"
+
+void NullOStream::avoidOutOfLineVirtualCompilerWarning()
+{
+}
+
+int NullStreambuf::overflow(int c){
+    setp(dummyBuffer, dummyBuffer + sizeof(dummyBuffer));
+    return (c == traits_type::eof()) ? '\0' : c;
+}

fuzzing/NullOStream.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <ostream>
+#include <streambuf>
+
+// from https://stackoverflow.com/a/8244052
+class NullStreambuf : public std::streambuf {
+  char dummyBuffer[64];
+
+protected:
+  virtual int overflow(int c) override final;
+};
+
+class NullOStream final : private NullStreambuf, public std::ostream {
+public:
+  NullOStream() : std::ostream(this) {}
+  NullStreambuf *rdbuf() { return this; }
+  virtual void avoidOutOfLineVirtualCompilerWarning();
+};
+

fuzzing/build_fuzzers.sh

@@ -0,0 +1,33 @@
+#!/bin/sh
+#
+# Builds the fuzzers
+#
+# By Paul Dreik 20200923
+set -exu
+
+CATCHROOT=$(readlink -f $(dirname $0)/..)
+
+
+BUILDDIR=$CATCHROOT/build-fuzzers
+mkdir -p $BUILDDIR
+cd $BUILDDIR
+
+if which /usr/lib/ccache/clang++ >/dev/null 2>&1 ; then
+ CXX=/usr/lib/ccache/clang++
+else
+ CXX=clang++
+fi
+
+cmake $CATCHROOT \
+  -DCMAKE_CXX_COMPILER=$CXX \
+  -DCMAKE_CXX_FLAGS="-fsanitize=fuzzer-no-link,address,undefined -O3 -g" \
+  -DCATCH_DEVELOPMENT_BUILD=On \
+  -DCATCH_BUILD_EXAMPLES=Off \
+  -DCATCH_BUILD_EXTRA_TESTS=Off \
+  -DCATCH_BUILD_TESTING=Off \
+  -DBUILD_TESTING=Off \
+  -DCATCH_ENABLE_WERROR=Off \
+  -DCATCH_BUILD_FUZZERS=On
+
+cmake --build . -j $(nproc)
+

fuzzing/fuzz_TestSpecParser.cpp

@@ -0,0 +1,16 @@
+//License: Boost 1.0
+//By Paul Dreik 2020
+
+#include <catch2/internal/catch_test_spec_parser.hpp>
+#include <catch2/internal/catch_tag_alias_registry.hpp>
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
+
+    Catch::TagAliasRegistry tar;
+    Catch::TestSpecParser tsp(tar);
+
+    std::string buf(Data,Data+Size);
+    tsp.parse(buf);
+
+    return 0;
+}

fuzzing/fuzz_XmlWriter.cpp

@@ -0,0 +1,16 @@
+//License: Boost 1.0
+//By Paul Dreik 2020
+
+#include <catch2/internal/catch_xmlwriter.hpp>
+
+#include "NullOStream.h"
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
+
+    std::string buf(Data,Data+Size);
+    NullOStream nul;
+    Catch::XmlEncode encode(buf);
+    encode.encodeTo(nul);
+    return 0;
+}
+

fuzzing/fuzz_textflow.cpp

@@ -0,0 +1,47 @@
+//License: Boost 1.0
+//By Paul Dreik 2020
+
+#include <catch2/internal/catch_textflow.hpp>
+
+#include "NullOStream.h"
+
+#include <string>
+#include <string_view>
+
+
+template<class Callback>
+void split(const char *Data, size_t Size, Callback callback) {
+
+    using namespace std::literals;
+    constexpr auto sep="\n~~~\n"sv;
+
+    std::string_view remainder(Data,Size);
+    for (;;) {
+        auto pos=remainder.find(sep);
+        if(pos==std::string_view::npos) {
+            //not found. use the remainder and exit
+            callback(remainder);
+            return;
+        } else {
+            //found. invoke callback on the first part, then proceed with the rest.
+            callback(remainder.substr(0,pos));
+            remainder=remainder.substr(pos+sep.size());
+        }
+    }
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
+
+    Catch::TextFlow::Columns columns;
+
+    // break the input on separator
+    split((const char*)Data,Size,[&](std::string_view word) {
+        columns+=Catch::TextFlow::Column(std::string(word));
+    });
+
+    NullOStream nul;
+    nul << columns;
+
+    return 0;
+}
+

single_include/catch2/catch_reporter_automake.hpp

@@ -1,62 +0,0 @@
-/*
- *  Created by Justin R. Wilson on 2/19/2017.
- *  Copyright 2017 Justin R. Wilson. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
-
-// Don't #include any Catch headers here - we can assume they are already
-// included before this header.
-// This is not good practice in general but is necessary in this case so this
-// file can be distributed as a single header that works with the main
-// Catch single header.
-
-namespace Catch {
-
-    struct AutomakeReporter : StreamingReporterBase<AutomakeReporter> {
-        AutomakeReporter( ReporterConfig const& _config )
-          :   StreamingReporterBase( _config )
-        {}
-
-        ~AutomakeReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results in the format of Automake .trs files";
-        }
-
-        void assertionStarting( AssertionInfo const& ) override {}
-
-        bool assertionEnded( AssertionStats const& /*_assertionStats*/ ) override { return true; }
-
-        void testCaseEnded( TestCaseStats const& _testCaseStats ) override {
-            // Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
-            stream << ":test-result: ";
-            if (_testCaseStats.totals.assertions.allPassed()) {
-                stream << "PASS";
-            } else if (_testCaseStats.totals.assertions.allOk()) {
-                stream << "XFAIL";
-            } else {
-                stream << "FAIL";
-            }
-            stream << ' ' << _testCaseStats.testInfo.name << '\n';
-            StreamingReporterBase::testCaseEnded( _testCaseStats );
-        }
-
-        void skipTest( TestCaseInfo const& testInfo ) override {
-            stream << ":test-result: SKIP " << testInfo.name << '\n';
-        }
-
-    };
-
-#ifdef CATCH_IMPL
-    AutomakeReporter::~AutomakeReporter() {}
-#endif
-
-    CATCH_REGISTER_REPORTER( "automake", AutomakeReporter)
-
-} // end namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED

single_include/catch2/catch_reporter_tap.hpp

@@ -1,253 +0,0 @@
-/*
- *  Created by Colton Wolkins on 2015-08-15.
- *  Copyright 2015 Martin Moene. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
-
-
-// Don't #include any Catch headers here - we can assume they are already
-// included before this header.
-// This is not good practice in general but is necessary in this case so this
-// file can be distributed as a single header that works with the main
-// Catch single header.
-
-#include <algorithm>
-
-namespace Catch {
-
-    struct TAPReporter : StreamingReporterBase<TAPReporter> {
-
-        using StreamingReporterBase::StreamingReporterBase;
-
-        ~TAPReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results in TAP format, suitable for test harnesses";
-        }
-
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
-
-        void noMatchingTestCases( std::string const& spec ) override {
-            stream << "# No test cases matched '" << spec << "'" << std::endl;
-        }
-
-        void assertionStarting( AssertionInfo const& ) override {}
-
-        bool assertionEnded( AssertionStats const& _assertionStats ) override {
-            ++counter;
-
-            stream << "# " << currentTestCaseInfo->name << std::endl;
-            AssertionPrinter printer( stream, _assertionStats, counter );
-            printer.print();
-
-            stream << std::endl;
-            return true;
-        }
-
-        void testRunEnded( TestRunStats const& _testRunStats ) override {
-            printTotals( _testRunStats.totals );
-            stream << "\n" << std::endl;
-            StreamingReporterBase::testRunEnded( _testRunStats );
-        }
-
-    private:
-        std::size_t counter = 0;
-        class AssertionPrinter {
-        public:
-            AssertionPrinter& operator= ( AssertionPrinter const& ) = delete;
-            AssertionPrinter( AssertionPrinter const& ) = delete;
-            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter )
-            : stream( _stream )
-            , result( _stats.assertionResult )
-            , messages( _stats.infoMessages )
-            , itMessage( _stats.infoMessages.begin() )
-            , printInfoMessages( true )
-            , counter(_counter)
-            {}
-
-            void print() {
-                itMessage = messages.begin();
-
-                switch( result.getResultType() ) {
-                    case ResultWas::Ok:
-                        printResultType( passedString() );
-                        printOriginalExpression();
-                        printReconstructedExpression();
-                        if ( ! result.hasExpression() )
-                            printRemainingMessages( Colour::None );
-                        else
-                            printRemainingMessages();
-                        break;
-                    case ResultWas::ExpressionFailed:
-                        if (result.isOk()) {
-                            printResultType(passedString());
-                        } else {
-                            printResultType(failedString());
-                        }
-                        printOriginalExpression();
-                        printReconstructedExpression();
-                        if (result.isOk()) {
-                            printIssue(" # TODO");
-                        }
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::ThrewException:
-                        printResultType( failedString() );
-                        printIssue( "unexpected exception with message:" );
-                        printMessage();
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::FatalErrorCondition:
-                        printResultType( failedString() );
-                        printIssue( "fatal error condition with message:" );
-                        printMessage();
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::DidntThrowException:
-                        printResultType( failedString() );
-                        printIssue( "expected exception, got none" );
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::Info:
-                        printResultType( "info" );
-                        printMessage();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::Warning:
-                        printResultType( "warning" );
-                        printMessage();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::ExplicitFailure:
-                        printResultType( failedString() );
-                        printIssue( "explicitly" );
-                        printRemainingMessages( Colour::None );
-                        break;
-                    // These cases are here to prevent compiler warnings
-                    case ResultWas::Unknown:
-                    case ResultWas::FailureBit:
-                    case ResultWas::Exception:
-                        printResultType( "** internal error **" );
-                        break;
-                }
-            }
-
-        private:
-            static Colour::Code dimColour() { return Colour::FileName; }
-
-            static const char* failedString() { return "not ok"; }
-            static const char* passedString() { return "ok"; }
-
-            void printSourceInfo() const {
-                Colour colourGuard( dimColour() );
-                stream << result.getSourceInfo() << ":";
-            }
-
-            void printResultType( std::string const& passOrFail ) const {
-                if( !passOrFail.empty() ) {
-                    stream << passOrFail << ' ' << counter << " -";
-                }
-            }
-
-            void printIssue( std::string const& issue ) const {
-                stream << " " << issue;
-            }
-
-            void printExpressionWas() {
-                if( result.hasExpression() ) {
-                    stream << ";";
-                    {
-                        Colour colour( dimColour() );
-                        stream << " expression was:";
-                    }
-                    printOriginalExpression();
-                }
-            }
-
-            void printOriginalExpression() const {
-                if( result.hasExpression() ) {
-                    stream << " " << result.getExpression();
-                }
-            }
-
-            void printReconstructedExpression() const {
-                if( result.hasExpandedExpression() ) {
-                    {
-                        Colour colour( dimColour() );
-                        stream << " for: ";
-                    }
-                    std::string expr = result.getExpandedExpression();
-                    std::replace( expr.begin(), expr.end(), '\n', ' ');
-                    stream << expr;
-                }
-            }
-
-            void printMessage() {
-                if ( itMessage != messages.end() ) {
-                    stream << " '" << itMessage->message << "'";
-                    ++itMessage;
-                }
-            }
-
-            void printRemainingMessages( Colour::Code colour = dimColour() ) {
-                if (itMessage == messages.end()) {
-                    return;
-                }
-
-                // using messages.end() directly (or auto) yields compilation error:
-                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
-                const std::size_t N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );
-
-                {
-                    Colour colourGuard( colour );
-                    stream << " with " << pluralise( N, "message" ) << ":";
-                }
-
-                for(; itMessage != itEnd; ) {
-                    // If this assertion is a warning ignore any INFO messages
-                    if( printInfoMessages || itMessage->type != ResultWas::Info ) {
-                        stream << " '" << itMessage->message << "'";
-                        if ( ++itMessage != itEnd ) {
-                            Colour colourGuard( dimColour() );
-                            stream << " and";
-                        }
-                    }
-                }
-            }
-
-        private:
-            std::ostream& stream;
-            AssertionResult const& result;
-            std::vector<MessageInfo> messages;
-            std::vector<MessageInfo>::const_iterator itMessage;
-            bool printInfoMessages;
-            std::size_t counter;
-        };
-
-        void printTotals( const Totals& totals ) const {
-            if( totals.testCases.total() == 0 ) {
-                stream << "1..0 # Skipped: No tests ran.";
-            } else {
-                stream << "1.." << counter;
-            }
-        }
-    };
-
-#ifdef CATCH_IMPL
-    TAPReporter::~TAPReporter() {}
-#endif
-
-    CATCH_REGISTER_REPORTER( "tap", TAPReporter )
-
-} // end namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED

single_include/catch2/catch_reporter_teamcity.hpp

@@ -1,219 +0,0 @@
-/*
- *  Created by Phil Nash on 19th December 2014
- *  Copyright 2014 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
-
-// Don't #include any Catch headers here - we can assume they are already
-// included before this header.
-// This is not good practice in general but is necessary in this case so this
-// file can be distributed as a single header that works with the main
-// Catch single header.
-
-#include <cstring>
-
-#ifdef __clang__
-#   pragma clang diagnostic push
-#   pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-namespace Catch {
-
-    struct TeamCityReporter : StreamingReporterBase<TeamCityReporter> {
-        TeamCityReporter( ReporterConfig const& _config )
-        :   StreamingReporterBase( _config )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = true;
-        }
-
-        static std::string escape( std::string const& str ) {
-            std::string escaped = str;
-            replaceInPlace( escaped, "|", "||" );
-            replaceInPlace( escaped, "'", "|'" );
-            replaceInPlace( escaped, "\n", "|n" );
-            replaceInPlace( escaped, "\r", "|r" );
-            replaceInPlace( escaped, "[", "|[" );
-            replaceInPlace( escaped, "]", "|]" );
-            return escaped;
-        }
-        ~TeamCityReporter() override;
-
-        static std::string getDescription() {
-            return "Reports test results as TeamCity service messages";
-        }
-
-        void skipTest( TestCaseInfo const& /* testInfo */ ) override {
-        }
-
-        void noMatchingTestCases( std::string const& /* spec */ ) override {}
-
-        void testGroupStarting( GroupInfo const& groupInfo ) override {
-            StreamingReporterBase::testGroupStarting( groupInfo );
-            stream << "##teamcity[testSuiteStarted name='"
-                << escape( groupInfo.name ) << "']\n";
-        }
-        void testGroupEnded( TestGroupStats const& testGroupStats ) override {
-            StreamingReporterBase::testGroupEnded( testGroupStats );
-            stream << "##teamcity[testSuiteFinished name='"
-                << escape( testGroupStats.groupInfo.name ) << "']\n";
-        }
-
-
-        void assertionStarting( AssertionInfo const& ) override {}
-
-        bool assertionEnded( AssertionStats const& assertionStats ) override {
-            AssertionResult const& result = assertionStats.assertionResult;
-            if( !result.isOk() ) {
-
-                ReusableStringStream msg;
-                if( !m_headerPrintedForThisSection )
-                    printSectionHeader( msg.get() );
-                m_headerPrintedForThisSection = true;
-
-                msg << result.getSourceInfo() << "\n";
-
-                switch( result.getResultType() ) {
-                    case ResultWas::ExpressionFailed:
-                        msg << "expression failed";
-                        break;
-                    case ResultWas::ThrewException:
-                        msg << "unexpected exception";
-                        break;
-                    case ResultWas::FatalErrorCondition:
-                        msg << "fatal error condition";
-                        break;
-                    case ResultWas::DidntThrowException:
-                        msg << "no exception was thrown where one was expected";
-                        break;
-                    case ResultWas::ExplicitFailure:
-                        msg << "explicit failure";
-                        break;
-
-                    // We shouldn't get here because of the isOk() test
-                    case ResultWas::Ok:
-                    case ResultWas::Info:
-                    case ResultWas::Warning:
-                        CATCH_ERROR( "Internal error in TeamCity reporter" );
-                    // These cases are here to prevent compiler warnings
-                    case ResultWas::Unknown:
-                    case ResultWas::FailureBit:
-                    case ResultWas::Exception:
-                        CATCH_ERROR( "Not implemented" );
-                }
-                if( assertionStats.infoMessages.size() == 1 )
-                    msg << " with message:";
-                if( assertionStats.infoMessages.size() > 1 )
-                    msg << " with messages:";
-                for( auto const& messageInfo : assertionStats.infoMessages )
-                    msg << "\n  \"" << messageInfo.message << "\"";
-
-
-                if( result.hasExpression() ) {
-                    msg <<
-                        "\n  " << result.getExpressionInMacro() << "\n"
-                        "with expansion:\n" <<
-                        "  " << result.getExpandedExpression() << "\n";
-                }
-
-                if( currentTestCaseInfo->okToFail() ) {
-                    msg << "- failure ignore as test marked as 'ok to fail'\n";
-                    stream << "##teamcity[testIgnored"
-                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
-                           << " message='" << escape( msg.str() ) << "'"
-                           << "]\n";
-                }
-                else {
-                    stream << "##teamcity[testFailed"
-                           << " name='" << escape( currentTestCaseInfo->name )<< "'"
-                           << " message='" << escape( msg.str() ) << "'"
-                           << "]\n";
-                }
-            }
-            stream.flush();
-            return true;
-        }
-
-        void sectionStarting( SectionInfo const& sectionInfo ) override {
-            m_headerPrintedForThisSection = false;
-            StreamingReporterBase::sectionStarting( sectionInfo );
-        }
-
-        void testCaseStarting( TestCaseInfo const& testInfo ) override {
-            m_testTimer.start();
-            StreamingReporterBase::testCaseStarting( testInfo );
-            stream << "##teamcity[testStarted name='"
-                << escape( testInfo.name ) << "']\n";
-            stream.flush();
-        }
-
-        void testCaseEnded( TestCaseStats const& testCaseStats ) override {
-            StreamingReporterBase::testCaseEnded( testCaseStats );
-            if( !testCaseStats.stdOut.empty() )
-                stream << "##teamcity[testStdOut name='"
-                    << escape( testCaseStats.testInfo.name )
-                    << "' out='" << escape( testCaseStats.stdOut ) << "']\n";
-            if( !testCaseStats.stdErr.empty() )
-                stream << "##teamcity[testStdErr name='"
-                    << escape( testCaseStats.testInfo.name )
-                    << "' out='" << escape( testCaseStats.stdErr ) << "']\n";
-            stream << "##teamcity[testFinished name='"
-                    << escape( testCaseStats.testInfo.name ) << "' duration='"
-                    << m_testTimer.getElapsedMilliseconds() << "']\n";
-            stream.flush();
-        }
-
-    private:
-        void printSectionHeader( std::ostream& os ) {
-            assert( !m_sectionStack.empty() );
-
-            if( m_sectionStack.size() > 1 ) {
-                os << getLineOfChars<'-'>() << "\n";
-
-                std::vector<SectionInfo>::const_iterator
-                it = m_sectionStack.begin()+1, // Skip first section (test case)
-                itEnd = m_sectionStack.end();
-                for( ; it != itEnd; ++it )
-                    printHeaderString( os, it->name );
-                os << getLineOfChars<'-'>() << "\n";
-            }
-
-            SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
-
-            os << lineInfo << "\n";
-            os << getLineOfChars<'.'>() << "\n\n";
-        }
-
-        // if string has a : in first line will set indent to follow it on
-        // subsequent lines
-        static void printHeaderString( std::ostream& os, std::string const& _string, std::size_t indent = 0 ) {
-            std::size_t i = _string.find( ": " );
-            if( i != std::string::npos )
-                i+=2;
-            else
-                i = 0;
-            os << Column( _string )
-                           .indent( indent+i)
-                           .initialIndent( indent ) << "\n";
-        }
-    private:
-        bool m_headerPrintedForThisSection = false;
-        Timer m_testTimer;
-    };
-
-#ifdef CATCH_IMPL
-    TeamCityReporter::~TeamCityReporter() {}
-#endif
-
-    CATCH_REGISTER_REPORTER( "teamcity", TeamCityReporter )
-
-} // end namespace Catch
-
-#ifdef __clang__
-#   pragma clang diagnostic pop
-#endif
-
-#endif // TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED

src/CMakeLists.txt

@@ -3,6 +3,7 @@ include(MiscFunctions)
 # Please keep these ordered alphabetically
 set(BENCHMARK_HEADERS
     ${SOURCES_DIR}/benchmark/catch_benchmark.hpp
+    ${SOURCES_DIR}/benchmark/catch_benchmark_all.hpp
     ${SOURCES_DIR}/benchmark/catch_chronometer.hpp
     ${SOURCES_DIR}/benchmark/catch_clock.hpp
     ${SOURCES_DIR}/benchmark/catch_constructor.hpp
@@ -23,198 +24,206 @@ set(BENCHMARK_HEADERS
     ${SOURCES_DIR}/benchmark/detail/catch_timing.hpp
 )
 set(BENCHMARK_SOURCES
+    ${SOURCES_DIR}/benchmark/internal/catch_benchmark_combined_tu.cpp
     ${SOURCES_DIR}/benchmark/detail/catch_stats.cpp
 )
 
 SOURCE_GROUP("benchmark" FILES ${BENCHMARK_HEADERS} ${BENCHMARK_SOURCES})
 
 set(INTERNAL_HEADERS
-    ${SOURCES_DIR}/catch.hpp
-    ${SOURCES_DIR}/catch_approx.h
-    ${SOURCES_DIR}/catch_assertionhandler.h
-    ${SOURCES_DIR}/catch_assertioninfo.h
-    ${SOURCES_DIR}/catch_assertionresult.h
-    ${SOURCES_DIR}/catch_capture.hpp
-    ${SOURCES_DIR}/catch_capture_matchers.h
-    ${SOURCES_DIR}/catch_clara.h
-    ${SOURCES_DIR}/catch_commandline.h
-    ${SOURCES_DIR}/catch_common.h
-    ${SOURCES_DIR}/catch_compiler_capabilities.h
+    ${SOURCES_DIR}/catch_all.hpp
+    ${SOURCES_DIR}/matchers/catch_matchers_all.hpp
+    ${SOURCES_DIR}/generators/catch_generators_all.hpp
+    ${SOURCES_DIR}/interfaces/catch_interfaces_all.hpp
+    ${SOURCES_DIR}/matchers/internal/catch_matchers_impl.hpp
+    ${SOURCES_DIR}/internal/catch_console_width.hpp
+    ${SOURCES_DIR}/internal/catch_container_nonmembers.hpp
+    ${SOURCES_DIR}/internal/catch_noncopyable.hpp
+    ${SOURCES_DIR}/catch_approx.hpp
+    ${SOURCES_DIR}/internal/catch_assertion_handler.hpp
+    ${SOURCES_DIR}/catch_assertion_info.hpp
+    ${SOURCES_DIR}/catch_assertion_result.hpp
+    ${SOURCES_DIR}/internal/catch_test_macro_impl.hpp
+    ${SOURCES_DIR}/internal/catch_case_sensitive.hpp
+    ${SOURCES_DIR}/internal/catch_clara.hpp
+    ${SOURCES_DIR}/internal/catch_commandline.hpp
+    ${SOURCES_DIR}/internal/catch_common.hpp
+    ${SOURCES_DIR}/internal/catch_compiler_capabilities.hpp
     ${SOURCES_DIR}/catch_config.hpp
-    ${SOURCES_DIR}/catch_console_colour.h
-    ${SOURCES_DIR}/catch_context.h
-    ${SOURCES_DIR}/catch_debug_console.h
-    ${SOURCES_DIR}/catch_debugger.h
-    ${SOURCES_DIR}/catch_decomposer.h
-    ${SOURCES_DIR}/catch_default_main.hpp
-    ${SOURCES_DIR}/catch_enforce.h
-    ${SOURCES_DIR}/catch_enum_values_registry.h
-    ${SOURCES_DIR}/catch_errno_guard.h
-    ${SOURCES_DIR}/catch_exception_translator_registry.h
-    ${SOURCES_DIR}/catch_external_interfaces.h
-    ${SOURCES_DIR}/catch_fatal_condition.h
-    ${SOURCES_DIR}/catch_generators.hpp
-    ${SOURCES_DIR}/catch_generators_generic.hpp
-    ${SOURCES_DIR}/catch_generators_specific.hpp
-    ${SOURCES_DIR}/catch_impl.hpp
-    ${SOURCES_DIR}/catch_interfaces_capture.h
-    ${SOURCES_DIR}/catch_interfaces_config.h
-    ${SOURCES_DIR}/catch_interfaces_enum_values_registry.h
-    ${SOURCES_DIR}/catch_interfaces_exception.h
-    ${SOURCES_DIR}/catch_interfaces_registry_hub.h
-    ${SOURCES_DIR}/catch_interfaces_reporter.h
-    ${SOURCES_DIR}/catch_interfaces_runner.h
-    ${SOURCES_DIR}/catch_interfaces_tag_alias_registry.h
-    ${SOURCES_DIR}/catch_interfaces_testcase.h
-    ${SOURCES_DIR}/catch_leak_detector.h
-    ${SOURCES_DIR}/catch_list.h
-    ${SOURCES_DIR}/catch_matchers.h
-    ${SOURCES_DIR}/catch_matchers_exception.hpp
-    ${SOURCES_DIR}/catch_matchers_floating.h
-    ${SOURCES_DIR}/catch_matchers_generic.hpp
-    ${SOURCES_DIR}/catch_matchers_string.h
-    ${SOURCES_DIR}/catch_matchers_vector.h
-    ${SOURCES_DIR}/catch_message.h
-    ${SOURCES_DIR}/catch_meta.hpp
-    ${SOURCES_DIR}/catch_objc.hpp
-    ${SOURCES_DIR}/catch_objc_arc.hpp
-    ${SOURCES_DIR}/catch_option.hpp
-    ${SOURCES_DIR}/catch_output_redirect.h
-    ${SOURCES_DIR}/catch_platform.h
-    ${SOURCES_DIR}/catch_polyfills.hpp
-    ${SOURCES_DIR}/catch_preprocessor.hpp
-    ${SOURCES_DIR}/catch_random_number_generator.h
-    ${SOURCES_DIR}/catch_reenable_warnings.h
+    ${SOURCES_DIR}/internal/catch_config_uncaught_exceptions.hpp
+    ${SOURCES_DIR}/internal/catch_console_colour.hpp
+    ${SOURCES_DIR}/internal/catch_context.hpp
+    ${SOURCES_DIR}/internal/catch_debug_console.hpp
+    ${SOURCES_DIR}/internal/catch_debugger.hpp
+    ${SOURCES_DIR}/internal/catch_decomposer.hpp
+    ${SOURCES_DIR}/internal/catch_enforce.hpp
+    ${SOURCES_DIR}/internal/catch_enum_values_registry.hpp
+    ${SOURCES_DIR}/internal/catch_errno_guard.hpp
+    ${SOURCES_DIR}/internal/catch_exception_translator_registry.hpp
+    ${SOURCES_DIR}/internal/catch_fatal_condition_handler.hpp
+    ${SOURCES_DIR}/generators/catch_generator_exception.hpp
+    ${SOURCES_DIR}/generators/catch_generators.hpp
+    ${SOURCES_DIR}/generators/catch_generators_adapters.hpp
+    ${SOURCES_DIR}/generators/catch_generators_random.hpp
+    ${SOURCES_DIR}/generators/catch_generators_range.hpp
+    ${SOURCES_DIR}/interfaces/catch_interfaces_capture.hpp
+    ${SOURCES_DIR}/interfaces/catch_interfaces_config.hpp
+    ${SOURCES_DIR}/interfaces/catch_interfaces_enum_values_registry.hpp
+    ${SOURCES_DIR}/interfaces/catch_interfaces_exception.hpp
+    ${SOURCES_DIR}/interfaces/catch_interfaces_generatortracker.hpp
+    ${SOURCES_DIR}/interfaces/catch_interfaces_registry_hub.hpp
+    ${SOURCES_DIR}/interfaces/catch_interfaces_reporter.hpp
+    ${SOURCES_DIR}/interfaces/catch_interfaces_reporter_factory.hpp
+    ${SOURCES_DIR}/interfaces/catch_interfaces_reporter_registry.hpp
+    ${SOURCES_DIR}/interfaces/catch_interfaces_runner.hpp
+    ${SOURCES_DIR}/interfaces/catch_interfaces_tag_alias_registry.hpp
+    ${SOURCES_DIR}/interfaces/catch_interfaces_testcase.hpp
+    ${SOURCES_DIR}/internal/catch_lazy_expr.hpp
+    ${SOURCES_DIR}/internal/catch_leak_detector.hpp
+    ${SOURCES_DIR}/internal/catch_list.hpp
+    ${SOURCES_DIR}/matchers/catch_matchers.hpp
+    ${SOURCES_DIR}/matchers/catch_matchers_container_properties.hpp
+    ${SOURCES_DIR}/matchers/catch_matchers_contains.hpp
+    ${SOURCES_DIR}/matchers/catch_matchers_exception.hpp
+    ${SOURCES_DIR}/matchers/catch_matchers_floating.hpp
+    ${SOURCES_DIR}/matchers/catch_matchers_predicate.hpp
+    ${SOURCES_DIR}/matchers/catch_matchers_string.hpp
+    ${SOURCES_DIR}/matchers/catch_matchers_templated.hpp
+    ${SOURCES_DIR}/matchers/catch_matchers_vector.hpp
+    ${SOURCES_DIR}/catch_message.hpp
+    ${SOURCES_DIR}/internal/catch_message_info.hpp
+    ${SOURCES_DIR}/internal/catch_meta.hpp
+    ${SOURCES_DIR}/internal/catch_option.hpp
+    ${SOURCES_DIR}/internal/catch_output_redirect.hpp
+    ${SOURCES_DIR}/internal/catch_platform.hpp
+    ${SOURCES_DIR}/internal/catch_polyfills.hpp
+    ${SOURCES_DIR}/internal/catch_preprocessor.hpp
+    ${SOURCES_DIR}/internal/catch_random_number_generator.hpp
     ${SOURCES_DIR}/catch_reporter_registrars.hpp
-    ${SOURCES_DIR}/catch_reporter_registry.h
-    ${SOURCES_DIR}/catch_result_type.h
-    ${SOURCES_DIR}/catch_run_context.h
-    ${SOURCES_DIR}/catch_section.h
-    ${SOURCES_DIR}/catch_section_info.h
-    ${SOURCES_DIR}/catch_session.h
-    ${SOURCES_DIR}/catch_singletons.hpp
-    ${SOURCES_DIR}/catch_startup_exception_registry.h
-    ${SOURCES_DIR}/catch_stream.h
-    ${SOURCES_DIR}/catch_stringref.h
-    ${SOURCES_DIR}/catch_string_manip.h
-    ${SOURCES_DIR}/catch_suppress_warnings.h
-    ${SOURCES_DIR}/catch_tag_alias.h
-    ${SOURCES_DIR}/catch_tag_alias_autoregistrar.h
-    ${SOURCES_DIR}/catch_tag_alias_registry.h
-    ${SOURCES_DIR}/catch_test_case_info.h
-    ${SOURCES_DIR}/catch_test_case_registry_impl.h
-    ${SOURCES_DIR}/catch_test_case_tracker.h
-    ${SOURCES_DIR}/catch_test_registry.h
-    ${SOURCES_DIR}/catch_test_spec.h
-    ${SOURCES_DIR}/catch_test_spec_parser.h
-    ${SOURCES_DIR}/catch_text.h
-    ${SOURCES_DIR}/catch_timer.h
-    ${SOURCES_DIR}/catch_to_string.hpp
-    ${SOURCES_DIR}/catch_tostring.h
-    ${SOURCES_DIR}/catch_totals.h
-    ${SOURCES_DIR}/catch_uncaught_exceptions.h
-    ${SOURCES_DIR}/catch_user_interfaces.h
-    ${SOURCES_DIR}/catch_version.h
-    ${SOURCES_DIR}/catch_wildcard_pattern.h
-    ${SOURCES_DIR}/catch_windows_h_proxy.h
-    ${SOURCES_DIR}/catch_xmlwriter.h
+    ${SOURCES_DIR}/internal/catch_reporter_registry.hpp
+    ${SOURCES_DIR}/internal/catch_result_type.hpp
+    ${SOURCES_DIR}/internal/catch_run_context.hpp
+    ${SOURCES_DIR}/internal/catch_section.hpp
+    ${SOURCES_DIR}/catch_section_info.hpp
+    ${SOURCES_DIR}/catch_session.hpp
+    ${SOURCES_DIR}/internal/catch_singletons.hpp
+    ${SOURCES_DIR}/internal/catch_startup_exception_registry.hpp
+    ${SOURCES_DIR}/internal/catch_stream.hpp
+    ${SOURCES_DIR}/internal/catch_string_manip.hpp
+    ${SOURCES_DIR}/internal/catch_stringref.hpp
+    ${SOURCES_DIR}/catch_tag_alias.hpp
+    ${SOURCES_DIR}/catch_tag_alias_autoregistrar.hpp
+    ${SOURCES_DIR}/internal/catch_tag_alias_registry.hpp
+    ${SOURCES_DIR}/catch_test_case_info.hpp
+    ${SOURCES_DIR}/internal/catch_test_case_registry_impl.hpp
+    ${SOURCES_DIR}/internal/catch_test_case_tracker.hpp
+    ${SOURCES_DIR}/catch_template_test_macros.hpp
+    ${SOURCES_DIR}/catch_test_macros.hpp
+    ${SOURCES_DIR}/internal/catch_template_test_registry.hpp
+    ${SOURCES_DIR}/internal/catch_test_registry.hpp
+    ${SOURCES_DIR}/catch_test_spec.hpp
+    ${SOURCES_DIR}/internal/catch_test_spec_parser.hpp
+    ${SOURCES_DIR}/internal/catch_textflow.hpp
+    ${SOURCES_DIR}/catch_timer.hpp
+    ${SOURCES_DIR}/internal/catch_to_string.hpp
+    ${SOURCES_DIR}/catch_tostring.hpp
+    ${SOURCES_DIR}/catch_totals.hpp
+    ${SOURCES_DIR}/catch_translate_exception.hpp
+    ${SOURCES_DIR}/internal/catch_uncaught_exceptions.hpp
+    ${SOURCES_DIR}/internal/catch_unique_ptr.hpp
+    ${SOURCES_DIR}/catch_version.hpp
+    ${SOURCES_DIR}/catch_version_macros.hpp
+    ${SOURCES_DIR}/internal/catch_wildcard_pattern.hpp
+    ${SOURCES_DIR}/internal/catch_windows_h_proxy.hpp
+    ${SOURCES_DIR}/internal/catch_xmlwriter.hpp
 )
 set(IMPL_SOURCES
     ${SOURCES_DIR}/catch_approx.cpp
-    ${SOURCES_DIR}/catch_assertionhandler.cpp
-    ${SOURCES_DIR}/catch_assertionresult.cpp
-    ${SOURCES_DIR}/catch_capture_matchers.cpp
-    ${SOURCES_DIR}/catch_commandline.cpp
-    ${SOURCES_DIR}/catch_common.cpp
+    ${SOURCES_DIR}/internal/catch_assertion_handler.cpp
+    ${SOURCES_DIR}/catch_assertion_result.cpp
+    ${SOURCES_DIR}/matchers/internal/catch_matchers_combined_tu.cpp
+    ${SOURCES_DIR}/internal/catch_clara.cpp
+    ${SOURCES_DIR}/internal/catch_commandline.cpp
+    ${SOURCES_DIR}/internal/catch_common.cpp
     ${SOURCES_DIR}/catch_config.cpp
-    ${SOURCES_DIR}/catch_console_colour.cpp
-    ${SOURCES_DIR}/catch_context.cpp
-    ${SOURCES_DIR}/catch_debug_console.cpp
-    ${SOURCES_DIR}/catch_debugger.cpp
-    ${SOURCES_DIR}/catch_decomposer.cpp
-    ${SOURCES_DIR}/catch_enforce.cpp
-    ${SOURCES_DIR}/catch_enum_values_registry.cpp
-    ${SOURCES_DIR}/catch_errno_guard.cpp
-    ${SOURCES_DIR}/catch_exception_translator_registry.cpp
-    ${SOURCES_DIR}/catch_fatal_condition.cpp
-    ${SOURCES_DIR}/catch_generators.cpp
-    ${SOURCES_DIR}/catch_interfaces_capture.cpp
-    ${SOURCES_DIR}/catch_interfaces_config.cpp
-    ${SOURCES_DIR}/catch_interfaces_exception.cpp
-    ${SOURCES_DIR}/catch_interfaces_generatortracker.h
-    ${SOURCES_DIR}/catch_interfaces_registry_hub.cpp
-    ${SOURCES_DIR}/catch_interfaces_runner.cpp
-    ${SOURCES_DIR}/catch_interfaces_testcase.cpp
-    ${SOURCES_DIR}/catch_list.cpp
-    ${SOURCES_DIR}/catch_leak_detector.cpp
-    ${SOURCES_DIR}/catch_matchers.cpp
-    ${SOURCES_DIR}/catch_matchers_exception.cpp
-    ${SOURCES_DIR}/catch_matchers_floating.cpp
-    ${SOURCES_DIR}/catch_matchers_generic.cpp
-    ${SOURCES_DIR}/catch_matchers_string.cpp
+    ${SOURCES_DIR}/internal/catch_console_colour.cpp
+    ${SOURCES_DIR}/internal/catch_context.cpp
+    ${SOURCES_DIR}/internal/catch_debug_console.cpp
+    ${SOURCES_DIR}/internal/catch_debugger.cpp
+    ${SOURCES_DIR}/internal/catch_enforce.cpp
+    ${SOURCES_DIR}/internal/catch_enum_values_registry.cpp
+    ${SOURCES_DIR}/internal/catch_exception_translator_registry.cpp
+    ${SOURCES_DIR}/internal/catch_fatal_condition_handler.cpp
+    ${SOURCES_DIR}/generators/internal/catch_generators_combined_tu.cpp
+    ${SOURCES_DIR}/interfaces/catch_interfaces_combined_tu.cpp
+    ${SOURCES_DIR}/interfaces/catch_interfaces_reporter.cpp
+    ${SOURCES_DIR}/internal/catch_list.cpp
+    ${SOURCES_DIR}/matchers/catch_matchers_floating.cpp
+    ${SOURCES_DIR}/matchers/catch_matchers_string.cpp
+    ${SOURCES_DIR}/matchers/catch_matchers_templated.cpp
     ${SOURCES_DIR}/catch_message.cpp
-    ${SOURCES_DIR}/catch_output_redirect.cpp
+    ${SOURCES_DIR}/internal/catch_output_redirect.cpp
     ${SOURCES_DIR}/catch_registry_hub.cpp
-    ${SOURCES_DIR}/catch_interfaces_reporter.cpp
-    ${SOURCES_DIR}/catch_polyfills.cpp
-    ${SOURCES_DIR}/catch_random_number_generator.cpp
-    ${SOURCES_DIR}/catch_reporter_registry.cpp
-    ${SOURCES_DIR}/catch_result_type.cpp
-    ${SOURCES_DIR}/catch_run_context.cpp
-    ${SOURCES_DIR}/catch_section.cpp
+    ${SOURCES_DIR}/internal/catch_combined_tu.cpp
+    ${SOURCES_DIR}/internal/catch_random_number_generator.cpp
+    ${SOURCES_DIR}/internal/catch_reporter_registry.cpp
+    ${SOURCES_DIR}/internal/catch_result_type.cpp
+    ${SOURCES_DIR}/internal/catch_run_context.cpp
+    ${SOURCES_DIR}/internal/catch_section.cpp
     ${SOURCES_DIR}/catch_session.cpp
-    ${SOURCES_DIR}/catch_singletons.cpp
-    ${SOURCES_DIR}/catch_startup_exception_registry.cpp
-    ${SOURCES_DIR}/catch_stream.cpp
-    ${SOURCES_DIR}/catch_stringref.cpp
-    ${SOURCES_DIR}/catch_string_manip.cpp
-    ${SOURCES_DIR}/catch_tag_alias.cpp
-    ${SOURCES_DIR}/catch_tag_alias_autoregistrar.cpp
-    ${SOURCES_DIR}/catch_tag_alias_registry.cpp
+    ${SOURCES_DIR}/internal/catch_singletons.cpp
+    ${SOURCES_DIR}/internal/catch_stream.cpp
+    ${SOURCES_DIR}/internal/catch_stringref.cpp
+    ${SOURCES_DIR}/internal/catch_string_manip.cpp
+    ${SOURCES_DIR}/internal/catch_tag_alias_registry.cpp
     ${SOURCES_DIR}/catch_test_case_info.cpp
-    ${SOURCES_DIR}/catch_test_case_registry_impl.cpp
-    ${SOURCES_DIR}/catch_test_case_tracker.cpp
-    ${SOURCES_DIR}/catch_test_registry.cpp
+    ${SOURCES_DIR}/internal/catch_test_case_registry_impl.cpp
+    ${SOURCES_DIR}/internal/catch_test_case_tracker.cpp
+    ${SOURCES_DIR}/internal/catch_test_registry.cpp
+    ${SOURCES_DIR}/internal/catch_textflow.cpp
     ${SOURCES_DIR}/catch_test_spec.cpp
-    ${SOURCES_DIR}/catch_test_spec_parser.cpp
+    ${SOURCES_DIR}/internal/catch_test_spec_parser.cpp
     ${SOURCES_DIR}/catch_timer.cpp
     ${SOURCES_DIR}/catch_tostring.cpp
     ${SOURCES_DIR}/catch_totals.cpp
-    ${SOURCES_DIR}/catch_uncaught_exceptions.cpp
     ${SOURCES_DIR}/catch_version.cpp
-    ${SOURCES_DIR}/catch_wildcard_pattern.cpp
-    ${SOURCES_DIR}/catch_xmlwriter.cpp
+    ${SOURCES_DIR}/internal/catch_wildcard_pattern.cpp
+    ${SOURCES_DIR}/internal/catch_xmlwriter.cpp
 )
 set(INTERNAL_FILES ${IMPL_SOURCES} ${INTERNAL_HEADERS})
-CheckFileList(INTERNAL_FILES ${SOURCES_DIR}/internal)
 
 # Please keep these ordered alphabetically
 set(REPORTER_HEADERS
+    ${SOURCES_DIR}/reporters/catch_reporters_all.hpp
     ${SOURCES_DIR}/reporters/catch_reporter_automake.hpp
-    ${SOURCES_DIR}/reporters/catch_reporter_bases.hpp
-    ${SOURCES_DIR}/reporters/catch_reporter_compact.h
-    ${SOURCES_DIR}/reporters/catch_reporter_console.h
-    ${SOURCES_DIR}/reporters/catch_reporter_junit.h
-    ${SOURCES_DIR}/reporters/catch_reporter_listening.h
+    ${SOURCES_DIR}/reporters/catch_reporter_compact.hpp
+    ${SOURCES_DIR}/reporters/catch_reporter_console.hpp
+    ${SOURCES_DIR}/reporters/catch_reporter_cumulative_base.hpp
+    ${SOURCES_DIR}/reporters/catch_reporter_event_listener.hpp
+    ${SOURCES_DIR}/reporters/catch_reporter_helpers.hpp
+    ${SOURCES_DIR}/reporters/catch_reporter_junit.hpp
+    ${SOURCES_DIR}/reporters/catch_reporter_listening.hpp
     ${SOURCES_DIR}/reporters/catch_reporter_sonarqube.hpp
+    ${SOURCES_DIR}/reporters/catch_reporter_streaming_base.hpp
     ${SOURCES_DIR}/reporters/catch_reporter_tap.hpp
     ${SOURCES_DIR}/reporters/catch_reporter_teamcity.hpp
-    ${SOURCES_DIR}/reporters/catch_reporter_xml.h
+    ${SOURCES_DIR}/reporters/catch_reporter_xml.hpp
 )
 set(REPORTER_SOURCES
     ${SOURCES_DIR}/reporters/catch_reporter_automake.cpp
-    ${SOURCES_DIR}/reporters/catch_reporter_bases.cpp
+    ${SOURCES_DIR}/reporters/catch_reporter_combined_tu.cpp
     ${SOURCES_DIR}/reporters/catch_reporter_compact.cpp
     ${SOURCES_DIR}/reporters/catch_reporter_console.cpp
+    ${SOURCES_DIR}/reporters/catch_reporter_cumulative_base.cpp
     ${SOURCES_DIR}/reporters/catch_reporter_junit.cpp
     ${SOURCES_DIR}/reporters/catch_reporter_listening.cpp
     ${SOURCES_DIR}/reporters/catch_reporter_sonarqube.cpp
+    ${SOURCES_DIR}/reporters/catch_reporter_streaming_base.cpp
     ${SOURCES_DIR}/reporters/catch_reporter_tap.cpp
     ${SOURCES_DIR}/reporters/catch_reporter_teamcity.cpp
     ${SOURCES_DIR}/reporters/catch_reporter_xml.cpp
 )
 set(REPORTER_FILES ${REPORTER_HEADERS} ${REPORTER_SOURCES})
-CheckFileList(REPORTER_FILES ${SOURCES_DIR}/reporters)
 
 # Fixme: STATIC because for dynamic, we would need to handle visibility
 # and I don't want to do the annotations right now
@@ -262,20 +271,22 @@ target_include_directories(Catch2
 )
 
 
-add_library(Catch2Main STATIC
-    ${SOURCES_DIR}/catch_main.cpp
+add_library(Catch2WithMain STATIC
+    ${SOURCES_DIR}/internal/catch_main.cpp
+)
+add_library(Catch2::Catch2WithMain ALIAS Catch2WithMain)
+target_link_libraries(Catch2WithMain PUBLIC Catch2)
+set_target_properties(Catch2WithMain
+  PROPERTIES
+    OUTPUT_NAME "Catch2Main"
 )
-add_library(Catch2::Catch2Main ALIAS Catch2Main)
-target_link_libraries(Catch2Main PUBLIC Catch2)
-
-
 
 if (NOT_SUBPROJECT)
     # create and install an export set for catch target as Catch2::Catch
     install(
       TARGETS
         Catch2
-        Catch2Main
+        Catch2WithMain
       EXPORT
         Catch2Targets
       DESTINATION
@@ -305,10 +316,38 @@ if (CATCH_BUILD_EXAMPLES OR CATCH_BUILD_EXTRA_TESTS)
       ${INTERNAL_FILES}
       ${BENCHMARK_HEADERS}
       ${BENCHMARK_SOURCES}
+      # Also include main entry point
+      ${SOURCES_DIR}/internal/catch_main.cpp
     )
     target_include_directories(Catch2_buildall_interface
       INTERFACE
         $<BUILD_INTERFACE:${SOURCES_DIR}/..>
         $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
     )
+    target_compile_features(Catch2_buildall_interface
+      INTERFACE
+        cxx_alignas
+        cxx_alignof
+        cxx_attributes
+        cxx_auto_type
+        cxx_constexpr
+        cxx_defaulted_functions
+        cxx_deleted_functions
+        cxx_final
+        cxx_lambdas
+        cxx_noexcept
+        cxx_override
+        cxx_range_for
+        cxx_rvalue_references
+        cxx_static_assert
+        cxx_strong_enums
+        cxx_trailing_return_types
+        cxx_unicode_literals
+        cxx_user_literals
+        cxx_variable_templates
+        cxx_variadic_macros
+    )
 endif()
+
+list(APPEND CATCH_WARNING_TARGETS Catch2 Catch2WithMain)
+set(CATCH_WARNING_TARGETS ${CATCH_WARNING_TARGETS} PARENT_SCOPE)

src/catch2/benchmark/catch_benchmark.hpp

@@ -1,19 +1,18 @@
-/*
- *  Created by Joachim on 16/04/2019.
- *  Adapted from donated nonius code.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
- // Benchmark
-#ifndef TWOBLUECUBES_CATCH_BENCHMARK_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_BENCHMARK_HPP_INCLUDED
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
 
-#include <catch2/catch_config.hpp>
-#include <catch2/catch_context.h>
-#include <catch2/catch_interfaces_reporter.h>
-#include <catch2/catch_test_registry.h>
+// SPDX-License-Identifier: BSL-1.0
+// Adapted from donated nonius code.
+
+#ifndef CATCH_BENCHMARK_HPP_INCLUDED
+#define CATCH_BENCHMARK_HPP_INCLUDED
+
+#include <catch2/interfaces/catch_interfaces_config.hpp>
+#include <catch2/internal/catch_context.hpp>
+#include <catch2/interfaces/catch_interfaces_reporter.hpp>
 
 #include <catch2/benchmark/catch_chronometer.hpp>
 #include <catch2/benchmark/catch_clock.hpp>
@@ -34,25 +33,25 @@
 namespace Catch {
     namespace Benchmark {
         struct Benchmark {
-            Benchmark(std::string &&name)
-                : name(std::move(name)) {}
+            Benchmark(std::string&& benchmarkName)
+                : name(std::move(benchmarkName)) {}
 
             template <class FUN>
-            Benchmark(std::string &&name, FUN &&func)
-                : fun(std::move(func)), name(std::move(name)) {}
+            Benchmark(std::string&& benchmarkName , FUN &&func)
+                : fun(std::move(func)), name(std::move(benchmarkName)) {}
 
             template <typename Clock>
             ExecutionPlan<FloatDuration<Clock>> prepare(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
                 auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
-                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(Detail::warmup_time));
+                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
                 auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(run_time), 1, fun);
                 int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
-                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FloatDuration<Clock>>(Detail::warmup_time), Detail::warmup_iterations };
+                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FloatDuration<Clock>>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
             }
 
             template <typename Clock = default_clock>
             void run() {
-                IConfigPtr cfg = getCurrentContext().getConfig();
+                auto const* cfg = getCurrentContext().getConfig();
 
                 auto env = Detail::measure_environment<Clock>();
 
@@ -79,7 +78,7 @@ namespace Catch {
                     });
 
                     auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
-                    BenchmarkStats<std::chrono::duration<double, std::nano>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
+                    BenchmarkStats<FloatDuration<Clock>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
                     getResultCapture().benchmarkEnded(stats);
 
                 } CATCH_CATCH_ALL{
@@ -119,4 +118,20 @@ namespace Catch {
     if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
         BenchmarkName = [&]
 
-#endif // TWOBLUECUBES_CATCH_BENCHMARK_HPP_INCLUDED
+#if defined(CATCH_CONFIG_PREFIX_ALL)
+
+#define CATCH_BENCHMARK(...) \
+    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define CATCH_BENCHMARK_ADVANCED(name) \
+    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
+
+#else
+
+#define BENCHMARK(...) \
+    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define BENCHMARK_ADVANCED(name) \
+    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
+
+#endif
+
+#endif // CATCH_BENCHMARK_HPP_INCLUDED

src/catch2/benchmark/catch_benchmark_all.hpp

@@ -0,0 +1,44 @@
+
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+/** \file
+ * This is a convenience header for Catch2's benchmarking. It includes
+ * **all** of Catch2 headers related to benchmarking.
+ *
+ * Generally the Catch2 users should use specific includes they need,
+ * but this header can be used instead for ease-of-experimentation, or
+ * just plain convenience, at the cost of (significantly) increased
+ * compilation times.
+ *
+ * When a new header is added to either the `benchmark` folder, or to
+ * the corresponding internal (detail) subfolder, it should be added here.
+ */
+
+#ifndef CATCH_BENCHMARK_ALL_HPP_INCLUDED
+#define CATCH_BENCHMARK_ALL_HPP_INCLUDED
+
+#include <catch2/benchmark/catch_benchmark.hpp>
+#include <catch2/benchmark/catch_chronometer.hpp>
+#include <catch2/benchmark/catch_clock.hpp>
+#include <catch2/benchmark/catch_constructor.hpp>
+#include <catch2/benchmark/catch_environment.hpp>
+#include <catch2/benchmark/catch_estimate.hpp>
+#include <catch2/benchmark/catch_execution_plan.hpp>
+#include <catch2/benchmark/catch_optimizer.hpp>
+#include <catch2/benchmark/catch_outlier_classification.hpp>
+#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_complete_invoke.hpp>
+#include <catch2/benchmark/detail/catch_estimate_clock.hpp>
+#include <catch2/benchmark/detail/catch_measure.hpp>
+#include <catch2/benchmark/detail/catch_repeat.hpp>
+#include <catch2/benchmark/detail/catch_run_for_at_least.hpp>
+#include <catch2/benchmark/detail/catch_stats.hpp>
+#include <catch2/benchmark/detail/catch_timing.hpp>
+
+#endif // CATCH_BENCHMARK_ALL_HPP_INCLUDED

src/catch2/benchmark/catch_chronometer.hpp

@@ -1,20 +1,19 @@
-/*
- *  Created by Joachim on 16/04/2019.
- *  Adapted from donated nonius code.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
-// User-facing chronometer
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef TWOBLUECUBES_CATCH_CHRONOMETER_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_CHRONOMETER_HPP_INCLUDED
+// SPDX-License-Identifier: BSL-1.0
+// Adapted from donated nonius code.
+
+#ifndef CATCH_CHRONOMETER_HPP_INCLUDED
+#define CATCH_CHRONOMETER_HPP_INCLUDED
 
 #include <catch2/benchmark/catch_clock.hpp>
 #include <catch2/benchmark/catch_optimizer.hpp>
 #include <catch2/benchmark/detail/catch_complete_invoke.hpp>
-#include <catch2/catch_meta.hpp>
+#include <catch2/internal/catch_meta.hpp>
 
 namespace Catch {
     namespace Benchmark {
@@ -22,7 +21,11 @@ namespace Catch {
             struct ChronometerConcept {
                 virtual void start() = 0;
                 virtual void finish() = 0;
-                virtual ~ChronometerConcept() = default;
+                virtual ~ChronometerConcept(); // = default;
+
+                ChronometerConcept() = default;
+                ChronometerConcept(ChronometerConcept const&) = default;
+                ChronometerConcept& operator=(ChronometerConcept const&) = default;
             };
             template <typename Clock>
             struct ChronometerModel final : public ChronometerConcept {
@@ -41,11 +44,11 @@ namespace Catch {
             template <typename Fun>
             void measure(Fun&& fun) { measure(std::forward<Fun>(fun), is_callable<Fun(int)>()); }
 
-            int runs() const { return k; }
+            int runs() const { return repeats; }
 
-            Chronometer(Detail::ChronometerConcept& meter, int k)
+            Chronometer(Detail::ChronometerConcept& meter, int repeats_)
                 : impl(&meter)
-                , k(k) {}
+                , repeats(repeats_) {}
 
         private:
             template <typename Fun>
@@ -57,15 +60,15 @@ namespace Catch {
             void measure(Fun&& fun, std::true_type) {
                 Detail::optimizer_barrier();
                 impl->start();
-                for (int i = 0; i < k; ++i) invoke_deoptimized(fun, i);
+                for (int i = 0; i < repeats; ++i) invoke_deoptimized(fun, i);
                 impl->finish();
                 Detail::optimizer_barrier();
             }
 
             Detail::ChronometerConcept* impl;
-            int k;
+            int repeats;
         };
     } // namespace Benchmark
 } // namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_CHRONOMETER_HPP_INCLUDED
+#endif // CATCH_CHRONOMETER_HPP_INCLUDED

src/catch2/benchmark/catch_clock.hpp

@@ -1,15 +1,14 @@
-/*
- *  Created by Joachim on 16/04/2019.
- *  Adapted from donated nonius code.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
-// Clocks
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef TWOBLUECUBES_CATCH_CLOCK_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_CLOCK_HPP_INCLUDED
+// SPDX-License-Identifier: BSL-1.0
+// Adapted from donated nonius code.
+
+#ifndef CATCH_CLOCK_HPP_INCLUDED
+#define CATCH_CLOCK_HPP_INCLUDED
 
 #include <chrono>
 #include <ratio>
@@ -37,4 +36,4 @@ namespace Catch {
     } // namespace Benchmark
 } // namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_CLOCK_HPP_INCLUDED
+#endif // CATCH_CLOCK_HPP_INCLUDED

src/catch2/benchmark/catch_constructor.hpp

@@ -1,73 +1,78 @@
-/*
- *  Created by Joachim on 16/04/2019.
- *  Adapted from donated nonius code.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
-// Constructor and destructor helpers
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef TWOBLUECUBES_CATCH_CONSTRUCTOR_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_CONSTRUCTOR_HPP_INCLUDED
+// SPDX-License-Identifier: BSL-1.0
+// Adapted from donated nonius code.
+
+#ifndef CATCH_CONSTRUCTOR_HPP_INCLUDED
+#define CATCH_CONSTRUCTOR_HPP_INCLUDED
 
 #include <type_traits>
 
 namespace Catch {
-    namespace Detail {
-        template <typename T, bool Destruct>
-        struct ObjectStorage
-        {
-            using TStorage = typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type;
-
-            ObjectStorage() : data() {}
-
-            ObjectStorage(const ObjectStorage& other)
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T, bool Destruct>
+            struct ObjectStorage
             {
-                new(&data) T(other.stored_object());
-            }
+                using TStorage = typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type;
 
-            ObjectStorage(ObjectStorage&& other)
-            {
-                new(&data) T(std::move(other.stored_object()));
-            }
+                ObjectStorage() : data() {}
 
-            ~ObjectStorage() { destruct_on_exit<T>(); }
+                ObjectStorage(const ObjectStorage& other)
+                {
+                    new(&data) T(other.stored_object());
+                }
 
-            template <typename... Args>
-            void construct(Args&&... args)
-            {
-                new (&data) T(std::forward<Args>(args)...);
-            }
+                ObjectStorage(ObjectStorage&& other)
+                {
+                    new(&data) T(std::move(other.stored_object()));
+                }
 
-            template <bool AllowManualDestruction = !Destruct>
-            typename std::enable_if<AllowManualDestruction>::type destruct()
-            {
-                stored_object().~T();
-            }
+                ~ObjectStorage() { destruct_on_exit<T>(); }
 
-        private:
-            // If this is a constructor benchmark, destruct the underlying object
-            template <typename U>
-            void destruct_on_exit(typename std::enable_if<Destruct, U>::type* = 0) { destruct<true>(); }
-            // Otherwise, don't
-            template <typename U>
-            void destruct_on_exit(typename std::enable_if<!Destruct, U>::type* = 0) { }
+                template <typename... Args>
+                void construct(Args&&... args)
+                {
+                    new (&data) T(std::forward<Args>(args)...);
+                }
 
-            T& stored_object()
-            {
-                return *static_cast<T*>(static_cast<void*>(&data));
-            }
+                template <bool AllowManualDestruction = !Destruct>
+                typename std::enable_if<AllowManualDestruction>::type destruct()
+                {
+                    stored_object().~T();
+                }
 
-            TStorage data;
-        };
-    }
+            private:
+                // If this is a constructor benchmark, destruct the underlying object
+                template <typename U>
+                void destruct_on_exit(typename std::enable_if<Destruct, U>::type* = 0) { destruct<true>(); }
+                // Otherwise, don't
+                template <typename U>
+                void destruct_on_exit(typename std::enable_if<!Destruct, U>::type* = 0) { }
 
-    template <typename T>
-    using storage_for = Detail::ObjectStorage<T, true>;
+                T& stored_object() {
+                    return *static_cast<T*>(static_cast<void*>(&data));
+                }
 
-    template <typename T>
-    using destructable_object = Detail::ObjectStorage<T, false>;
-}
+                T const& stored_object() const {
+                    return *static_cast<T*>(static_cast<void*>(&data));
+                }
 
-#endif // TWOBLUECUBES_CATCH_CONSTRUCTOR_HPP_INCLUDED
+
+                TStorage data;
+            };
+        } // namespace Detail
+
+        template <typename T>
+        using storage_for = Detail::ObjectStorage<T, true>;
+
+        template <typename T>
+        using destructable_object = Detail::ObjectStorage<T, false>;
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_CONSTRUCTOR_HPP_INCLUDED

src/catch2/benchmark/catch_environment.hpp

@@ -1,15 +1,14 @@
-/*
- *  Created by Joachim on 16/04/2019.
- *  Adapted from donated nonius code.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
-// Environment information
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef TWOBLUECUBES_CATCH_ENVIRONMENT_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_ENVIRONMENT_HPP_INCLUDED
+// SPDX-License-Identifier: BSL-1.0
+// Adapted from donated nonius code.
+
+#ifndef CATCH_ENVIRONMENT_HPP_INCLUDED
+#define CATCH_ENVIRONMENT_HPP_INCLUDED
 
 #include <catch2/benchmark/catch_clock.hpp>
 #include <catch2/benchmark/catch_outlier_classification.hpp>
@@ -35,4 +34,4 @@ namespace Catch {
     } // namespace Benchmark
 } // namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_ENVIRONMENT_HPP_INCLUDED
+#endif // CATCH_ENVIRONMENT_HPP_INCLUDED

src/catch2/benchmark/catch_estimate.hpp

@@ -1,15 +1,14 @@
-/*
- *  Created by Joachim on 16/04/2019.
- *  Adapted from donated nonius code.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
- // Statistics estimates
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef TWOBLUECUBES_CATCH_ESTIMATE_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_ESTIMATE_HPP_INCLUDED
+// SPDX-License-Identifier: BSL-1.0
+// Adapted from donated nonius code.
+
+#ifndef CATCH_ESTIMATE_HPP_INCLUDED
+#define CATCH_ESTIMATE_HPP_INCLUDED
 
 namespace Catch {
     namespace Benchmark {
@@ -28,4 +27,4 @@ namespace Catch {
     } // namespace Benchmark
 } // namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_ESTIMATE_HPP_INCLUDED
+#endif // CATCH_ESTIMATE_HPP_INCLUDED

src/catch2/benchmark/catch_execution_plan.hpp

@@ -1,17 +1,16 @@
-/*
- *  Created by Joachim on 16/04/2019.
- *  Adapted from donated nonius code.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
- // Execution plan
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef TWOBLUECUBES_CATCH_EXECUTION_PLAN_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_EXECUTION_PLAN_HPP_INCLUDED
+// SPDX-License-Identifier: BSL-1.0
+// Adapted from donated nonius code.
 
-#include <catch2/catch_config.hpp>
+#ifndef CATCH_EXECUTION_PLAN_HPP_INCLUDED
+#define CATCH_EXECUTION_PLAN_HPP_INCLUDED
+
+#include <catch2/interfaces/catch_interfaces_config.hpp>
 #include <catch2/benchmark/catch_clock.hpp>
 #include <catch2/benchmark/catch_environment.hpp>
 #include <catch2/benchmark/detail/catch_benchmark_function.hpp>
@@ -55,4 +54,4 @@ namespace Catch {
     } // namespace Benchmark
 } // namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_EXECUTION_PLAN_HPP_INCLUDED
+#endif // CATCH_EXECUTION_PLAN_HPP_INCLUDED

src/catch2/benchmark/catch_optimizer.hpp

@@ -1,20 +1,22 @@
-/*
- *  Created by Joachim on 16/04/2019.
- *  Adapted from donated nonius code.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
- // Hinting the optimizer
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef TWOBLUECUBES_CATCH_OPTIMIZER_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_OPTIMIZER_HPP_INCLUDED
+// SPDX-License-Identifier: BSL-1.0
+// Adapted from donated nonius code.
+
+#ifndef CATCH_OPTIMIZER_HPP_INCLUDED
+#define CATCH_OPTIMIZER_HPP_INCLUDED
 
 #if defined(_MSC_VER)
 #   include <atomic> // atomic_thread_fence
 #endif
 
+#include <type_traits>
+#include <utility>
+
 namespace Catch {
     namespace Benchmark {
 #if defined(__GNUC__) || defined(__clang__)
@@ -65,4 +67,4 @@ namespace Catch {
     } // namespace Benchmark
 } // namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_OPTIMIZER_HPP_INCLUDED
+#endif // CATCH_OPTIMIZER_HPP_INCLUDED

src/catch2/benchmark/catch_outlier_classification.hpp

@@ -1,14 +1,14 @@
-/*
- *  Created by Joachim on 16/04/2019.
- *  Adapted from donated nonius code.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
-// Outlier information
-#ifndef TWOBLUECUBES_CATCH_OUTLIERS_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_OUTLIERS_HPP_INCLUDED
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+// Adapted from donated nonius code.
+
+#ifndef CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED
+#define CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED
 
 namespace Catch {
     namespace Benchmark {
@@ -26,4 +26,4 @@ namespace Catch {
     } // namespace Benchmark
 } // namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_OUTLIERS_HPP_INCLUDED
+#endif // CATCH_OUTLIERS_CLASSIFICATION_HPP_INCLUDED

src/catch2/benchmark/catch_sample_analysis.hpp

@@ -1,15 +1,14 @@
-/*
- *  Created by Joachim on 16/04/2019.
- *  Adapted from donated nonius code.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
-// Benchmark results
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef TWOBLUECUBES_CATCH_BENCHMARK_RESULTS_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_BENCHMARK_RESULTS_HPP_INCLUDED
+// SPDX-License-Identifier: BSL-1.0
+// Adapted from donated nonius code.
+
+#ifndef CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
+#define CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
 
 #include <catch2/benchmark/catch_clock.hpp>
 #include <catch2/benchmark/catch_estimate.hpp>
@@ -47,4 +46,4 @@ namespace Catch {
     } // namespace Benchmark
 } // namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_BENCHMARK_RESULTS_HPP_INCLUDED
+#endif // CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED

src/catch2/benchmark/detail/catch_analyse.hpp

@@ -1,15 +1,14 @@
-/*
- *  Created by Joachim on 16/04/2019.
- *  Adapted from donated nonius code.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
- // Run and analyse one benchmark
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef TWOBLUECUBES_CATCH_DETAIL_ANALYSE_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_DETAIL_ANALYSE_HPP_INCLUDED
+// SPDX-License-Identifier: BSL-1.0
+// Adapted from donated nonius code.
+
+#ifndef CATCH_ANALYSE_HPP_INCLUDED
+#define CATCH_ANALYSE_HPP_INCLUDED
 
 #include <catch2/benchmark/catch_clock.hpp>
 #include <catch2/benchmark/catch_sample_analysis.hpp>
@@ -75,4 +74,4 @@ namespace Catch {
     } // namespace Benchmark
 } // namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_DETAIL_ANALYSE_HPP_INCLUDED
+#endif // CATCH_ANALYSE_HPP_INCLUDED

src/catch2/benchmark/detail/catch_benchmark_function.hpp

@@ -1,24 +1,23 @@
-    /*
- *  Created by Joachim on 16/04/2019.
- *  Adapted from donated nonius code.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
- // Dumb std::function implementation for consistent call overhead
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef TWOBLUECUBES_CATCH_DETAIL_BENCHMARK_FUNCTION_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_DETAIL_BENCHMARK_FUNCTION_HPP_INCLUDED
+// SPDX-License-Identifier: BSL-1.0
+// Adapted from donated nonius code.
+
+#ifndef CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
+#define CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
 
 #include <catch2/benchmark/catch_chronometer.hpp>
 #include <catch2/benchmark/detail/catch_complete_invoke.hpp>
-#include <catch2/catch_meta.hpp>
+#include <catch2/internal/catch_meta.hpp>
+#include <catch2/internal/catch_unique_ptr.hpp>
 
 #include <cassert>
 #include <type_traits>
 #include <utility>
-#include <memory>
 
 namespace Catch {
     namespace Benchmark {
@@ -41,12 +40,16 @@ namespace Catch {
                 struct callable {
                     virtual void call(Chronometer meter) const = 0;
                     virtual callable* clone() const = 0;
-                    virtual ~callable() = default;
+                    virtual ~callable(); // = default;
+
+                    callable() = default;
+                    callable(callable const&) = default;
+                    callable& operator=(callable const&) = default;
                 };
                 template <typename Fun>
                 struct model : public callable {
-                    model(Fun&& fun) : fun(std::move(fun)) {}
-                    model(Fun const& fun) : fun(fun) {}
+                    model(Fun&& fun_) : fun(std::move(fun_)) {}
+                    model(Fun const& fun_) : fun(fun_) {}
 
                     model<Fun>* clone() const override { return new model<Fun>(*this); }
 
@@ -77,14 +80,15 @@ namespace Catch {
                     BenchmarkFunction(Fun&& fun)
                     : f(new model<typename std::decay<Fun>::type>(std::forward<Fun>(fun))) {}
 
-                BenchmarkFunction(BenchmarkFunction&& that)
-                    : f(std::move(that.f)) {}
+                BenchmarkFunction( BenchmarkFunction&& that ) noexcept:
+                    f( std::move( that.f ) ) {}
 
                 BenchmarkFunction(BenchmarkFunction const& that)
                     : f(that.f->clone()) {}
 
-                BenchmarkFunction& operator=(BenchmarkFunction&& that) {
-                    f = std::move(that.f);
+                BenchmarkFunction&
+                operator=( BenchmarkFunction&& that ) noexcept {
+                    f = std::move( that.f );
                     return *this;
                 }
 
@@ -96,10 +100,10 @@ namespace Catch {
                 void operator()(Chronometer meter) const { f->call(meter); }
 
             private:
-                std::unique_ptr<callable> f;
+                Catch::Detail::unique_ptr<callable> f;
             };
         } // namespace Detail
     } // namespace Benchmark
 } // namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_DETAIL_BENCHMARK_FUNCTION_HPP_INCLUDED
+#endif // CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED

src/catch2/benchmark/detail/catch_complete_invoke.hpp

@@ -1,17 +1,19 @@
-/*
- *  Created by Joachim on 16/04/2019.
- *  Adapted from donated nonius code.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
-// Invoke with a special case for void
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef TWOBLUECUBES_CATCH_DETAIL_COMPLETE_INVOKE_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_DETAIL_COMPLETE_INVOKE_HPP_INCLUDED
+// SPDX-License-Identifier: BSL-1.0
+// Adapted from donated nonius code.
 
-#include <catch2/catch_enforce.h>
+#ifndef CATCH_COMPLETE_INVOKE_HPP_INCLUDED
+#define CATCH_COMPLETE_INVOKE_HPP_INCLUDED
+
+#include <catch2/internal/catch_enforce.hpp>
+#include <catch2/internal/catch_meta.hpp>
+#include <catch2/interfaces/catch_interfaces_capture.hpp>
+#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
 
 #include <type_traits>
 #include <utility>
@@ -42,20 +44,18 @@ namespace Catch {
                     return {};
                 }
             };
-            template <typename Sig>
-            using ResultOf_t = typename std::result_of<Sig>::type;
 
             // invoke and not return void :(
             template <typename Fun, typename... Args>
-            CompleteType_t<ResultOf_t<Fun(Args...)>> complete_invoke(Fun&& fun, Args&&... args) {
-                return CompleteInvoker<ResultOf_t<Fun(Args...)>>::invoke(std::forward<Fun>(fun), std::forward<Args>(args)...);
+            CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(Fun&& fun, Args&&... args) {
+                return CompleteInvoker<FunctionReturnType<Fun, Args...>>::invoke(std::forward<Fun>(fun), std::forward<Args>(args)...);
             }
 
-            const std::string benchmarkErrorMsg = "a benchmark failed to run successfully";
+            extern const std::string benchmarkErrorMsg;
         } // namespace Detail
 
         template <typename Fun>
-        Detail::CompleteType_t<Detail::ResultOf_t<Fun()>> user_code(Fun&& fun) {
+        Detail::CompleteType_t<FunctionReturnType<Fun>> user_code(Fun&& fun) {
             CATCH_TRY{
                 return Detail::complete_invoke(std::forward<Fun>(fun));
             } CATCH_CATCH_ALL{
@@ -66,4 +66,4 @@ namespace Catch {
     } // namespace Benchmark
 } // namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_DETAIL_COMPLETE_INVOKE_HPP_INCLUDED
+#endif // CATCH_COMPLETE_INVOKE_HPP_INCLUDED

src/catch2/benchmark/detail/catch_estimate_clock.hpp

@@ -1,15 +1,14 @@
-/*
- *  Created by Joachim on 16/04/2019.
- *  Adapted from donated nonius code.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
- // Environment measurement
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef TWOBLUECUBES_CATCH_DETAIL_ESTIMATE_CLOCK_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_DETAIL_ESTIMATE_CLOCK_HPP_INCLUDED
+// SPDX-License-Identifier: BSL-1.0
+// Adapted from donated nonius code.
+
+#ifndef CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
+#define CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
 
 #include <catch2/benchmark/catch_clock.hpp>
 #include <catch2/benchmark/catch_environment.hpp>
@@ -20,7 +19,6 @@
 
 #include <algorithm>
 #include <iterator>
-#include <tuple>
 #include <vector>
 #include <cmath>
 
@@ -110,4 +108,4 @@ namespace Catch {
     } // namespace Benchmark
 } // namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_DETAIL_ESTIMATE_CLOCK_HPP_INCLUDED
+#endif // CATCH_ESTIMATE_CLOCK_HPP_INCLUDED

src/catch2/benchmark/detail/catch_measure.hpp

@@ -1,15 +1,14 @@
-/*
- *  Created by Joachim on 16/04/2019.
- *  Adapted from donated nonius code.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
-// Measure
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef TWOBLUECUBES_CATCH_DETAIL_MEASURE_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_DETAIL_MEASURE_HPP_INCLUDED
+// SPDX-License-Identifier: BSL-1.0
+// Adapted from donated nonius code.
+
+#ifndef CATCH_MEASURE_HPP_INCLUDED
+#define CATCH_MEASURE_HPP_INCLUDED
 
 #include <catch2/benchmark/catch_clock.hpp>
 #include <catch2/benchmark/detail/catch_complete_invoke.hpp>
@@ -21,7 +20,7 @@ namespace Catch {
     namespace Benchmark {
         namespace Detail {
             template <typename Clock, typename Fun, typename... Args>
-            TimingOf<Clock, Fun(Args...)> measure(Fun&& fun, Args&&... args) {
+            TimingOf<Clock, Fun, Args...> measure(Fun&& fun, Args&&... args) {
                 auto start = Clock::now();
                 auto&& r = Detail::complete_invoke(fun, std::forward<Args>(args)...);
                 auto end = Clock::now();
@@ -32,4 +31,4 @@ namespace Catch {
     } // namespace Benchmark
 } // namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_DETAIL_MEASURE_HPP_INCLUDED
+#endif // CATCH_MEASURE_HPP_INCLUDED

src/catch2/benchmark/detail/catch_repeat.hpp

@@ -1,15 +1,14 @@
-/*
- *  Created by Joachim on 16/04/2019.
- *  Adapted from donated nonius code.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
-// repeat algorithm
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef TWOBLUECUBES_CATCH_DETAIL_REPEAT_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_DETAIL_REPEAT_HPP_INCLUDED
+// SPDX-License-Identifier: BSL-1.0
+// Adapted from donated nonius code.
+
+#ifndef CATCH_REPEAT_HPP_INCLUDED
+#define CATCH_REPEAT_HPP_INCLUDED
 
 #include <type_traits>
 #include <utility>
@@ -34,4 +33,4 @@ namespace Catch {
     } // namespace Benchmark
 } // namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_DETAIL_REPEAT_HPP_INCLUDED
+#endif // CATCH_REPEAT_HPP_INCLUDED

src/catch2/benchmark/detail/catch_run_for_at_least.hpp

@@ -1,22 +1,21 @@
-/*
- *  Created by Joachim on 16/04/2019.
- *  Adapted from donated nonius code.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
-// Run a function for a minimum amount of time
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef TWOBLUECUBES_CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
+// SPDX-License-Identifier: BSL-1.0
+// Adapted from donated nonius code.
+
+#ifndef CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
+#define CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
 
 #include <catch2/benchmark/catch_clock.hpp>
 #include <catch2/benchmark/catch_chronometer.hpp>
 #include <catch2/benchmark/detail/catch_measure.hpp>
 #include <catch2/benchmark/detail/catch_complete_invoke.hpp>
 #include <catch2/benchmark/detail/catch_timing.hpp>
-#include <catch2/catch_meta.hpp>
+#include <catch2/internal/catch_meta.hpp>
 
 #include <utility>
 #include <type_traits>
@@ -25,11 +24,11 @@ namespace Catch {
     namespace Benchmark {
         namespace Detail {
             template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(int)> measure_one(Fun&& fun, int iters, std::false_type) {
+            TimingOf<Clock, Fun, int> measure_one(Fun&& fun, int iters, std::false_type) {
                 return Detail::measure<Clock>(fun, iters);
             }
             template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(Chronometer)> measure_one(Fun&& fun, int iters, std::true_type) {
+            TimingOf<Clock, Fun, Chronometer> measure_one(Fun&& fun, int iters, std::true_type) {
                 Detail::ChronometerModel<Clock> meter;
                 auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
 
@@ -39,14 +38,12 @@ namespace Catch {
             template <typename Clock, typename Fun>
             using run_for_at_least_argument_t = typename std::conditional<is_callable<Fun(Chronometer)>::value, Chronometer, int>::type;
 
-            struct optimized_away_error : std::exception {
-                const char* what() const noexcept override {
-                    return "could not measure benchmark, maybe it was optimized away";
-                }
-            };
+
+            [[noreturn]]
+            void throw_optimized_away_error();
 
             template <typename Clock, typename Fun>
-            TimingOf<Clock, Fun(run_for_at_least_argument_t<Clock, Fun>)> run_for_at_least(ClockDuration<Clock> how_long, int seed, Fun&& fun) {
+            TimingOf<Clock, Fun, run_for_at_least_argument_t<Clock, Fun>> run_for_at_least(ClockDuration<Clock> how_long, int seed, Fun&& fun) {
                 auto iters = seed;
                 while (iters < (1 << 30)) {
                     auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
@@ -56,10 +53,10 @@ namespace Catch {
                     }
                     iters *= 2;
                 }
-                throw optimized_away_error{};
+                throw_optimized_away_error();
             }
         } // namespace Detail
     } // namespace Benchmark
 } // namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
+#endif // CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED

src/catch2/benchmark/detail/catch_stats.cpp

@@ -1,20 +1,18 @@
-/*
- *  Created by Martin on 15/06/2019.
- *  Adapted from donated nonius code.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
-// Statistical analysis tools
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
 
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// SPDX-License-Identifier: BSL-1.0
+// Adapted from donated nonius code.
 
 #include <catch2/benchmark/detail/catch_stats.hpp>
 
-#include <catch2/catch_compiler_capabilities.h>
+#include <catch2/internal/catch_compiler_capabilities.hpp>
 
 #include <cassert>
+#include <iterator>
 #include <random>
 
 
@@ -23,6 +21,27 @@
 #endif
 
 namespace {
+
+using Catch::Benchmark::Detail::sample;
+
+     template <typename URng, typename Estimator>
+     sample resample(URng& rng, int resamples, std::vector<double>::iterator first, std::vector<double>::iterator last, Estimator& estimator) {
+         auto n = last - first;
+         std::uniform_int_distribution<decltype(n)> dist(0, n - 1);
+
+         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[dist(rng)]; });
+             return estimator(resampled.begin(), resampled.end());
+         });
+         std::sort(out.begin(), out.end());
+         return out;
+     }
+
+
     double erf_inv(double x) {
         // Code accompanying the article "Approximating the erfinv function" in GPU Computing Gems, Volume 2
         double w, p;
@@ -220,5 +239,3 @@ namespace Catch {
         } // namespace Detail
     } // namespace Benchmark
 } // namespace Catch
-
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING

src/catch2/benchmark/detail/catch_stats.hpp

@@ -1,28 +1,24 @@
-/*
- *  Created by Joachim on 16/04/2019.
- *  Adapted from donated nonius code.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
-// Statistical analysis tools
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef TWOBLUECUBES_CATCH_DETAIL_ANALYSIS_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_DETAIL_ANALYSIS_HPP_INCLUDED
+// SPDX-License-Identifier: BSL-1.0
+// Adapted from donated nonius code.
+
+#ifndef CATCH_STATS_HPP_INCLUDED
+#define CATCH_STATS_HPP_INCLUDED
 
-#include <catch2/benchmark/catch_clock.hpp>
 #include <catch2/benchmark/catch_estimate.hpp>
 #include <catch2/benchmark/catch_outlier_classification.hpp>
 
 #include <algorithm>
-#include <functional>
 #include <vector>
 #include <numeric>
 #include <tuple>
 #include <cmath>
 #include <utility>
-#include <cstddef>
 
 namespace Catch {
     namespace Benchmark {
@@ -62,27 +58,11 @@ namespace Catch {
                 return sum / count;
             }
 
-            template <typename URng, typename Iterator, typename Estimator>
-            sample resample(URng& rng, int resamples, Iterator first, Iterator last, Estimator& estimator) {
-                auto n = last - first;
-                std::uniform_int_distribution<decltype(n)> dist(0, n - 1);
-
-                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[dist(rng)]; });
-                    return estimator(resampled.begin(), resampled.end());
-                });
-                std::sort(out.begin(), out.end());
-                return out;
-            }
-
             template <typename Estimator, typename Iterator>
             sample jackknife(Estimator&& estimator, Iterator first, Iterator last) {
                 auto n = last - first;
-                auto second = std::next(first);
+                auto second = first;
+                ++second;
                 sample results;
                 results.reserve(n);
 
@@ -155,4 +135,4 @@ namespace Catch {
     } // namespace Benchmark
 } // namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_DETAIL_ANALYSIS_HPP_INCLUDED
+#endif // CATCH_STATS_HPP_INCLUDED

src/catch2/benchmark/detail/catch_timing.hpp

@@ -1,20 +1,18 @@
-/*
- *  Created by Joachim on 16/04/2019.
- *  Adapted from donated nonius code.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
-// Timing
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef TWOBLUECUBES_CATCH_DETAIL_TIMING_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_DETAIL_TIMING_HPP_INCLUDED
+// SPDX-License-Identifier: BSL-1.0
+// Adapted from donated nonius code.
+
+#ifndef CATCH_TIMING_HPP_INCLUDED
+#define CATCH_TIMING_HPP_INCLUDED
 
 #include <catch2/benchmark/catch_clock.hpp>
 #include <catch2/benchmark/detail/catch_complete_invoke.hpp>
 
-#include <tuple>
 #include <type_traits>
 
 namespace Catch {
@@ -25,9 +23,9 @@ namespace Catch {
             Result result;
             int iterations;
         };
-        template <typename Clock, typename Sig>
-        using TimingOf = Timing<ClockDuration<Clock>, Detail::CompleteType_t<Detail::ResultOf_t<Sig>>>;
+        template <typename Clock, typename Func, typename... Args>
+        using TimingOf = Timing<ClockDuration<Clock>, Detail::CompleteType_t<FunctionReturnType<Func, Args...>>>;
     } // namespace Benchmark
 } // namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_DETAIL_TIMING_HPP_INCLUDED
+#endif // CATCH_TIMING_HPP_INCLUDED

src/catch2/benchmark/internal/catch_benchmark_combined_tu.cpp

@@ -0,0 +1,95 @@
+
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+/** \file
+ * This is a special TU that combines what would otherwise be a very
+ * small benchmarking-related TUs into one bigger TU.
+ *
+ * The reason for this is compilation performance improvements by
+ * avoiding reparsing headers for many small TUs, instead having this
+ * one TU include bit more, but having it all parsed only once.
+ *
+ * To avoid heavy-tail problem with compilation times, each "subpart"
+ * of Catch2 has its own combined TU like this.
+ */
+
+////////////////////////////////////////////
+// vvv formerly catch_chronometer.cpp vvv //
+////////////////////////////////////////////
+
+#include <catch2/benchmark/catch_chronometer.hpp>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            ChronometerConcept::~ChronometerConcept() = default;
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+
+///////////////////////////////////////////////////
+// vvv formerly catch_benchmark_function.cpp vvv //
+///////////////////////////////////////////////////
+
+#include <catch2/benchmark/detail/catch_benchmark_function.hpp>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            BenchmarkFunction::callable::~callable() = default;
+            } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+
+////////////////////////////////////////////////
+// vvv formerly catch_complete_invoke.cpp vvv //
+////////////////////////////////////////////////
+
+#include <catch2/benchmark/detail/catch_complete_invoke.hpp>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+            CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+            const std::string benchmarkErrorMsg = "a benchmark failed to run successfully";
+            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+
+
+
+/////////////////////////////////////////////////
+// vvv formerly catch_run_for_at_least.cpp vvv //
+/////////////////////////////////////////////////
+
+#include <catch2/benchmark/detail/catch_run_for_at_least.hpp>
+#include <exception>
+#include <catch2/internal/catch_enforce.hpp>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            struct optimized_away_error : std::exception {
+                const char* what() const noexcept override;
+            };
+
+            const char* optimized_away_error::what() const noexcept {
+                return "could not measure benchmark, maybe it was optimized away";
+            }
+
+            void throw_optimized_away_error() {
+                Catch::throw_exception(optimized_away_error{});
+            }
+
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch

src/catch2/catch.hpp

@@ -1,454 +0,0 @@
-/*
- *  Created by Phil on 22/10/2010.
- *  Copyright 2010 Two Blue Cubes Ltd
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-
-#ifndef TWOBLUECUBES_CATCH_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_HPP_INCLUDED
-
-#define CATCH_VERSION_MAJOR 2
-#define CATCH_VERSION_MINOR 10
-#define CATCH_VERSION_PATCH 2
-
-#ifdef __clang__
-#    pragma clang system_header
-#elif defined __GNUC__
-#    pragma GCC system_header
-#endif
-
-#include <catch2/catch_suppress_warnings.h>
-
-#if !defined(CATCH_CONFIG_IMPL_ONLY)
-#include <catch2/catch_platform.h>
-
-#include <catch2/catch_user_interfaces.h>
-#include <catch2/catch_tag_alias_autoregistrar.h>
-#include <catch2/catch_test_registry.h>
-#include <catch2/catch_capture.hpp>
-#include <catch2/catch_section.h>
-#include <catch2/catch_interfaces_exception.h>
-#include <catch2/catch_approx.h>
-#include <catch2/catch_compiler_capabilities.h>
-#include <catch2/catch_string_manip.h>
-
-#ifndef CATCH_CONFIG_DISABLE_MATCHERS
-#include <catch2/catch_capture_matchers.h>
-#endif
-#include <catch2/catch_generators.hpp>
-#include <catch2/catch_generators_generic.hpp>
-#include <catch2/catch_generators_specific.hpp>
-
-// These files are included here so the single_include script doesn't put them
-// in the conditionally compiled sections
-#include <catch2/catch_test_case_info.h>
-#include <catch2/catch_interfaces_runner.h>
-
-#ifdef __OBJC__
-#include <catch2/catch_objc.hpp>
-#endif
-
-#include <catch2/catch_external_interfaces.h>
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-#include <catch2/benchmark/catch_benchmark.hpp>
-#endif
-
-#endif // ! CATCH_CONFIG_IMPL_ONLY
-
-#if !defined(CATCH_CONFIG_IMPL_ONLY)
-
-#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
-#  undef CLARA_CONFIG_MAIN
-#endif
-
-#if !defined(CATCH_CONFIG_DISABLE)
-//////
-// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
-#ifdef CATCH_CONFIG_PREFIX_ALL
-
-#define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-
-#define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
-#endif// CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-
-#define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-#define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
-
-#define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
-
-#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
-#define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
-#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE",__VA_ARGS__ )
-
-#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
-#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
-#define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
-#define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-#define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
-#define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#else
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#endif
-
-
-#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
-#define CATCH_STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
-#else
-#define CATCH_STATIC_REQUIRE( ... )       CATCH_REQUIRE( __VA_ARGS__ )
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
-#endif
-
-
-// "BDD-style" convenience wrappers
-#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
-#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-#define CATCH_GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
-#define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
-#define CATCH_WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
-#define CATCH_AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
-#define CATCH_THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
-#define CATCH_AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-#define CATCH_BENCHMARK(...) \
-    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
-#define CATCH_BENCHMARK_ADVANCED(name) \
-    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
-#else
-
-#define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__  )
-#define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-
-#define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
-
-#define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
-#define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
-
-#define CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
-
-#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
-#define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
-#define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE",__VA_ARGS__ )
-
-#define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
-#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
-#define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
-#define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-#define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
-#define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
-#define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-#define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
-#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
-#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#else
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
-#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
-#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
-#endif
-
-
-#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
-#define STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
-#define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
-#else
-#define STATIC_REQUIRE( ... )       REQUIRE( __VA_ARGS__ )
-#define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
-#endif
-
-#endif
-
-#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
-
-// "BDD-style" convenience wrappers
-#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
-#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-
-#define GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
-#define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
-#define WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
-#define AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
-#define THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
-#define AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
-
-#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-#define BENCHMARK(...) \
-    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
-#define BENCHMARK_ADVANCED(name) \
-    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
-#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
-
-using Catch::Detail::Approx;
-
-#else // CATCH_CONFIG_DISABLE
-
-//////
-// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
-#ifdef CATCH_CONFIG_PREFIX_ALL
-
-#define CATCH_REQUIRE( ... )        (void)(0)
-#define CATCH_REQUIRE_FALSE( ... )  (void)(0)
-
-#define CATCH_REQUIRE_THROWS( ... ) (void)(0)
-#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CATCH_REQUIRE_THROWS_WITH( expr, matcher )     (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif// CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)
-
-#define CATCH_CHECK( ... )         (void)(0)
-#define CATCH_CHECK_FALSE( ... )   (void)(0)
-#define CATCH_CHECKED_IF( ... )    if (__VA_ARGS__)
-#define CATCH_CHECKED_ELSE( ... )  if (!(__VA_ARGS__))
-#define CATCH_CHECK_NOFAIL( ... )  (void)(0)
-
-#define CATCH_CHECK_THROWS( ... )  (void)(0)
-#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CATCH_CHECK_THROWS_WITH( expr, matcher )     (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CATCH_CHECK_NOTHROW( ... ) (void)(0)
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CATCH_CHECK_THAT( arg, matcher )   (void)(0)
-
-#define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define CATCH_INFO( msg )          (void)(0)
-#define CATCH_UNSCOPED_INFO( msg ) (void)(0)
-#define CATCH_WARN( msg )          (void)(0)
-#define CATCH_CAPTURE( msg )       (void)(0)
-
-#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_METHOD_AS_TEST_CASE( method, ... )
-#define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
-#define CATCH_SECTION( ... )
-#define CATCH_DYNAMIC_SECTION( ... )
-#define CATCH_FAIL( ... ) (void)(0)
-#define CATCH_FAIL_CHECK( ... ) (void)(0)
-#define CATCH_SUCCEED( ... ) (void)(0)
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#else
-#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
-#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#endif
-
-// "BDD-style" convenience wrappers
-#define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
-#define CATCH_GIVEN( desc )
-#define CATCH_AND_GIVEN( desc )
-#define CATCH_WHEN( desc )
-#define CATCH_AND_WHEN( desc )
-#define CATCH_THEN( desc )
-#define CATCH_AND_THEN( desc )
-
-#define CATCH_STATIC_REQUIRE( ... )       (void)(0)
-#define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
-
-// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
-#else
-
-#define REQUIRE( ... )       (void)(0)
-#define REQUIRE_FALSE( ... ) (void)(0)
-
-#define REQUIRE_THROWS( ... ) (void)(0)
-#define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
-#define REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define REQUIRE_NOTHROW( ... ) (void)(0)
-
-#define CHECK( ... ) (void)(0)
-#define CHECK_FALSE( ... ) (void)(0)
-#define CHECKED_IF( ... ) if (__VA_ARGS__)
-#define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
-#define CHECK_NOFAIL( ... ) (void)(0)
-
-#define CHECK_THROWS( ... )  (void)(0)
-#define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
-#define CHECK_THROWS_WITH( expr, matcher ) (void)(0)
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-#define CHECK_NOTHROW( ... ) (void)(0)
-
-
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
-#define CHECK_THAT( arg, matcher ) (void)(0)
-
-#define REQUIRE_THAT( arg, matcher ) (void)(0)
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
-
-#define INFO( msg ) (void)(0)
-#define UNSCOPED_INFO( msg ) (void)(0)
-#define WARN( msg ) (void)(0)
-#define CAPTURE( msg ) (void)(0)
-
-#define TEST_CASE( ... )  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
-#define METHOD_AS_TEST_CASE( method, ... )
-#define REGISTER_TEST_CASE( Function, ... ) (void)(0)
-#define SECTION( ... )
-#define DYNAMIC_SECTION( ... )
-#define FAIL( ... ) (void)(0)
-#define FAIL_CHECK( ... ) (void)(0)
-#define SUCCEED( ... ) (void)(0)
-
-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#else
-#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
-#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
-#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
-#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
-#endif
-
-#define STATIC_REQUIRE( ... )       (void)(0)
-#define STATIC_REQUIRE_FALSE( ... ) (void)(0)
-
-#endif
-
-#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
-
-// "BDD-style" convenience wrappers
-#define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) )
-#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
-
-#define GIVEN( desc )
-#define AND_GIVEN( desc )
-#define WHEN( desc )
-#define AND_WHEN( desc )
-#define THEN( desc )
-#define AND_THEN( desc )
-
-using Catch::Detail::Approx;
-
-
-#endif
-
-#endif // ! CATCH_CONFIG_IMPL_ONLY
-
-#include <catch2/catch_reenable_warnings.h>
-
-#endif // TWOBLUECUBES_CATCH_HPP_INCLUDED

src/catch2/catch_all.hpp

@@ -0,0 +1,105 @@
+
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+/** \file
+ * This is a convenience header for Catch2. It includes **all** of Catch2 headers.
+ *
+ * Generally the Catch2 users should use specific includes they need,
+ * but this header can be used instead for ease-of-experimentation, or
+ * just plain convenience, at the cost of (significantly) increased
+ * compilation times.
+ *
+ * When a new header is added to either the top level folder, or to the
+ * corresponding internal subfolder, it should be added here. Headers
+ * added to the various subparts (e.g. matchers, generators, etc...),
+ * should go their respective catch-all headers.
+ */
+
+#ifndef CATCH_ALL_HPP_INCLUDED
+#define CATCH_ALL_HPP_INCLUDED
+
+#include <catch2/benchmark/catch_benchmark_all.hpp>
+#include <catch2/catch_approx.hpp>
+#include <catch2/catch_assertion_info.hpp>
+#include <catch2/catch_assertion_result.hpp>
+#include <catch2/catch_config.hpp>
+#include <catch2/catch_message.hpp>
+#include <catch2/catch_reporter_registrars.hpp>
+#include <catch2/catch_section_info.hpp>
+#include <catch2/catch_session.hpp>
+#include <catch2/catch_tag_alias.hpp>
+#include <catch2/catch_tag_alias_autoregistrar.hpp>
+#include <catch2/catch_template_test_macros.hpp>
+#include <catch2/catch_test_case_info.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/catch_test_spec.hpp>
+#include <catch2/catch_timer.hpp>
+#include <catch2/catch_tostring.hpp>
+#include <catch2/catch_totals.hpp>
+#include <catch2/catch_translate_exception.hpp>
+#include <catch2/catch_version.hpp>
+#include <catch2/catch_version_macros.hpp>
+#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_case_sensitive.hpp>
+#include <catch2/internal/catch_clara.hpp>
+#include <catch2/internal/catch_commandline.hpp>
+#include <catch2/internal/catch_common.hpp>
+#include <catch2/internal/catch_compiler_capabilities.hpp>
+#include <catch2/internal/catch_config_uncaught_exceptions.hpp>
+#include <catch2/internal/catch_console_colour.hpp>
+#include <catch2/internal/catch_console_width.hpp>
+#include <catch2/internal/catch_container_nonmembers.hpp>
+#include <catch2/internal/catch_context.hpp>
+#include <catch2/internal/catch_debug_console.hpp>
+#include <catch2/internal/catch_debugger.hpp>
+#include <catch2/internal/catch_decomposer.hpp>
+#include <catch2/internal/catch_enforce.hpp>
+#include <catch2/internal/catch_enum_values_registry.hpp>
+#include <catch2/internal/catch_errno_guard.hpp>
+#include <catch2/internal/catch_exception_translator_registry.hpp>
+#include <catch2/internal/catch_fatal_condition_handler.hpp>
+#include <catch2/internal/catch_lazy_expr.hpp>
+#include <catch2/internal/catch_leak_detector.hpp>
+#include <catch2/internal/catch_list.hpp>
+#include <catch2/internal/catch_message_info.hpp>
+#include <catch2/internal/catch_meta.hpp>
+#include <catch2/internal/catch_noncopyable.hpp>
+#include <catch2/internal/catch_option.hpp>
+#include <catch2/internal/catch_output_redirect.hpp>
+#include <catch2/internal/catch_platform.hpp>
+#include <catch2/internal/catch_polyfills.hpp>
+#include <catch2/internal/catch_preprocessor.hpp>
+#include <catch2/internal/catch_random_number_generator.hpp>
+#include <catch2/internal/catch_reporter_registry.hpp>
+#include <catch2/internal/catch_result_type.hpp>
+#include <catch2/internal/catch_run_context.hpp>
+#include <catch2/internal/catch_section.hpp>
+#include <catch2/internal/catch_singletons.hpp>
+#include <catch2/internal/catch_startup_exception_registry.hpp>
+#include <catch2/internal/catch_stream.hpp>
+#include <catch2/internal/catch_string_manip.hpp>
+#include <catch2/internal/catch_stringref.hpp>
+#include <catch2/internal/catch_tag_alias_registry.hpp>
+#include <catch2/internal/catch_template_test_registry.hpp>
+#include <catch2/internal/catch_test_case_registry_impl.hpp>
+#include <catch2/internal/catch_test_case_tracker.hpp>
+#include <catch2/internal/catch_test_macro_impl.hpp>
+#include <catch2/internal/catch_test_registry.hpp>
+#include <catch2/internal/catch_test_spec_parser.hpp>
+#include <catch2/internal/catch_textflow.hpp>
+#include <catch2/internal/catch_to_string.hpp>
+#include <catch2/internal/catch_uncaught_exceptions.hpp>
+#include <catch2/internal/catch_unique_ptr.hpp>
+#include <catch2/internal/catch_wildcard_pattern.hpp>
+#include <catch2/internal/catch_windows_h_proxy.hpp>
+#include <catch2/internal/catch_xmlwriter.hpp>
+#include <catch2/matchers/catch_matchers_all.hpp>
+#include <catch2/reporters/catch_reporters_all.hpp>
+
+#endif // CATCH_ALL_HPP_INCLUDED

src/catch2/catch_approx.cpp

@@ -1,13 +1,12 @@
-/*
- *  Created by Martin on 19/07/2017.
- *  Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
-#include <catch2/catch_approx.h>
-#include <catch2/catch_enforce.h>
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#include <catch2/catch_approx.hpp>
+#include <catch2/internal/catch_enforce.hpp>
 
 #include <cmath>
 #include <limits>
@@ -23,7 +22,6 @@ bool marginComparison(double lhs, double rhs, double margin) {
 }
 
 namespace Catch {
-namespace Detail {
 
     Approx::Approx ( double value )
     :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
@@ -70,18 +68,16 @@ namespace Detail {
         m_epsilon = newEpsilon;
     }
 
-} // end namespace Detail
-
 namespace literals {
-    Detail::Approx operator "" _a(long double val) {
-        return Detail::Approx(val);
+    Approx operator "" _a(long double val) {
+        return Approx(val);
     }
-    Detail::Approx operator "" _a(unsigned long long val) {
-        return Detail::Approx(val);
+    Approx operator "" _a(unsigned long long val) {
+        return Approx(val);
     }
 } // end namespace literals
 
-std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx const& value) {
+std::string StringMaker<Catch::Approx>::convert(Catch::Approx const& value) {
     return value.toString();
 }
 

src/catch2/catch_approx.hpp

@@ -1,28 +1,25 @@
-/*
- *  Created by Phil on 28/04/2011.
- *  Copyright 2010 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED
 
-#include <catch2/catch_tostring.h>
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#ifndef CATCH_APPROX_HPP_INCLUDED
+#define CATCH_APPROX_HPP_INCLUDED
+
+#include <catch2/catch_tostring.hpp>
 
 #include <type_traits>
 
 namespace Catch {
-namespace Detail {
 
     class Approx {
     private:
         bool equalityComparisonImpl(double other) const;
-        // Validates the new margin (margin >= 0)
-        // out-of-line to avoid including stdexcept in the header
+        // Sets and validates the new margin (margin >= 0)
         void setMargin(double margin);
-        // Validates the new epsilon (0 < epsilon < 1)
-        // out-of-line to avoid including stdexcept in the header
+        // Sets and validates the new epsilon (0 < epsilon < 1)
         void setEpsilon(double epsilon);
 
     public:
@@ -32,7 +29,7 @@ namespace Detail {
 
         Approx operator-() const;
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         Approx operator()( T const& value ) {
             Approx approx( static_cast<double>(value) );
             approx.m_epsilon = m_epsilon;
@@ -41,67 +38,67 @@ namespace Detail {
             return approx;
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         explicit Approx( T const& value ): Approx(static_cast<double>(value))
         {}
 
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         friend bool operator == ( const T& lhs, Approx const& rhs ) {
             auto lhs_v = static_cast<double>(lhs);
             return rhs.equalityComparisonImpl(lhs_v);
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         friend bool operator == ( Approx const& lhs, const T& rhs ) {
             return operator==( rhs, lhs );
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         friend bool operator != ( T const& lhs, Approx const& rhs ) {
             return !operator==( lhs, rhs );
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         friend bool operator != ( Approx const& lhs, T const& rhs ) {
             return !operator==( rhs, lhs );
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         friend bool operator <= ( T const& lhs, Approx const& rhs ) {
             return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         friend bool operator <= ( Approx const& lhs, T const& rhs ) {
             return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         friend bool operator >= ( T const& lhs, Approx const& rhs ) {
             return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         friend bool operator >= ( Approx const& lhs, T const& rhs ) {
             return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         Approx& epsilon( T const& newEpsilon ) {
             double epsilonAsDouble = static_cast<double>(newEpsilon);
             setEpsilon(epsilonAsDouble);
             return *this;
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         Approx& margin( T const& newMargin ) {
             double marginAsDouble = static_cast<double>(newMargin);
             setMargin(marginAsDouble);
             return *this;
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         Approx& scale( T const& newScale ) {
             m_scale = static_cast<double>(newScale);
             return *this;
@@ -115,18 +112,17 @@ namespace Detail {
         double m_scale;
         double m_value;
     };
-} // end namespace Detail
 
 namespace literals {
-    Detail::Approx operator "" _a(long double val);
-    Detail::Approx operator "" _a(unsigned long long val);
+    Approx operator "" _a(long double val);
+    Approx operator "" _a(unsigned long long val);
 } // end namespace literals
 
 template<>
-struct StringMaker<Catch::Detail::Approx> {
-    static std::string convert(Catch::Detail::Approx const& value);
+struct StringMaker<Catch::Approx> {
+    static std::string convert(Catch::Approx const& value);
 };
 
 } // end namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED
+#endif // CATCH_APPROX_HPP_INCLUDED

src/catch2/catch_assertion_info.hpp

@@ -0,0 +1,28 @@
+
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#ifndef CATCH_ASSERTION_INFO_HPP_INCLUDED
+#define CATCH_ASSERTION_INFO_HPP_INCLUDED
+
+#include <catch2/internal/catch_result_type.hpp>
+#include <catch2/internal/catch_common.hpp>
+#include <catch2/internal/catch_stringref.hpp>
+
+namespace Catch {
+
+    struct AssertionInfo {
+        // AssertionInfo() = delete;
+
+        StringRef macroName;
+        SourceLineInfo lineInfo;
+        StringRef capturedExpression;
+        ResultDisposition::Flags resultDisposition;
+    };
+
+} // end namespace Catch
+
+#endif // CATCH_ASSERTION_INFO_HPP_INCLUDED

src/catch2/catch_assertion_result.cpp

@@ -1,14 +1,15 @@
-/*
- *  Created by Phil on 8/8/12
- *  Copyright 2012 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
 
-#include <catch2/catch_assertionresult.h>
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#include <catch2/catch_assertion_result.hpp>
+#include <catch2/internal/catch_stream.hpp>
 
 namespace Catch {
+
     AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
         lazyExpression(_lazyExpression),
         resultType(_resultType) {}

src/catch2/catch_assertion_result.hpp

@@ -1,19 +1,19 @@
-/*
- *  Created by Phil on 28/10/2010.
- *  Copyright 2010 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED
-#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED
+
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#ifndef CATCH_ASSERTION_RESULT_HPP_INCLUDED
+#define CATCH_ASSERTION_RESULT_HPP_INCLUDED
 
 #include <string>
-#include <catch2/catch_assertioninfo.h>
-#include <catch2/catch_result_type.h>
-#include <catch2/catch_common.h>
-#include <catch2/catch_stringref.h>
-#include <catch2/catch_assertionhandler.h>
+#include <catch2/catch_assertion_info.hpp>
+#include <catch2/internal/catch_result_type.hpp>
+#include <catch2/internal/catch_common.hpp>
+#include <catch2/internal/catch_stringref.hpp>
+#include <catch2/internal/catch_lazy_expr.hpp>
 
 namespace Catch {
 
@@ -56,4 +56,4 @@ namespace Catch {
 
 } // end namespace Catch
 
-#endif // TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED
+#endif // CATCH_ASSERTION_RESULT_HPP_INCLUDED

src/catch2/catch_assertioninfo.h

@@ -1,28 +0,0 @@
-/*
- *  Created by Phil on 8/8/2017.
- *  Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_CATCH_ASSERTIONINFO_H_INCLUDED
-#define TWOBLUECUBES_CATCH_ASSERTIONINFO_H_INCLUDED
-
-#include <catch2/catch_result_type.h>
-#include <catch2/catch_common.h>
-#include <catch2/catch_stringref.h>
-
-namespace Catch {
-
-    struct AssertionInfo {
-        // AssertionInfo() = delete;
-
-        StringRef macroName;
-        SourceLineInfo lineInfo;
-        StringRef capturedExpression;
-        ResultDisposition::Flags resultDisposition;
-    };
-
-} // end namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_ASSERTIONINFO_H_INCLUDED

src/catch2/catch_capture_matchers.cpp

@@ -1,24 +0,0 @@
-/*
- *  Created by Phil on 9/8/2017.
- *  Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#include <catch2/catch_capture_matchers.h>
-#include <catch2/catch_interfaces_registry_hub.h>
-
-namespace Catch {
-
-    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
-
-    // This is the general overload that takes a any string matcher
-    // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
-    // the Equals matcher (so the header does not mention matchers)
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  ) {
-        std::string exceptionMessage = Catch::translateActiveException();
-        MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
-        handler.handleExpr( expr );
-    }
-
-} // namespace Catch

src/catch2/catch_clara.h

@@ -1,38 +0,0 @@
-/*
- *  Created by Phil on 10/2/2014.
- *  Copyright 2014 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- *
- */
-#ifndef TWOBLUECUBES_CATCH_CLARA_H_INCLUDED
-#define TWOBLUECUBES_CATCH_CLARA_H_INCLUDED
-
-// Use Catch's value for console width (store Clara's off to the side, if present)
-#ifdef CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#undef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#endif
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH-1
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wweak-vtables"
-#pragma clang diagnostic ignored "-Wexit-time-destructors"
-#pragma clang diagnostic ignored "-Wshadow"
-#endif
-
-#include <catch2/external/clara.hpp>
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// Restore Clara's value for console width, if present
-#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#endif
-
-#endif // TWOBLUECUBES_CATCH_CLARA_H_INCLUDED