Fix priority

.clang-format

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

.github/FUNDING.yml

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

.gitignore

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

.travis.yml

@@ -9,8 +9,8 @@ common_sources: &all_sources
   - llvm-toolchain-trusty
   - llvm-toolchain-trusty-3.9
   - llvm-toolchain-trusty-4.0
-  - llvm-toolchain-xenial-5.0
-  - llvm-toolchain-xenial-6.0
+  - llvm-toolchain-trusty-5.0
+  - llvm-toolchain-trusty-6.0
 
 matrix:
   include:
@@ -60,7 +60,6 @@ matrix:
       env: COMPILER='clang++-4.0'
 
     - os: linux
-      dist: xenial
       compiler: clang
       addons:
           apt:
@@ -69,7 +68,6 @@ matrix:
       env: COMPILER='clang++-5.0'
 
     - os: linux
-      dist: xenial
       compiler: clang
       addons:
           apt:
@@ -155,7 +153,6 @@ matrix:
       env: COMPILER='clang++-4.0' CPP14=1
 
     - os: linux
-      dist: xenial
       compiler: clang
       addons:
           apt:
@@ -164,7 +161,6 @@ matrix:
       env: COMPILER='clang++-5.0' CPP14=1
 
     - os: linux
-      dist: xenial
       compiler: clang
       addons:
           apt:
@@ -259,7 +255,6 @@ matrix:
       env: COMPILER='g++-7' EXAMPLES=1 COVERAGE=1 EXTRAS=1 CPP17=1
 
     - os: linux
-      dist: xenial
       compiler: clang
       addons:
           apt:
@@ -268,7 +263,6 @@ matrix:
       env: COMPILER='clang++-6.0' CPP17=1
 
     - os: linux
-      dist: xenial
       compiler: clang
       addons:
           apt:
@@ -282,7 +276,7 @@ matrix:
         - "3.7"
       dist: xenial
       install:
-        - pip install conan-package-tools
+        - pip install conan==1.10.2 conan-package-tools
       env:
         - CONAN_GCC_VERSIONS=8
         - CONAN_DOCKER_IMAGE=conanio/gcc8

BUILD.bazel

@@ -1,10 +0,0 @@
-# Load the cc_library rule.
-load("@rules_cc//cc:defs.bzl", "cc_library")
-
-# Header-only rule to export catch2/catch.hpp.
-cc_library(
-  name = "catch2",
-  hdrs = ["single_include/catch2/catch.hpp"],
-  visibility = ["//visibility:public"],
-  includes = ["single_include/"],
-)

CMakeLists.txt

@@ -6,16 +6,12 @@ if(NOT DEFINED PROJECT_NAME)
   set(NOT_SUBPROJECT ON)
 endif()
 
-# Catch2's build breaks if done in-tree. You probably should not build
-# things in tree anyway, but we can allow projects that include Catch2
-# as a subproject to build in-tree as long as it is not in our tree.
-if (CMAKE_BINARY_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+project(Catch2 LANGUAGES CXX VERSION 2.9.1)
+
+if (CMAKE_BINARY_DIR STREQUAL CMAKE_SOURCE_DIR)
     message(FATAL_ERROR "Building in-source is not supported! Create a build dir and remove ${CMAKE_SOURCE_DIR}/CMakeCache.txt")
 endif()
 
-
-project(Catch2 LANGUAGES CXX VERSION 2.13.0)
-
 # Provide path for scripts
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/CMake")
 
@@ -46,8 +42,8 @@ if(USE_WMAIN)
 endif()
 
 if (BUILD_TESTING AND CATCH_BUILD_TESTING AND NOT_SUBPROJECT)
-    find_package(PythonInterp)
-    if (NOT PYTHONINTERP_FOUND)
+    find_package(Python COMPONENTS Interpreter)
+    if (NOT Python_Interpreter_FOUND)
         message(FATAL_ERROR "Python not found, but required for tests")
     endif()
     add_subdirectory(projects)
@@ -96,10 +92,6 @@ target_include_directories(Catch2
     $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
 )
 
-if (ANDROID)
-    target_link_libraries(Catch2 INTERFACE log)
-endif()
-
 # provide a namespaced alias for clients to 'link' against if catch is included as a sub-project
 add_library(Catch2::Catch2 ALIAS Catch2)
 

README.md

@@ -5,11 +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/aavJBzemrxUgGV9S)
+[![Try online](https://img.shields.io/badge/try-online-blue.svg)](https://wandbox.org/permlink/5icuqPwk9miJLAL1)
 [![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.13.0/catch.hpp">The latest version of the single header can be downloaded directly using this link</a>
+<a href="https://github.com/catchorg/Catch2/releases/download/v2.9.1/catch.hpp">The latest version of the single header can be downloaded directly using this link</a>
 
 ## Catch2 is released!
 

appveyor.yml

@@ -1,11 +1,6 @@
 # version string format -- This will be overwritten later anyway
 version: "{build}"
 
-# We need a more up to date pip because Python 2.7 is EOL soon
-init:
-  - set PATH=C:\Python35\Scripts;%PATH%
-
-
 branches:
   except:
     - /dev-travis.+/
@@ -67,7 +62,7 @@ matrix:
 
 
 install:
-  - ps: if (($env:CONFIGURATION) -eq "Debug" -And ($env:coverage) -eq "1" ) { pip --disable-pip-version-check install codecov }
+  - ps: if (($env:CONFIGURATION) -eq "Debug" -And ($env:coverage) -eq "1" ) { python -m pip --disable-pip-version-check install codecov }
   - ps: if (($env:CONFIGURATION) -eq "Debug" -And ($env:coverage) -eq "1" ) { .\misc\installOpenCppCoverage.ps1 }
 
 # Win32 and x64 are CMake-compatible solution platform names.

codecov.yml

@@ -14,7 +14,6 @@ coverage:
     - "**/catch_reporter_tap.hpp"
     - "**/catch_reporter_automake.hpp"
     - "**/catch_reporter_teamcity.hpp"
-    - "**/catch_reporter_sonarqube.hpp"
     - "**/external/clara.hpp"
 
 

conanfile.py

@@ -25,6 +25,3 @@ class CatchConan(ConanFile):
 
     def package_id(self):
         self.info.header_only()
-
-    def package_info(self):
-        self.cpp_info.builddirs.append("lib/cmake/Catch2")

contrib/CatchAddTests.cmake

@@ -51,11 +51,8 @@ string(REPLACE "\n" ";" output "${output}")
 # Parse output
 foreach(line ${output})
   set(test ${line})
-  # Escape characters in test case names that would be parsed by Catch2
-  set(test_name ${test})
-  foreach(char , [ ])
-    string(REPLACE ${char} "\\${char}" test_name ${test_name})
-  endforeach(char)
+  # use escape commas to handle properly test cases with commans inside the name
+  string(REPLACE "," "\\," test_name ${test})
   # ...and add to script
   add_command(add_test
     "${prefix}${test}${suffix}"

contrib/ParseAndAddCatchTests.cmake

@@ -144,7 +144,7 @@ function(ParseAndAddCatchTests_ParseFile SourceFile TestTarget)
         if("${TestType}" STREQUAL "SCENARIO")
             set(Name "Scenario: ${Name}")
         endif()
-        if(PARSE_CATCH_TESTS_ADD_FIXTURE_IN_TEST_NAME AND "${TestType}" MATCHES "(CATCH_)?TEST_CASE_METHOD" AND TestFixture )
+        if(PARSE_CATCH_TESTS_ADD_FIXTURE_IN_TEST_NAME AND TestFixture)
             set(CTestName "${TestFixture}:${Name}")
         else()
             set(CTestName "${Name}")

docs/Readme.md

@@ -35,7 +35,6 @@ 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/assertions.md

@@ -136,7 +136,7 @@ REQUIRE_THROWS_WITH( dismantleHal(), "My mind is going" );
 * **REQUIRE_THROWS_MATCHES(** _expression_, _exception type_, _matcher for given exception type_ **)** and
 * **CHECK_THROWS_MATCHES(** _expression_, _exception type_, _matcher for given exception type_ **)**
 
-Expects that exception of _exception type_ is thrown and it matches provided matcher (see the [documentation for Matchers](matchers.md#top)).
+Expects that exception of _exception type_ is thrown and it matches provided matcher (see next section for Matchers).
 
 
 _Please note that the `THROW` family of assertions expects to be passed a single expression, not a statement or series of statements. If you want to check a more complicated sequence of operations, you can use a C++11 lambda function._

docs/benchmarks.md

@@ -1,8 +1,6 @@
 <a id="top"></a>
 # Authoring benchmarks
 
-> [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)._
@@ -168,7 +166,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,17 +187,19 @@ 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/ci-and-misc.md

@@ -12,7 +12,7 @@ Build Systems may refer to low-level tools, like CMake, or larger systems that r
 
 ## Continuous Integration systems
 
-Probably the most important aspect to using Catch with a build server is the use of different reporters. Catch comes bundled with three reporters that should cover the majority of build servers out there - although adding more for better integration with some is always a possibility (currently we also offer TeamCity, TAP, Automake and SonarQube reporters).
+Probably the most important aspect to using Catch with a build server is the use of different reporters. Catch comes bundled with three reporters that should cover the majority of build servers out there - although adding more for better integration with some is always a possibility (currently we also offer TeamCity, TAP and Automake reporters).
 
 Two of these reporters are built in (XML and JUnit) and the third (TeamCity) is included as a separate header. It's possible that the other two may be split out in the future too - as that would make the core of Catch smaller for those that don't need them.
 
@@ -65,10 +65,6 @@ The Automake Reporter writes out the [meta tags](https://www.gnu.org/software/au
 
 Because of the incremental nature of Catch's test suites and ability to run specific tests, our implementation of TAP reporter writes out the number of tests in a suite last.
 
-### SonarQube Reporter
-```-r sonarqube```
-[SonarQube Generic Test Data](https://docs.sonarqube.org/latest/analysis/generic-test/) XML format for tests metrics.
-
 ## Low-level tools
 
 ### Precompiled headers (PCHs)

docs/cmake-integration.md

@@ -6,7 +6,6 @@
 [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.
@@ -221,19 +220,6 @@ 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,7 +24,6 @@
 [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>
@@ -65,7 +64,6 @@ 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>
@@ -101,7 +99,6 @@ exclude:notThis         Matches all tests except, 'notThis'
 ~*private*              Matches all tests except those that contain 'private'
 a* ~ab* abc             Matches all tests that start with 'a', except those that
                         start with 'ab', except 'abc', which is included
--# [#somefile]          Matches all tests from the file 'somefile.cpp'
 </pre>
 
 Names within square brackets are interpreted as tags.
@@ -222,16 +219,6 @@ 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>
@@ -253,25 +240,15 @@ 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).
-Tests in the same TU are sorted using their declaration orders, different
-TUs are in an implementation (linking) dependent order.
 
+### 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.
 
 ### lex
-Lexicographic order. Tests are sorted by their name, their tags are ignored.
-
+Lexicographically sorted. Tests are sorted, alpha-numerically, by name.
 
 ### rand
-
-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
-
+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>.
 
 <a id="rng-seed"></a>
 ## Specify a seed for the Random Number Generator
@@ -291,7 +268,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;never|start|exit|both&gt;</pre>
+<pre>--wait-for-keypress &lt;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.
@@ -300,8 +277,6 @@ either before running any tests, after running all tests - or both, depending on
 ## Specify the number of benchmark samples to collect
 <pre>--benchmark-samples &lt;# of samples&gt;</pre>
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1616) in Catch 2.9.0.
-
 When running benchmarks a number of "samples" is collected. This is the base data for later statistical analysis.
 Per sample a clock resolution dependent number of iterations of the user code is run, which is independent of the number of samples. Defaults to 100.
 
@@ -309,8 +284,6 @@ Per sample a clock resolution dependent number of iterations of the user code is
 ## Specify the number of resamples for bootstrapping
 <pre>--benchmark-resamples &lt;# of resamples&gt;</pre>
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1616) in Catch 2.9.0.
-
 After the measurements are performed, statistical [bootstrapping] is performed
 on the samples. The number of resamples for that bootstrapping is configurable
 but defaults to 100000. Due to the bootstrapping it is possible to give
@@ -324,8 +297,6 @@ defaults to 95%).
 ## Specify the confidence-interval for bootstrapping
 <pre>--benchmark-confidence-interval &lt;confidence-interval&gt;</pre>
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1616) in Catch 2.9.0.
-
 The confidence-interval is used for statistical bootstrapping on the samples to
 calculate the upper and lower bounds of mean and standard deviation.
 Must be between 0 and 1 and defaults to 0.95.
@@ -334,19 +305,9 @@ Must be between 0 and 1 and defaults to 0.95.
 ## Disable statistical analysis of collected benchmark samples
 <pre>--benchmark-no-analysis</pre>
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1616) in Catch 2.9.0.
-
 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,6 +17,3 @@ 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)
- - [King](https://king.com)
- 

docs/configuration.md

@@ -16,7 +16,6 @@
 [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```).
 
@@ -128,12 +127,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_VARIANT              // Override std::variant support detection (checked by CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER)
-    CATCH_CONFIG_CPP17_OPTIONAL             // Override std::optional support detection (checked by CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER)
-    CATCH_CONFIG_CPP17_BYTE                 // Override std::byte support detection (Catch provides a StringMaker specialization by default)
-
-> `CATCH_CONFIG_CPP17_STRING_VIEW` was [introduced](https://github.com/catchorg/Catch2/issues/1376) in Catch 2.4.1.
+    CATCH_CONFIG_CPP17_STRING_VIEW          // Provide StringMaker specialization for std::string_view
+    CATCH_CONFIG_CPP17_VARIANT              // Override C++17 detection for CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
 
 Catch contains basic compiler/standard detection and attempts to use
 some C++17 features whenever appropriate. This automatic detection
@@ -156,10 +151,6 @@ by using `_NO_` in the macro, e.g. `CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS`.
     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
-
-> [`CATCH_CONFIG_ANDROID_LOGWRITE`](https://github.com/catchorg/Catch2/issues/1743) and [`CATCH_CONFIG_GLOBAL_NEXTAFTER`](https://github.com/catchorg/Catch2/pull/1739) were introduced in Catch 2.10.0
 
 Currently Catch enables `CATCH_CONFIG_WINDOWS_SEH` only when compiled with MSVC, because some versions of MinGW do not have the necessary Win32 API support.
 
@@ -218,14 +209,9 @@ By default, Catch does not stringify some types from the standard library. This
     CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER // Provide StringMaker specialization for std::optional (on C++17)
     CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS     // Defines all of the above
 
-> `CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER` was [introduced](https://github.com/catchorg/Catch2/issues/1380) in Catch 2.4.1.
-
-> `CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER` was [introduced](https://github.com/catchorg/Catch2/issues/1510) in Catch 2.6.0.
 
 ## Disabling exceptions
 
-> Introduced in Catch 2.4.0.
-
 By default, Catch2 uses exceptions to signal errors and to abort tests
 when an assertion from the `REQUIRE` family of assertions fails. We also
 provide an experimental support for disabling exceptions. Catch2 should
@@ -258,18 +244,6 @@ 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,202 +1,92 @@
 <a id="top"></a>
-# Contributing to Catch2
+# Contributing to Catch
 
 **Contents**<br>
-[Using Git(Hub)](#using-github)<br>
+[Branches](#branches)<br>
+[Directory structure](#directory-structure)<br>
 [Testing your changes](#testing-your-changes)<br>
-[Writing documentation](#writing-documentation)<br>
-[Writing code](#writing-code)<br>
-[CoC](#coc)<br>
+[Code constructs to watch out for](#code-constructs-to-watch-out-for)<br>
 
-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.
+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.
 
+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.
 
-This page covers some guidelines and helpful tips for contributing
-to the codebase itself.
+## Branches
 
-## Using Git(Hub)
+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.
 
-Ongoing development happens in the `master` branch for Catch2 v2, and in
-`dev-v3` for the next major version, v3.
+## Directory structure
 
-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.
+_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.
 
-_When submitting a pull request please do not include changes to the
-single include. This means do not include them in your git commits!_
+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.
 
+The other directories are `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
 
-_Note: Running Catch2's tests requires Python3_
+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.
 
+This means 2 things
 
-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 serve as a compilation test on the single-header distribution,
-and present a small and self-contained snippets of using Catch2 for
-writing tests. ExtraTests then are tests that either take a long time
-to run, or require separate compilation, e.g. because of testing compile
-time configuration options, and take a long time because of that.
-
-Both of these are compiled against the single-header distribution of
-Catch2, and thus might require you to regenerate it manually. This is
-done by calling the `generateSingleHeader.py` script in `scripts`.
-
-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 single header distribution
+* Compiling Catch's SelfTest project:
 ```
 $ cd Catch2
-$ ./scripts/generateSingleHeader.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 -Bdebug-build -H. -DCMAKE_BUILD_TYPE=Debug
 $ cmake --build debug-build
 ```
-4. Run the tests using CTest
+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:
 ```
 $ cd debug-build
-$ ctest -j 4 --output-on-failure -C Debug
+$ ctest -j 2 --output-on-failure
 ```
+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.
 
 
-## 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
-be replaced with the actual version upon release. There are 2 styles
-of placeholders used through the documentation, you should pick one that
-fits your text better (if in doubt, take a look at the existing version
-tags for other features).
-  * `> [Introduced](link-to-issue-or-PR) in Catch X.Y.Z` - this
-  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. a list
-
-* 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,
-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 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.
-
-
-### 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
+## 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
@@ -207,8 +97,7 @@ 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
@@ -216,12 +105,7 @@ there is no difference is wrong, QNX and VxWorks won't compile if you
 include the header as `<cfoo>` and call the function unqualified.
 
 
-## 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

@@ -39,39 +39,6 @@ apart from writing it out for `--list-tests -v high`.
 Because it isn't actually used nor documented, and brings complications
 to Catch2's internals, description support will be removed.
 
-### SourceLineInfo::empty()
-
-There should be no reason to ever have an empty `SourceLineInfo`, so the
-method will be removed.
-
-
-### Composing lvalues of already composed matchers
-
-Because a significant bug in this use case has persisted for 2+ years
-without a bug report, and to simplify the implementation, code that
-composes lvalues of composed matchers will not compile. That is,
-this code will no longer work:
-
-```cpp
-            auto m1 = Contains("string");
-            auto m2 = Contains("random");
-            auto composed1 = m1 || m2;
-            auto m3 = Contains("different");
-            auto composed2 = composed1 || m3;
-            REQUIRE_THAT(foo(), !composed1);
-            REQUIRE_THAT(foo(), composed2);
-```
-
-Instead you will have to write this:
-
-```cpp
-            auto m1 = Contains("string");
-            auto m2 = Contains("random");
-            auto m3 = Contains("different");
-            REQUIRE_THAT(foo(), !(m1 || m2));
-            REQUIRE_THAT(foo(), m1 || m2 || m3);
-```
-
 
 ## Planned changes
 
@@ -121,17 +88,6 @@ positively match a testspec.
 The API for Catch2's console colour will be changed to take an extra
 argument, the stream to which the colour code should be applied.
 
-
-### Type erasure in the `PredicateMatcher`
-
-Currently, the `PredicateMatcher` uses `std::function` for type erasure,
-so that type of the matcher is always `PredicateMatcher<T>`, regardless
-of the type of the predicate. Because of the high compilation overhead
-of `std::function`, and the fact that the type erasure is used only rarely,
-`PredicateMatcher` will no longer be type erased in the future. Instead,
-the predicate type will be made part of the PredicateMatcher's type.
-
-
 ---
 
 [Home](Readme.md#top)

docs/generators.md

@@ -1,8 +1,6 @@
 <a id="top"></a>
 # Data Generators
 
-> Introduced in Catch 2.6.0.
-
 Data generators (also known as _data driven/parametrized test cases_)
 let you reuse the same set of assertions across different input values.
 In Catch2, this means that they respect the ordering and nesting
@@ -12,88 +10,23 @@ are run once per each value in a generator.
 This is best explained with an example:
 ```cpp
 TEST_CASE("Generators") {
-    auto i = GENERATE(1, 3, 5);
-    REQUIRE(is_odd(i));
+    auto i = GENERATE(1, 2, 3);
+    SECTION("one") {
+        auto j = GENERATE( -3, -2, -1 );
+        REQUIRE(j < i);
+    }
 }
 ```
 
-The "Generators" `TEST_CASE` will be entered 3 times, and the value of
-`i` will be 1, 3, and 5 in turn. `GENERATE`s can also be used multiple
-times at the same scope, in which case the result will be a cartesian
-product of all elements in the generators. This means that in the snippet
-below, the test case will be run 6 (2\*3) times.
+The 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).
 
-```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).
-
-```
-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(j != 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 als obe 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,
@@ -101,8 +34,8 @@ Catch2's provided generator functionality consists of three parts,
 * `GENERATE` macro,  that serves to integrate generator expression with
 a test case,
 * 2 fundamental generators
-  * `SingleValueGenerator<T>` -- contains only single element
-  * `FixedValuesGenerator<T>` -- contains multiple elements
+  * `ValueGenerator<T>` -- contains only single element
+  * `ValuesGenerator<T>` -- contains multiple elements
 * 5 generic generators that modify other generators
   * `FilterGenerator<T, Predicate>` -- filters out elements from a generator
   for which the predicate returns "false"
@@ -111,22 +44,16 @@ a test case,
   * `MapGenerator<T, U, Func>` -- returns the result of applying `Func`
   on elements from a different generator
   * `ChunkGenerator<T>` -- returns chunks (inside `std::vector`) of n elements from a generator
-* 4 specific purpose generators
+* 3 specific purpose generators
   * `RandomIntegerGenerator<Integral>` -- generates random Integrals from range
   * `RandomFloatGenerator<Float>` -- generates random Floats from range
-  * `RangeGenerator<T>` -- generates all values inside an arithmetic range
-  * `IteratorGenerator<T>` -- copies and returns values from an iterator range
-
-> `ChunkGenerator<T>`, `RandomIntegerGenerator<Integral>`, `RandomFloatGenerator<Float>` and `RangeGenerator<T>` were introduced in Catch 2.7.0.
-
-> `IteratorGenerator<T>` was introduced in Catch 2.10.0.
+  * `RangeGenerator<T>` -- generates all values inside a specific range
 
 The generators also have associated helper functions that infer their
 type, making their usage much nicer. These are
 
-* `value(T&&)` for `SingleValueGenerator<T>`
-* `values(std::initializer_list<T>)` for `FixedValuesGenerator<T>`
-* `table<Ts...>(std::initializer_list<std::tuple<Ts...>>)` for `FixedValuesGenerator<std::tuple<Ts...>>`
+* `value(T&&)` for `ValueGenerator<T>`
+* `values(std::initializer_list<T>)` for `ValuesGenerator<T>`
 * `filter(predicate, GeneratorWrapper<T>&&)` for `FilterGenerator<T, Predicate>`
 * `take(count, GeneratorWrapper<T>&&)` for `TakeGenerator<T>`
 * `repeat(repeats, GeneratorWrapper<T>&&)` for `RepeatGenerator<T>`
@@ -134,16 +61,9 @@ type, making their usage much nicer. These are
 * `map<T>(func, GeneratorWrapper<U>&&)` for `MapGenerator<T, U, Func>` (map `U` to `T`)
 * `chunk(chunk-size, GeneratorWrapper<T>&&)` for `ChunkGenerator<T>`
 * `random(IntegerOrFloat a, IntegerOrFloat b)` for `RandomIntegerGenerator` or `RandomFloatGenerator`
-* `range(Arithemtic start, Arithmetic end)` for `RangeGenerator<Arithmetic>` with a step size of `1`
-* `range(Arithmetic start, Arithmetic end, Arithmetic step)` for `RangeGenerator<Arithmetic>` with a custom step size
-* `from_range(InputIterator from, InputIterator to)` for `IteratorGenerator<T>`
-* `from_range(Container const&)` for `IteratorGenerator<T>`
+* `range(start, end)` for `RangeGenerator<T>` with a step size of `1`
+* `range(start, end, step)` for `RangeGenerator<T>` with a custom step size
 
-> `chunk()`, `random()` and both `range()` functions were introduced in Catch 2.7.0.
-
-> `from_range` has been introduced in Catch 2.10.0
-
-> `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:
@@ -164,7 +84,7 @@ Apart from registering generators with Catch2, the `GENERATE` macro has
 one more purpose, and that is to provide simple way of generating trivial
 generators, as seen in the first example on this page, where we used it
 as `auto i = GENERATE(1, 2, 3);`. This usage converted each of the three
-literals into a single `SingleValueGenerator<int>` and then placed them all in
+literals into a single `ValueGenerator<int>` and then placed them all in
 a special generator that concatenates other generators. It can also be
 used with other generators as arguments, such as `auto i = GENERATE(0, 2,
 take(100, random(300, 3000)));`. This is useful e.g. if you know that
@@ -176,8 +96,6 @@ scope and thus capturing references is dangerous. If you need to use
 variables inside the generator expression, make sure you thought through
 the lifetime implications and use `GENERATE_COPY` or `GENERATE_REF`.**
 
-> `GENERATE_COPY` and `GENERATE_REF` were introduced in Catch 2.7.1.
-
 You can also override the inferred type by using `as<type>` as the first
 argument to the macro. This can be useful when dealing with string literals,
 if you want them to come out as `std::string`:

docs/limitations.md

@@ -45,15 +45,6 @@ the `REQUIRE` family of macros), Catch2 does not know that there are no
 more sections in that test case and must run the test case again.
 
 
-### MinGW/CygWin compilation (linking) is extremely slow
-
-Compiling Catch2 with MinGW can be exceedingly slow, especially during
-the linking step. As far as we can tell, this is caused by deficiencies
-in its default linker. If you can tell MinGW to instead use lld, via
-`-fuse-ld=lld`, the link time should drop down to reasonable length
-again.
-
-
 ## Features
 This section outlines some missing features, what is their status and their possible workarounds.
 

docs/list-of-examples.md

@@ -16,7 +16,6 @@
 - 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/logging.md

@@ -30,8 +30,6 @@ When the last `CHECK` fails in the "Bar" test case, then only one message will b
 
 ## Logging without local scope
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1522) in Catch 2.7.0.
-
 `UNSCOPED_INFO` is similar to `INFO` with two key differences:
 
 - Lifetime of an unscoped message is not tied to its own scope.
@@ -106,8 +104,6 @@ This semicolon will be removed with next major version. It is highly advised to
 
 **UNSCOPED_INFO(** _message expression_ **)**
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1522) in Catch 2.7.0.
-
 Similar to `INFO`, but messages are not limited to their own scope: They are removed from the buffer after each assertion, section or test case, whichever comes first.
 
 **WARN(** _message expression_ **)**

docs/matchers.md

@@ -12,57 +12,31 @@ The first argument is the thing (object or value) under test. The second part is
 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:
-
+ 
  ```c++
 using Catch::Matchers::EndsWith; // or Catch::EndsWith
 std::string str = getStringFromSomewhere();
-REQUIRE_THAT( str, EndsWith( "as a service" ) );
-```
+REQUIRE_THAT( str, EndsWith( "as a service" ) ); 
+ ```
 
 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 ) );
+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" ) ) );
+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:_
-
-```cpp
-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" ) );
-    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.
-
-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.
-
+Catch currently provides some matchers, they are in the `Catch::Matchers` and `Catch` namespaces.
 
 ### 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.
@@ -71,42 +45,13 @@ Each of the provided `std::string` matchers also takes an optional second argume
 
 
 ### Vector matchers
-Catch2 currently provides 5 built-in matchers that work on `std::vector`.
-These are
-
- * `Contains` which checks whether a specified vector is present in the result
- * `VectorContains` which checks whether a specified element is present in the result
- * `Equals` which checks whether the result is exactly equal (order matters) to a specific vector
- * `UnorderedEquals` which checks whether the result is equal to a specific vector under a permutation
- * `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.
-
+The vector matchers are `Contains`, `VectorContains` and `Equals`. `VectorContains` looks for a single element in the matched vector, `Contains` looks for a set (vector) of elements inside the matched vector.
 
 ### Floating point matchers
-Catch2 provides 3 matchers for working with floating point numbers. These
-are `WithinAbsMatcher`, `WithinUlpsMatcher` and `WithinRelMatcher`.
+The floating point matchers are `WithinULP` and `WithinAbs`. `WithinAbs` accepts floating point numbers that are within a certain margin of target. `WithinULP` performs an [ULP](https://en.wikipedia.org/wiki/Unit_in_the_last_place)-based comparison of two floating point numbers and accepts them if they are less than certain number of ULPs apart.
 
-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.
+Do note that ULP-based checks only make sense when both compared numbers are of the same type and `WithinULP` will use type of its argument as the target type. This means that `WithinULP(1.f, 1)` will expect to compare `float`s, but `WithinULP(1., 1)` will expect to compare `double`s.
 
-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.
-
-> `WithinRel` matcher was introduced in Catch 2.10.0
 
 ### Generic matchers
 Catch also aims to provide a set of generic matchers. Currently this set
@@ -127,29 +72,13 @@ The second argument is an optional description of the predicate, and is
 used only during reporting of the result.
 
 
-### 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 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
-
-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.
 
-You need to provide two things:
+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()`.
+override two methods: `match()` and `describe()`. 
 2. A simple builder function. This is what is actually called from the test code and allows overloading.
 
 Here's an example for asserting that an integer falls within a given range
@@ -194,7 +123,7 @@ TEST_CASE("Integers are within a range")
 ```
 
 Running this test gives the following in the console:
-
+ 
 ```
 /**/TestFile.cpp:123: FAILED:
   CHECK_THAT( 100, IsBetween( 1, 10 ) )

docs/opensource-users.md

@@ -20,21 +20,15 @@ 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.
 
@@ -56,6 +50,9 @@ Open source Oracle Tuxedo-like XATMI middleware for C and C++.
 ### [Inja](https://github.com/pantor/inja)
 A header-only template engine for modern C++.
 
+### [JSON for Modern C++](https://github.com/nlohmann/json)
+A, single-header, JSON parsing library that takes advantage of what C++ has to offer.
+
 ### [libcluon](https://github.com/chrberger/libcluon)
 A single-header-only library written in C++14 to glue distributed software components (UDP, TCP, shared memory) supporting natively Protobuf, LCM/ZCM, MsgPack, and JSON for dynamic message transformations in-between. 
 
@@ -68,6 +65,9 @@ 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,21 +77,18 @@ 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.
 
-### [SOCI](https://github.com/SOCI/soci)
-The C++ Database Access Library.
+### [thor](https://github.com/xorz57/thor)
+Wrapper Library for CUDA.
 
 ### [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)
@@ -106,9 +103,6 @@ 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).
 

docs/other-macros.md

@@ -59,8 +59,6 @@ TEST_CASE( "SUCCEED showcase" ) {
 
 * `STATIC_REQUIRE`
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1362) in Catch 2.4.2.
-
 `STATIC_REQUIRE( expr )` is a macro that can be used the same way as a
 `static_assert`, but also registers the success with Catch2, so it is
 reported as a success at runtime. The whole check can also be deferred
@@ -134,8 +132,6 @@ ANON_TEST_CASE() {
 
 * `DYNAMIC_SECTION`
 
-> Introduced in Catch 2.3.0.
-
 `DYNAMIC_SECTION` is a `SECTION` where the user can use `operator<<` to
 create the final name for that section. This can be useful with e.g.
 generators, or when creating a `SECTION` dynamically, within a loop.

docs/own-main.md

@@ -11,9 +11,9 @@ The easiest way to use Catch is to let it supply ```main()``` for you and handle
 
 This is achieved by writing ```#define CATCH_CONFIG_MAIN``` before the ```#include "catch.hpp"``` in *exactly one* source file.
 
-Sometimes, though, you need to write your own version of main(). You can do this by writing ```#define CATCH_CONFIG_RUNNER``` instead. Now you are free to write ```main()``` as normal and call into Catch yourself manually. You now have a lot of flexibility - but here are three recipes to get your started:
+Sometimes, though, you need to write your own version of main(). You can do this by writing ```#define CATCH_CONFIG_RUNNER``` instead. Now you are free to write ```main()``` as normal and call into Catch yourself manually.
 
-**Important note: you can only provide `main` in the same file you defined `CATCH_CONFIG_RUNNER`.**
+You now have a lot of flexibility - but here are three recipes to get your started:
 
 ## Let Catch take full control of args and config
 

docs/release-notes.md

@@ -2,20 +2,6 @@
 
 # Release notes
 **Contents**<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>
-[2.9.2](#292)<br>
 [2.9.1](#291)<br>
 [2.9.0](#290)<br>
 [2.8.0](#280)<br>
@@ -40,261 +26,6 @@
 [Older versions](#older-versions)<br>
 [Even Older versions](#even-older-versions)<br>
 
-## 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
-* Catch2 will now compile on platform where `INFINITY` is double (#1782)
-
-
-### Fixes
-* Warning suppressed during listener registration will no longer leak
-
-
-
-## 2.10.1
-
-### Improvements
-* Catch2 now guards itself against `min` and `max` macros from `windows.h` (#1772)
-* Templated tests will now compile with ICC (#1748)
-* `WithinULP` matcher now uses scientific notation for stringification (#1760)
-
-
-### Fixes
-* Templated tests no longer trigger `-Wunused-templates` (#1762)
-* Suppressed clang-analyzer false positive in context getter (#1230, #1735)
-
-
-### Miscellaneous
-* CMake no longer prohibits in-tree build when Catch2 is used as a subproject (#1773, #1774)
-
-
-
-## 2.10.0
-
-### Fixes
-* `TEMPLATE_LIST_TEST_CASE` now properly handles non-copyable and non-movable types (#1729)
-* Fixed compilation error on Solaris caused by a system header defining macro `TT` (#1722, #1723)
-* `REGISTER_ENUM` will now fail at compilation time if the registered enum is too large
-* Removed use of `std::is_same_v` in C++17 mode (#1757)
-* Fixed parsing of escaped special characters when reading test specs from a file (#1767, #1769)
-
-
-### Improvements
-* Trailing and leading whitespace in test/section specs are now ignored.
-* Writing to Android debug log now uses `__android_log_write` instead of `__android_log_print`
-* Android logging support can now be turned on/off at compile time (#1743)
-  * The toggle is `CATCH_CONFIG_ANDROID_LOGWRITE`
-* Added a generator that returns elements of a range
-  * Use via `from_range(from, to)` or `from_range(container)`
-* Added support for CRTs that do not provide `std::nextafter` (#1739)
-  * They must still provide global `nextafter{f,l,}`
-  * Enabled via `CATCH_CONFIG_GLOBAL_NEXTAFTER`
-* Special cased `Approx(inf)` not to match non-infinite values
-  * Very strictly speaking this might be a breaking change, but it should match user expectations better
-* The output of benchmarking through the Console reporter when `--benchmark-no-analysis` is set is now much simpler (#1768)
-* Added a matcher that can be used for checking an exceptions message (#1649, #1728)
-  * The matcher helper function is called `Message`
-  * The exception must publicly derive from `std::exception`
-  * The matching is done exactly, including case and whitespace
-* Added a matcher that can be used for checking relative equality of floating point numbers (#1746)
-  * Unlike `Approx`, it considers both sides when determining the allowed margin
-  * Special cases `NaN` and `INFINITY` to match user expectations
-  * The matcher helper function is called `WithinRel`
-* The ULP matcher now allows for any possible distance between the two numbers
-* The random number generators now use Catch-global instance of RNG (#1734, #1736)
-  * This means that nested random number generators actually generate different numbers
-
-
-### Miscellaneous
-* In-repo PNGs have been optimized to lower overhead of using Catch2 via git clone
-* Catch2 now uses its own implementation of the URBG concept
-  * In the future we also plan to use our own implementation of the distributions from `<random>` to provide cross-platform repeatability of random results
-
-
-
-## 2.9.2
-
-### Fixes
-* `ChunkGenerator` can now be used with chunks of size 0 (#1671)
-* Nested subsections are now run properly when specific section is run via the `-c` argument (#1670, #1673)
-* Catch2 now consistently uses `_WIN32` to detect Windows platform (#1676)
-* `TEMPLATE_LIST_TEST_CASE` now support non-default constructible type lists (#1697)
-* Fixed a crash in the XMLReporter when a benchmark throws exception during warmup (#1706)
-* Fixed a possible infinite loop in CompactReporter (#1715)
-* Fixed `-w NoTests` returning 0 even when no tests were matched (#1449, #1683, #1684)
-* Fixed matcher compilation under Obj-C++ (#1661)
-
-### Improvements
-* `RepeatGenerator` and `FixedValuesGenerator` now fail to compile when used with `bool` (#1692)
-  * Previously they would fail at runtime.
-* Catch2 now supports Android's debug logging for its debug output (#1710)
-* Catch2 now detects and configures itself for the RTX platform (#1693)
-  * You still need to pass `--benchmark-no-analysis` if you are using benchmarking under RTX
-* Removed a "storage class is not first" warning when compiling Catch2 with PGI compiler (#1717)
-
-### Miscellaneous
-* Documentation now contains indication when a specific feature was introduced (#1695)
-  * These start with Catch2 v2.3.0, (a bit over a year ago).
-  * `docs/contributing.md` has been updated to provide contributors guidance on how to add these to newly written documentation
-* Various other documentation improvements
-  * ToC fixes
-  * Documented `--order` and `--rng-seed` command line options
-  * Benchmarking documentation now clearly states that it requires opt-in
-  * Documented `CATCH_CONFIG_CPP17_OPTIONAL` and `CATCH_CONFIG_CPP17_BYTE` macros
-  * Properly documented built-in vector matchers
-  * Improved `*_THROWS_MATCHES` documentation a bit
-* CMake config file is now arch-independent even if `CMAKE_SIZEOF_VOID_P` is in CMake cache (#1660)
-* `CatchAddTests` now properly escapes `[` and `]` in test names (#1634, #1698)
-* Reverted `CatchAddTests` adding tags as CTest labels (#1658)
-  * The script broke when test names were too long
-  * Overwriting `LABELS` caused trouble for users who set them manually
-  * CMake does not let users append to `LABELS` if the test name has spaces
-
-
 ## 2.9.1
 
 ### Fixes
@@ -357,7 +88,7 @@
 
 ### Improvements
 * Reporters now print out the filters applied to test cases (#1550, #1585)
-* Added `GENERATE_COPY` and `GENERATE_REF` macros that can use variables inside the generator expression
+* Added `GENERATE_COPY` and `GENERATE_VAR` macros that can use variables inside the generator expression
   * Because of the significant danger of lifetime issues, the default `GENERATE` macro still does not allow variables
 * The `map` generator helper now deduces the mapped return type (#1576)
 

docs/release-process.md

@@ -42,8 +42,8 @@ Tag version and release title should be same as the new version,
 description should contain the release notes for the current release.
 Single header version of `catch.hpp` *needs* to be attached as a binary,
 as that is where the official download link links to. Preferably
-it should use linux line endings. All non-bundled reporters (Automake, TAP,
-TeamCity, SonarQube) should also be attached as binaries, as they might be
+it should use linux line endings. All non-bundled reporters (Automake,
+TAP, TeamCity) should also be attached as binaries, as they might be
 dependent on a specific version of the single-include header.
 
 Since 2.5.0, the release tag and the "binaries" (headers) should be PGP
@@ -67,7 +67,6 @@ $ gpg2 --armor --output catch.hpp.asc --detach-sig catch.hpp
 $ gpg2 --armor --output catch_reporter_automake.hpp.asc --detach-sig catch_reporter_automake.hpp
 $ gpg2 --armor --output catch_reporter_teamcity.hpp.asc --detach-sig catch_reporter_teamcity.hpp
 $ gpg2 --armor --output catch_reporter_tap.hpp.asc --detach-sig catch_reporter_tap.hpp
-$ gpg2 --armor --output catch_reporter_sonarqube.hpp.asc --detach-sig catch_reporter_sonarqube.hpp
 ```
 
 _GPG does not support signing multiple files in single invocation._

docs/reporters.md

@@ -29,7 +29,6 @@ Do this in one source file - the same one you have `CATCH_CONFIG_MAIN` or `CATCH
 Use this when building as part of a TeamCity build to see results as they happen ([code example](../examples/207-Rpt-TeamCityReporter.cpp)).
 * `tap` writes in the TAP ([Test Anything Protocol](https://en.wikipedia.org/wiki/Test_Anything_Protocol)) format.
 * `automake` writes in a format that correspond to [automake  .trs](https://www.gnu.org/software/automake/manual/html_node/Log-files-generation-and-test-results-recording.html) files
-* `sonarqube` writes the [SonarQube Generic Test Data](https://docs.sonarqube.org/latest/analysis/generic-test/) XML format.
 
 You see what reporters are available from the command line by running with `--list-reporters`.
 

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

@@ -84,13 +84,10 @@ This macro maps onto ```TEST_CASE``` and works in the same way, except that the
 
 These macros map onto ```SECTION```s except that the section names are the _something_s prefixed by "given: ", "when: " or "then: " respectively.
 
-* **AND_GIVEN(** _something_ **)**
 * **AND_WHEN(** _something_ **)**
 * **AND_THEN(** _something_ **)**
 
-Similar to ```GIVEN```, ```WHEN``` and ```THEN``` except that the prefixes start with "and ". These are used to chain ```GIVEN```s, ```WHEN```s and ```THEN```s together.
-
-> `AND_GIVEN` was [introduced](https://github.com/catchorg/Catch2/issues/1360) in Catch 2.4.0.
+Similar to ```WHEN``` and ```THEN``` except that the prefixes start with "and ". These are used to chain ```WHEN```s and ```THEN```s together.
 
 When any of these macros are used the console reporter recognises them and formats the test case header such that the Givens, Whens and Thens are aligned to aid readability.
 
@@ -104,8 +101,6 @@ by types, in the form of `TEMPLATE_TEST_CASE`,
 
 * **TEMPLATE_TEST_CASE(** _test name_ , _tags_,  _type1_, _type2_, ..., _typen_ **)**
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1437) in Catch 2.5.0.
-
 _test name_ and _tag_ are exactly the same as they are in `TEST_CASE`,
 with the difference that the tag string must be provided (however, it
 can be empty). _type1_ through _typen_ is the list of types for which
@@ -156,8 +151,6 @@ TEMPLATE_TEST_CASE( "vectors can be sized and resized", "[vector][template]", in
 
 * **TEMPLATE_PRODUCT_TEST_CASE(** _test name_ , _tags_, (_template-type1_, _template-type2_, ..., _template-typen_), (_template-arg1_, _template-arg2_, ..., _template-argm_) **)**
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1468) in Catch 2.6.0.
-
 _template-type1_ through _template-typen_ is list of template template
 types which should be combined with each of _template-arg1_ through
  _template-argm_, resulting in _n * m_ test cases. Inside the test case,
@@ -201,8 +194,6 @@ is very high and should not be encountered in practice._
 
 * **TEMPLATE_LIST_TEST_CASE(** _test name_, _tags_, _type list_ **)**
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1627) in Catch 2.9.0.
-
 _type list_ is a generic list of types on which test case should be instantiated.
 List can be `std::tuple`, `boost::mpl::list`, `boost::mp11::mp_list` or anything with
 `template <typename...>` signature.
@@ -221,8 +212,6 @@ TEMPLATE_LIST_TEST_CASE("Template test case with test types specified inside std
 
 ## Signature based parametrised test cases
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1609) in Catch 2.8.0.
-
 In addition to [type parametrised test cases](#type-parametrised-test-cases) Catch2 also supports
 signature base parametrised test cases, in form of `TEMPLATE_TEST_CASE_SIG` and `TEMPLATE_PRODUCT_TEST_CASE_SIG`.
 These test cases have similar syntax like [type parametrised test cases](#type-parametrised-test-cases), with one

docs/test-fixtures.md

@@ -1,8 +1,6 @@
 <a id="top"></a>
 # Test fixtures
 
-## Defining test fixtures
-
 Although Catch allows you to group tests together as sections within a test case, it can still be convenient, sometimes, to group them using a more traditional test fixture. Catch fully supports this too. You define the test fixture as a simple structure:
 
 ```c++
@@ -86,9 +84,6 @@ _While there is an upper limit on the number of types you can specify
 in single `TEMPLATE_TEST_CASE_METHOD` or `TEMPLATE_PRODUCT_TEST_CASE_METHOD`,
 the limit is very high and should not be encountered in practice._
 
-## Signature-based parametrised test fixtures
-
-> [Introduced](https://github.com/catchorg/Catch2/issues/1609) in Catch 2.8.0.
 
 Catch2 also provides `TEMPLATE_TEST_CASE_METHOD_SIG` and `TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG` to support
 fixtures using non-type template parameters. These test cases work similar to `TEMPLATE_TEST_CASE_METHOD` and `TEMPLATE_PRODUCT_TEST_CASE_METHOD`,
@@ -105,13 +100,6 @@ TEMPLATE_TEST_CASE_METHOD_SIG(Nttp_Fixture, "A TEMPLATE_TEST_CASE_METHOD_SIG bas
     REQUIRE(Nttp_Fixture<V>::value > 0);
 }
 
-template<typename T>
-struct Template_Fixture_2 {
-    Template_Fixture_2() {}
-
-    T m_a;
-};
-
 template< typename T, size_t V>
 struct Template_Foo_2 {
     size_t size() { return V; }
@@ -123,8 +111,6 @@ TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(Template_Fixture_2, "A TEMPLATE_PRODUCT_TE
 }
 ```
 
-## Template fixtures with types specified in template type lists
-
 Catch2 also provides `TEMPLATE_LIST_TEST_CASE_METHOD` to support template fixtures with types specified in
 template type lists like `std::tuple`, `boost::mpl::list` or `boost::mp11::mp_list`. This test case works the same as `TEMPLATE_TEST_CASE_METHOD`,
 only difference is the source of types. This allows you to reuse the template type list in multiple test cases.

docs/tostring.md

@@ -71,8 +71,6 @@ CATCH_TRANSLATE_EXCEPTION( MyType& ex ) {
 
 ## Enums
 
-> Introduced in Catch 2.8.0.
-
 Enums that already have a `<<` overload for `std::ostream` will convert to strings as expected.
 If you only need to convert enums to strings for test reporting purposes you can provide a `StringMaker` specialisations as any other type.
 However, as a convenience, Catch provides the `REGISTER_ENUM` helper macro that will generate the `StringMaker` specialiation for you with minimal code.
@@ -110,8 +108,6 @@ TEST_CASE() {
 
 ## Floating point precision
 
-> [Introduced](https://github.com/catchorg/Catch2/issues/1614) in Catch 2.8.0.
-
 Catch provides a built-in `StringMaker` specialization for both `float`
 and `double`. By default, it uses what we think is a reasonable precision,
 but you can customize it by modifying the `precision` static variable

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/210-Evt-EventListeners.cpp

@@ -24,7 +24,7 @@ std::string ws(int const level) {
 template< typename T >
 std::ostream& operator<<( std::ostream& os, std::vector<T> const& v ) {
     os << "{ ";
-    for ( const auto& x : v )
+    for ( auto x : v )
         os << x << ", ";
     return os << "}";
 }
@@ -57,7 +57,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 ( const auto& x : v )
+    for ( auto x : v )
     {
         os << ws(level+1) << "{\n";
         print( os, level+2, x );
@@ -300,7 +300,7 @@ char const * dashed_line =
 struct MyListener : Catch::TestEventListenerBase {
 
     using TestEventListenerBase::TestEventListenerBase; // inherit constructor
-
+    
     // Get rid of Wweak-tables
     ~MyListener();
 

examples/231-Cfg-OutputStreams.cpp

@@ -10,13 +10,12 @@
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 
-
 class out_buff : public std::stringbuf {
     std::FILE* m_stream;
 public:
-    out_buff(std::FILE* stream):m_stream(stream) {}
-    ~out_buff();
-    int sync() override {
+    out_buff(std::FILE* stream) :m_stream(stream) {}
+    ~out_buff() { pubsync(); }
+    int sync() {
         int ret = 0;
         for (unsigned char c : str()) {
             if (putc(c, m_stream) == EOF) {
@@ -30,12 +29,6 @@ public:
     }
 };
 
-out_buff::~out_buff() { pubsync(); }
-
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Wexit-time-destructors" // static variables in cout/cerr/clog
-#endif
-
 namespace Catch {
     std::ostream& cout() {
         static std::ostream ret(new out_buff(stdout));

examples/301-Gen-MapTypeConversion.cpp

@@ -1,9 +1,7 @@
 // 301-Gen-MapTypeConversion.cpp
 // Shows how to use map to modify generator's return type.
 
-// 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.
+// TODO
 
 #include <catch2/catch.hpp>
 
@@ -24,17 +22,15 @@ public:
         }
     }
 
-    std::string const& get() const override;
+    std::string const& get() const override {
+        return m_line;
+    }
     
     bool next() override {
         return !!std::getline(m_stream, m_line);
     }
 };
 
-std::string const& LineGenerator::get() const {
-    return m_line;
-}
-
 // This helper function provides a nicer UX when instantiating the generator
 // Notice that it returns an instance of GeneratorWrapper<std::string>, which
 // is a value-wrapper around std::unique_ptr<IGenerator<std::string>>.

examples/302-Gen-Table.cpp

@@ -1,54 +0,0 @@
-// 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.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/311-Gen-CustomCapture.cpp

@@ -23,11 +23,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( "custom capture generator", CATCH_INTERNAL_LINEINFO,
+    auto number = Catch::Generators::generate( 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

@@ -46,7 +46,6 @@ set( SOURCES_IDIOMATIC_TESTS
     210-Evt-EventListeners.cpp
     300-Gen-OwnGenerator.cpp
     301-Gen-MapTypeConversion.cpp
-    302-Gen-Table.cpp
     310-Gen-VariablesInGenerators.cpp
     311-Gen-CustomCapture.cpp
 )

include/catch.hpp

@@ -10,8 +10,8 @@
 #define TWOBLUECUBES_CATCH_HPP_INCLUDED
 
 #define CATCH_VERSION_MAJOR 2
-#define CATCH_VERSION_MINOR 13
-#define CATCH_VERSION_PATCH 0
+#define CATCH_VERSION_MINOR 9
+#define CATCH_VERSION_PATCH 1
 
 #ifdef __clang__
 #    pragma clang system_header
@@ -80,7 +80,7 @@
 #endif
 
 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-#include "internal/benchmark/catch_benchmarking_all.hpp"
+#include "internal/benchmark/catch_benchmark.hpp"
 #endif
 
 #endif // ! CATCH_CONFIG_IMPL_ONLY

include/external/clara.hpp

@@ -667,7 +667,7 @@ namespace detail {
     }
     inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
         std::string srcLC = source;
-        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( unsigned char c ) { return static_cast<char>( std::tolower(c) ); } );
+        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( std::tolower(c) ); } );
         if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
             target = true;
         else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")

include/internal/benchmark/catch_benchmark.hpp

@@ -44,10 +44,10 @@ namespace Catch {
             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)>(cfg.benchmarkWarmupTime()));
+                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(Detail::warmup_time));
                 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>>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
+                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FloatDuration<Clock>>(Detail::warmup_time), Detail::warmup_iterations };
             }
 
             template <typename Clock = default_clock>
@@ -79,7 +79,7 @@ namespace Catch {
                     });
 
                     auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
-                    BenchmarkStats<FloatDuration<Clock>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
+                    BenchmarkStats<std::chrono::duration<double, std::nano>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
                     getResultCapture().benchmarkEnded(stats);
 
                 } CATCH_CATCH_ALL{

include/internal/benchmark/catch_benchmarking_all.hpp

@@ -1,29 +0,0 @@
-/*
- *  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)
- */ 
-
-
-// A proxy header that includes all of the benchmarking headers to allow
-// concise include of the benchmarking features. You should prefer the
-// individual includes in standard use.
-
-#include "catch_benchmark.hpp"
-#include "catch_chronometer.hpp"
-#include "catch_clock.hpp"
-#include "catch_constructor.hpp"
-#include "catch_environment.hpp"
-#include "catch_estimate.hpp"
-#include "catch_execution_plan.hpp"
-#include "catch_optimizer.hpp"
-#include "catch_outlier_classification.hpp"
-#include "catch_sample_analysis.hpp"
-#include "detail/catch_analyse.hpp"
-#include "detail/catch_benchmark_function.hpp"
-#include "detail/catch_complete_invoke.hpp"
-#include "detail/catch_estimate_clock.hpp"
-#include "detail/catch_measure.hpp"
-#include "detail/catch_repeat.hpp"
-#include "detail/catch_run_for_at_least.hpp"
-#include "detail/catch_stats.hpp"
-#include "detail/catch_timing.hpp"

include/internal/benchmark/catch_constructor.hpp

@@ -14,66 +14,60 @@
 #include <type_traits>
 
 namespace Catch {
-    namespace Benchmark {
-        namespace Detail {
-            template <typename T, bool Destruct>
-            struct ObjectStorage
+    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)
             {
-                using TStorage = typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type;
+                new(&data) T(other.stored_object());
+            }
 
-                ObjectStorage() : data() {}
+            ObjectStorage(ObjectStorage&& other)
+            {
+                new(&data) T(std::move(other.stored_object()));
+            }
 
-                ObjectStorage(const ObjectStorage& other)
-                {
-                    new(&data) T(other.stored_object());
-                }
+            ~ObjectStorage() { destruct_on_exit<T>(); }
 
-                ObjectStorage(ObjectStorage&& other)
-                {
-                    new(&data) T(std::move(other.stored_object()));
-                }
+            template <typename... Args>
+            void construct(Args&&... args)
+            {
+                new (&data) T(std::forward<Args>(args)...);
+            }
 
-                ~ObjectStorage() { destruct_on_exit<T>(); }
+            template <bool AllowManualDestruction = !Destruct>
+            typename std::enable_if<AllowManualDestruction>::type destruct()
+            {
+                stored_object().~T();
+            }
 
-                template <typename... Args>
-                void construct(Args&&... args)
-                {
-                    new (&data) T(std::forward<Args>(args)...);
-                }
+        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 <bool AllowManualDestruction = !Destruct>
-                typename std::enable_if<AllowManualDestruction>::type destruct()
-                {
-                    stored_object().~T();
-                }
+            T& stored_object()
+            {
+                return *static_cast<T*>(static_cast<void*>(&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) { }
-
-                T& stored_object() {
-                    return *static_cast<T*>(static_cast<void*>(&data));
-                }
-
-                T const& stored_object() const {
-                    return *static_cast<T*>(static_cast<void*>(&data));
-                }
-
-
-                TStorage data;
-            };
-        }
-
-        template <typename T>
-        using storage_for = Detail::ObjectStorage<T, true>;
-
-        template <typename T>
-        using destructable_object = Detail::ObjectStorage<T, false>;
+            TStorage data;
+        };
     }
+
+    template <typename T>
+    using storage_for = Detail::ObjectStorage<T, true>;
+
+    template <typename T>
+    using destructable_object = Detail::ObjectStorage<T, false>;
 }
 
 #endif // TWOBLUECUBES_CATCH_CONSTRUCTOR_HPP_INCLUDED

include/internal/benchmark/detail/catch_complete_invoke.hpp

@@ -12,7 +12,6 @@
 #define TWOBLUECUBES_CATCH_DETAIL_COMPLETE_INVOKE_HPP_INCLUDED
 
 #include "../../catch_enforce.h"
-#include "../../catch_meta.hpp"
 
 #include <type_traits>
 #include <utility>
@@ -43,18 +42,20 @@ 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<FunctionReturnType<Fun, Args...>> complete_invoke(Fun&& fun, Args&&... args) {
-                return CompleteInvoker<FunctionReturnType<Fun, Args...>>::invoke(std::forward<Fun>(fun), std::forward<Args>(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)...);
             }
 
             const std::string benchmarkErrorMsg = "a benchmark failed to run successfully";
         } // namespace Detail
 
         template <typename Fun>
-        Detail::CompleteType_t<FunctionReturnType<Fun>> user_code(Fun&& fun) {
+        Detail::CompleteType_t<Detail::ResultOf_t<Fun()>> user_code(Fun&& fun) {
             CATCH_TRY{
                 return Detail::complete_invoke(std::forward<Fun>(fun));
             } CATCH_CATCH_ALL{

include/internal/benchmark/detail/catch_measure.hpp

@@ -21,7 +21,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();

include/internal/benchmark/detail/catch_run_for_at_least.hpp

@@ -25,11 +25,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));
 
@@ -46,7 +46,7 @@ namespace Catch {
             };
 
             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)>());

include/internal/benchmark/detail/catch_stats.cpp

@@ -176,10 +176,9 @@ namespace Catch {
 
 
             bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
-                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
                 CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
                 static std::random_device entropy;
-                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+                CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
 
                 auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
 

include/internal/benchmark/detail/catch_stats.hpp

@@ -18,13 +18,11 @@
 #include <algorithm>
 #include <functional>
 #include <vector>
-#include <iterator>
 #include <numeric>
 #include <tuple>
 #include <cmath>
 #include <utility>
 #include <cstddef>
-#include <random>
 
 namespace Catch {
     namespace Benchmark {

include/internal/benchmark/detail/catch_timing.hpp

@@ -25,8 +25,8 @@ namespace Catch {
             Result result;
             int iterations;
         };
-        template <typename Clock, typename Func, typename... Args>
-        using TimingOf = Timing<ClockDuration<Clock>, Detail::CompleteType_t<FunctionReturnType<Func, Args...>>>;
+        template <typename Clock, typename Sig>
+        using TimingOf = Timing<ClockDuration<Clock>, Detail::CompleteType_t<Detail::ResultOf_t<Sig>>>;
     } // namespace Benchmark
 } // namespace Catch
 

include/internal/catch_approx.cpp

@@ -52,8 +52,7 @@ namespace Detail {
     bool Approx::equalityComparisonImpl(const double other) const {
         // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
         // Thanks to Richard Harris for his help refining the scaled margin value
-        return marginComparison(m_value, other, m_margin)
-            || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
+        return marginComparison(m_value, other, m_margin) || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(m_value)));
     }
 
     void Approx::setMargin(double newMargin) {

include/internal/catch_assertionhandler.cpp

@@ -15,7 +15,6 @@
 #include "catch_interfaces_registry_hub.h"
 #include "catch_capture_matchers.h"
 #include "catch_run_context.h"
-#include "catch_enforce.h"
 
 namespace Catch {
 

include/internal/catch_assertionresult.cpp

@@ -45,7 +45,7 @@ namespace Catch {
     }
 
     bool AssertionResult::hasExpression() const {
-        return !m_info.capturedExpression.empty();
+        return m_info.capturedExpression[0] != 0;
     }
 
     bool AssertionResult::hasMessage() const {
@@ -53,22 +53,16 @@ namespace Catch {
     }
 
     std::string AssertionResult::getExpression() const {
-        // Possibly overallocating by 3 characters should be basically free
-        std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
-        if (isFalseTest(m_info.resultDisposition)) {
-            expr += "!(";
-        }
-        expr += m_info.capturedExpression;
-        if (isFalseTest(m_info.resultDisposition)) {
-            expr += ')';
-        }
-        return expr;
+        if( isFalseTest( m_info.resultDisposition ) )
+            return "!(" + m_info.capturedExpression + ")";
+        else
+            return m_info.capturedExpression;
     }
 
     std::string AssertionResult::getExpressionInMacro() const {
         std::string expr;
-        if( m_info.macroName.empty() )
-            expr = static_cast<std::string>(m_info.capturedExpression);
+        if( m_info.macroName[0] == 0 )
+            expr = m_info.capturedExpression;
         else {
             expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
             expr += m_info.macroName;

include/internal/catch_capture.hpp

@@ -41,17 +41,15 @@
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
     do { \
-        /* The expression should not be evaluated, but warnings should hopefully be checked */ \
-        CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
         Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
         INTERNAL_CATCH_TRY { \
-            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
             CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
             catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); \
-            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+            CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
         } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
         INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( (void)0, (false) && static_cast<bool>( !!(__VA_ARGS__) ) )
+    } while( (void)0, (false) && static_cast<bool>( !!(__VA_ARGS__) ) ) // the expression here is never evaluated at runtime but it forces the compiler to give it a look
+    // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
 
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \

include/internal/catch_capture_matchers.h

@@ -10,7 +10,6 @@
 
 #include "catch_capture.hpp"
 #include "catch_matchers.h"
-#include "catch_matchers_exception.hpp"
 #include "catch_matchers_floating.h"
 #include "catch_matchers_generic.hpp"
 #include "catch_matchers_string.h"

include/internal/catch_commandline.cpp

@@ -49,14 +49,9 @@ namespace Catch {
                     if( !line.empty() && !startsWith( line, '#' ) ) {
                         if( !startsWith( line, '"' ) )
                             line = '"' + line + '"';
-                        config.testsOrTags.push_back( line );
-                        config.testsOrTags.emplace_back( "," );
+                        config.testsOrTags.push_back( line + ',' );
                     }
                 }
-                //Remove comma in the end
-                if(!config.testsOrTags.empty())
-                    config.testsOrTags.erase( config.testsOrTags.end()-1 );
-
                 return ParserResult::ok( ParseResultType::Matched );
             };
         auto const setTestOrder = [&]( std::string const& order ) {
@@ -91,16 +86,14 @@ namespace Catch {
             };
         auto const setWaitForKeypress = [&]( std::string const& keypress ) {
                 auto keypressLc = toLower( keypress );
-                if (keypressLc == "never")
-                    config.waitForKeypress = WaitForKeypress::Never;
-                else if( keypressLc == "start" )
+                if( keypressLc == "start" )
                     config.waitForKeypress = WaitForKeypress::BeforeStart;
                 else if( keypressLc == "exit" )
                     config.waitForKeypress = WaitForKeypress::BeforeExit;
                 else if( keypressLc == "both" )
                     config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
                 else
-                    return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" );
+                    return ParserResult::runtimeError( "keypress argument must be one of: start, exit or both. '" + keypress + "' not recognised" );
             return ParserResult::ok( ParseResultType::Matched );
             };
         auto const setVerbosity = [&]( std::string const& verbosity ) {
@@ -170,9 +163,6 @@ namespace Catch {
             | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
                 ["-d"]["--durations"]
                 ( "show test durations" )
-            | Opt( config.minDuration, "seconds" )
-                ["-D"]["--min-duration"]
-                ( "show test durations for tests taking at least the given number of seconds" )
             | Opt( loadTestNamesFromFile, "filename" )
                 ["-f"]["--input-file"]
                 ( "load test names to run from a file" )
@@ -203,7 +193,7 @@ namespace Catch {
             | Opt( config.libIdentify )
                 ["--libidentify"]
                 ( "report name and version according to libidentify standard" )
-            | Opt( setWaitForKeypress, "never|start|exit|both" )
+            | Opt( setWaitForKeypress, "start|exit|both" )
                 ["--wait-for-keypress"]
                 ( "waits for a keypress before exiting" )
             | Opt( config.benchmarkSamples, "samples" )
@@ -218,10 +208,7 @@ namespace Catch {
             | Opt( config.benchmarkNoAnalysis )
                 ["--benchmark-no-analysis"]
                 ( "perform only measurements; do not perform any analysis" )
-            | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" )
-                ["--benchmark-warmup-time"]
-                ( "amount of time in milliseconds spent on warming up each test (default: 100)" )
-            | Arg( config.testsOrTags, "test name|pattern|tags" )
+			| Arg( config.testsOrTags, "test name|pattern|tags" )
                 ( "which test or tests to use" );
 
         return cli;

include/internal/catch_common.cpp

@@ -15,6 +15,9 @@
 
 namespace Catch {
 
+    bool SourceLineInfo::empty() const noexcept {
+        return file[0] == '\0';
+    }
     bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
         return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
     }

include/internal/catch_common.h

@@ -57,7 +57,7 @@ namespace Catch {
         SourceLineInfo( SourceLineInfo&& )              noexcept = default;
         SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
 
-        bool empty() const noexcept { return file[0] == '\0'; }
+        bool empty() const noexcept;
         bool operator == ( SourceLineInfo const& other ) const noexcept;
         bool operator < ( SourceLineInfo const& other ) const noexcept;
 

include/internal/catch_compiler_capabilities.h

@@ -39,56 +39,36 @@
 
 #endif
 
-#if defined(__cpp_lib_uncaught_exceptions)
+#if defined(CATCH_CPP17_OR_GREATER)
 #  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
 #endif
 
-// We have to avoid both ICC and Clang, because they try to mask themselves
-// as gcc, and we want only GCC in this block
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC)
-#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
-#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "GCC diagnostic pop" )
+#ifdef __clang__
 
-#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
+#       define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+            _Pragma( "clang diagnostic push" ) \
+            _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
+            _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
+#       define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
+            _Pragma( "clang diagnostic pop" )
 
-#endif
+#       define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+            _Pragma( "clang diagnostic push" ) \
+            _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
+#       define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
+            _Pragma( "clang diagnostic pop" )
 
-#if defined(__clang__)
+#       define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+            _Pragma( "clang diagnostic push" ) \
+            _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
+#       define CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS \
+            _Pragma( "clang diagnostic pop" )
 
-#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
-#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )
-
-// As of this writing, IBM XL's implementation of __builtin_constant_p has a bug
-// which results in calls to destructors being emitted for each temporary,
-// without a matching initialization. In practice, this can result in something
-// like `std::string::~string` being called on an uninitialized value.
-//
-// For example, this code will likely segfault under IBM XL:
-// ```
-// REQUIRE(std::string("12") + "34" == "1234")
-// ```
-//
-// Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented.
-#  if !defined(__ibmxl__)
-#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */
-#  endif
-
-
-#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
-         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
-
-#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
-
-#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
-         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
+#       define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+            _Pragma( "clang diagnostic push" ) \
+            _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
+#       define CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS \
+            _Pragma( "clang diagnostic pop" )
 
 #endif // __clang__
 
@@ -114,7 +94,6 @@
 // Android somehow still does not support std::to_string
 #if defined(__ANDROID__)
 #    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
-#    define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -136,7 +115,7 @@
 // Required for some versions of Cygwin to declare gettimeofday
 // see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
 #   define _BSD_SOURCE
-// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
+// some versions of cygwin (most) do not support std::to_string. Use the libstd check. 
 // https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
 # if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
            && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
@@ -148,10 +127,8 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // Visual C++
-#if defined(_MSC_VER)
+#ifdef _MSC_VER
 
-#  define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )
-#  define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  __pragma( warning(pop) )
 
 #  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
 #    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
@@ -168,12 +145,9 @@
 // MSVC traditional preprocessor needs some workaround for __VA_ARGS__
 // _MSVC_TRADITIONAL == 0 means new conformant preprocessor
 // _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
-#  if !defined(__clang__) // Handle Clang masquerading for msvc
-#    if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
-#      define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#    endif // MSVC_TRADITIONAL
-#  endif // __clang__
-
+#  if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
+#    define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#  endif
 #endif // _MSC_VER
 
 #if defined(_REENTRANT) || defined(_MSC_VER)
@@ -210,55 +184,49 @@
     #define CATCH_INTERNAL_CONFIG_COUNTER
 #endif
 
+////////////////////////////////////////////////////////////////////////////////
+// Check if string_view is available and usable
+// The check is split apart to work around v140 (VS2015) preprocessor issue...
+#if defined(__has_include)
+#if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
+#    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
+#endif
+#endif
 
 ////////////////////////////////////////////////////////////////////////////////
-
-// RTX is a special version of Windows that is real time.
-// This means that it is detected as Windows, but does not provide
-// the same set of capabilities as real Windows does.
-#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
-    #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
-    #define CATCH_INTERNAL_CONFIG_NO_ASYNC
-    #define CATCH_CONFIG_COLOUR_NONE
-#endif
-
-#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
-#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
-#endif
-
-// Various stdlib support checks that require __has_include
+// Check if optional is available and usable
 #if defined(__has_include)
-  // Check if string_view is available and usable
-  #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
-  #endif
+#  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+#    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
+#  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+#endif // __has_include
 
-  // Check if optional is available and usable
-  #  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
-  #  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+////////////////////////////////////////////////////////////////////////////////
+// Check if byte is available and usable
+#if defined(__has_include)
+#  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+#    define CATCH_INTERNAL_CONFIG_CPP17_BYTE
+#  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+#endif // __has_include
 
-  // Check if byte is available and usable
-  #  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
-  #    define CATCH_INTERNAL_CONFIG_CPP17_BYTE
-  #  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
-
-  // Check if variant is available and usable
-  #  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
-  #    if defined(__clang__) && (__clang_major__ < 8)
-         // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
-         // fix should be in clang 8, workaround in libstdc++ 8.2
-  #      include <ciso646>
-  #      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
-  #        define CATCH_CONFIG_NO_CPP17_VARIANT
-  #      else
-  #        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
-  #      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
-  #    else
-  #      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
-  #    endif // defined(__clang__) && (__clang_major__ < 8)
-  #  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
-#endif // defined(__has_include)
+////////////////////////////////////////////////////////////////////////////////
+// Check if variant is available and usable
+#if defined(__has_include)
+#  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+#    if defined(__clang__) && (__clang_major__ < 8)
+       // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
+       // fix should be in clang 8, workaround in libstdc++ 8.2
+#      include <ciso646>
+#      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+#        define CATCH_CONFIG_NO_CPP17_VARIANT
+#      else
+#        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+#      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+#    else
+#      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+#    endif // defined(__clang__) && (__clang_major__ < 8)
+#  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+#endif // __has_include
 
 
 #if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
@@ -317,54 +285,25 @@
 #  define CATCH_CONFIG_POLYFILL_ISNAN
 #endif
 
-#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
+#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
 #  define CATCH_CONFIG_USE_ASYNC
 #endif
 
-#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE)
-#  define CATCH_CONFIG_ANDROID_LOGWRITE
-#endif
-
-#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
-#  define CATCH_CONFIG_GLOBAL_NEXTAFTER
-#endif
-
-
-// Even if we do not think the compiler has that warning, we still have
-// to provide a macro that can be used by the code.
-#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
-#   define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
-#endif
-#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
-#   define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-#endif
 #if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
 #   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
+#   define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS
 #endif
 #if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
 #   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+#   define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
 #endif
 #if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)
 #   define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
+#   define CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS
 #endif
 #if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
 #   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
-#endif
-
-// The goal of this macro is to avoid evaluation of the arguments, but
-// still have the compiler warn on problems inside...
-#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
-#   define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
-#endif
-
-#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
-#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#elif defined(__clang__) && (__clang_major__ < 5)
-#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#endif
-
-#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#   define CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS
 #endif
 
 #if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)

include/internal/catch_config.cpp

@@ -15,23 +15,11 @@ namespace Catch {
     :   m_data( data ),
         m_stream( openStream() )
     {
-        // We need to trim filter specs to avoid trouble with superfluous
-        // whitespace (esp. important for bdd macros, as those are manually
-        // aligned with whitespace).
-
-        for (auto& elem : m_data.testsOrTags) {
-            elem = trim(elem);
-        }
-        for (auto& elem : m_data.sectionsToRun) {
-            elem = trim(elem);
-        }
-
         TestSpecParser parser(ITagAliasRegistry::get());
-        if (!m_data.testsOrTags.empty()) {
+        if (!data.testsOrTags.empty()) {
             m_hasTestFilters = true;
-            for (auto const& testOrTags : m_data.testsOrTags) {
-                parser.parse(testOrTags);
-            }
+            for( auto const& testOrTags : data.testsOrTags )
+                parser.parse( testOrTags );
         }
         m_testSpec = parser.testSpec();
     }
@@ -44,7 +32,7 @@ namespace Catch {
     bool Config::listTestNamesOnly() const  { return m_data.listTestNamesOnly; }
     bool Config::listTags() const           { return m_data.listTags; }
     bool Config::listReporters() const      { return m_data.listReporters; }
-
+	
     std::string Config::getProcessName() const { return m_data.processName; }
     std::string const& Config::getReporterName() const { return m_data.reporterName; }
 
@@ -64,7 +52,6 @@ namespace Catch {
     bool Config::warnAboutMissingAssertions() const    { return !!(m_data.warnings & WarnAbout::NoAssertions); }
     bool Config::warnAboutNoTests() const              { return !!(m_data.warnings & WarnAbout::NoTests); }
     ShowDurations::OrNot Config::showDurations() const { return m_data.showDurations; }
-    double Config::minDuration() const                 { return m_data.minDuration; }
     RunTests::InWhatOrder Config::runOrder() const     { return m_data.runOrder; }
     unsigned int Config::rngSeed() const               { return m_data.rngSeed; }
     UseColour::YesOrNo Config::useColour() const       { return m_data.useColour; }
@@ -73,11 +60,10 @@ namespace Catch {
     bool Config::showInvisibles() const                { return m_data.showInvisibles; }
     Verbosity Config::verbosity() const                { return m_data.verbosity; }
 
-    bool Config::benchmarkNoAnalysis() const                      { return m_data.benchmarkNoAnalysis; }
-    int Config::benchmarkSamples() const                          { return m_data.benchmarkSamples; }
-    double Config::benchmarkConfidenceInterval() const            { return m_data.benchmarkConfidenceInterval; }
-    unsigned int Config::benchmarkResamples() const               { return m_data.benchmarkResamples; }
-    std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
+    bool Config::benchmarkNoAnalysis() const           { return m_data.benchmarkNoAnalysis; }
+    int Config::benchmarkSamples() const               { return m_data.benchmarkSamples; }
+    double Config::benchmarkConfidenceInterval() const { return m_data.benchmarkConfidenceInterval; }
+    unsigned int Config::benchmarkResamples() const    { return m_data.benchmarkResamples; }
 
     IStream const* Config::openStream() {
         return Catch::makeStream(m_data.outputFilename);

include/internal/catch_config.hpp

@@ -47,12 +47,10 @@ namespace Catch {
         unsigned int benchmarkSamples = 100;
         double benchmarkConfidenceInterval = 0.95;
         unsigned int benchmarkResamples = 100000;
-        std::chrono::milliseconds::rep benchmarkWarmupTime = 100;
 
         Verbosity verbosity = Verbosity::Normal;
         WarnAbout::What warnings = WarnAbout::Nothing;
         ShowDurations::OrNot showDurations = ShowDurations::DefaultForReporter;
-        double minDuration = -1;
         RunTests::InWhatOrder runOrder = RunTests::InDeclarationOrder;
         UseColour::YesOrNo useColour = UseColour::Auto;
         WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
@@ -104,7 +102,6 @@ namespace Catch {
         bool warnAboutMissingAssertions() const override;
         bool warnAboutNoTests() const override;
         ShowDurations::OrNot showDurations() const override;
-        double minDuration() const override;
         RunTests::InWhatOrder runOrder() const override;
         unsigned int rngSeed() const override;
         UseColour::YesOrNo useColour() const override;
@@ -116,7 +113,6 @@ namespace Catch {
         int benchmarkSamples() const override;
         double benchmarkConfidenceInterval() const override;
         unsigned int benchmarkResamples() const override;
-        std::chrono::milliseconds benchmarkWarmupTime() const override;
 
     private:
 

include/internal/catch_console_colour.cpp

@@ -34,7 +34,7 @@ namespace Catch {
         };
 
         struct NoColourImpl : IColourImpl {
-            void use( Colour::Code ) override {}
+            void use( Colour::Code ) {}
 
             static IColourImpl* instance() {
                 static NoColourImpl s_instance;
@@ -167,7 +167,7 @@ namespace {
 
     bool useColourOnPlatform() {
         return
-#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
+#ifdef CATCH_PLATFORM_MAC
             !isDebuggerActive() &&
 #endif
 #if !(defined(__DJGPP__) && defined(__STRICT_ANSI__))
@@ -208,13 +208,13 @@ namespace Catch {
 namespace Catch {
 
     Colour::Colour( Code _colourCode ) { use( _colourCode ); }
-    Colour::Colour( Colour&& other ) noexcept {
-        m_moved = other.m_moved;
-        other.m_moved = true;
+    Colour::Colour( Colour&& rhs ) noexcept {
+        m_moved = rhs.m_moved;
+        rhs.m_moved = true;
     }
-    Colour& Colour::operator=( Colour&& other ) noexcept {
-        m_moved = other.m_moved;
-        other.m_moved  = true;
+    Colour& Colour::operator=( Colour&& rhs ) noexcept {
+        m_moved = rhs.m_moved;
+        rhs.m_moved  = true;
         return *this;
     }
 
@@ -226,7 +226,7 @@ namespace Catch {
         // However, under some conditions it does happen (see #1626),
         // and this change is small enough that we can let practicality
         // triumph over purity in this case.
-        if (impl != nullptr) {
+        if (impl != NULL) {
             impl->use( _colourCode );
         }
     }

include/internal/catch_context.cpp

@@ -7,7 +7,6 @@
  */
 #include "catch_context.h"
 #include "catch_common.h"
-#include "catch_random_number_generator.h"
 
 namespace Catch {
 
@@ -60,11 +59,4 @@ namespace Catch {
     IContext::~IContext() = default;
     IMutableContext::~IMutableContext() = default;
     Context::~Context() = default;
-
-
-    SimplePcg32& rng() {
-        static SimplePcg32 s_rng;
-        return s_rng;
-    }
-
 }

include/internal/catch_context.h

@@ -46,7 +46,6 @@ namespace Catch {
     {
         if( !IMutableContext::currentContext )
             IMutableContext::createContext();
-        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
         return *IMutableContext::currentContext;
     }
 
@@ -56,9 +55,6 @@ namespace Catch {
     }
 
     void cleanUpContext();
-
-    class SimplePcg32;
-    SimplePcg32& rng();
 }
 
 #endif // TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED

include/internal/catch_debug_console.cpp

@@ -7,21 +7,11 @@
  */
 
 #include "catch_debug_console.h"
-#include "catch_compiler_capabilities.h"
 #include "catch_stream.h"
 #include "catch_platform.h"
 #include "catch_windows_h_proxy.h"
 
-#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
-#include <android/log.h>
-
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
-        }
-    }
-
-#elif defined(CATCH_PLATFORM_WINDOWS)
+#ifdef CATCH_PLATFORM_WINDOWS
 
     namespace Catch {
         void writeToDebugConsole( std::string const& text ) {

include/internal/catch_debugger.cpp

@@ -12,9 +12,10 @@
 #include "catch_stream.h"
 #include "catch_platform.h"
 
-#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
+#ifdef CATCH_PLATFORM_MAC
 
-#  include <cassert>
+#  include <assert.h>
+#  include <stdbool.h>
 #  include <sys/types.h>
 #  include <unistd.h>
 #  include <cstddef>

include/internal/catch_debugger.h

@@ -17,24 +17,7 @@ namespace Catch {
 
 #ifdef CATCH_PLATFORM_MAC
 
-    #if defined(__i386__) || defined(__x86_64__)
-        #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
-    #elif defined(__aarch64__)
-        #define CATCH_TRAP()  __asm__(".inst 0xd4200000")
-    #endif
-
-#elif defined(CATCH_PLATFORM_IPHONE)
-
-    // use inline assembler
-    #if defined(__i386__) || defined(__x86_64__)
-        #define CATCH_TRAP()  __asm__("int $3")
-    #elif defined(__aarch64__)
-        #define CATCH_TRAP()  __asm__(".inst 0xd4200000")
-    #elif defined(__arm__) && !defined(__thumb__)
-        #define CATCH_TRAP()  __asm__(".inst 0xe7f001f0")
-    #elif defined(__arm__) &&  defined(__thumb__)
-        #define CATCH_TRAP()  __asm__(".inst 0xde01")
-    #endif
+    #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
 
 #elif defined(CATCH_PLATFORM_LINUX)
     // If we can use inline assembler, do it because this allows us to break
@@ -54,12 +37,10 @@ namespace Catch {
     #define CATCH_TRAP() DebugBreak()
 #endif
 
-#ifndef CATCH_BREAK_INTO_DEBUGGER
-    #ifdef CATCH_TRAP
-        #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
-    #else
-        #define CATCH_BREAK_INTO_DEBUGGER() []{}()
-    #endif
+#ifdef CATCH_TRAP
+    #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
+#else
+    #define CATCH_BREAK_INTO_DEBUGGER() []{}()
 #endif
 
 #endif // TWOBLUECUBES_CATCH_DEBUGGER_H_INCLUDED

include/internal/catch_decomposer.h

@@ -200,18 +200,6 @@ namespace Catch {
         auto operator <= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
             return { static_cast<bool>(m_lhs <= rhs), m_lhs, "<=", rhs };
         }
-        template <typename RhsT>
-        auto operator | (RhsT const& rhs) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs | rhs), m_lhs, "|", rhs };
-        }
-        template <typename RhsT>
-        auto operator & (RhsT const& rhs) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs & rhs), m_lhs, "&", rhs };
-        }
-        template <typename RhsT>
-        auto operator ^ (RhsT const& rhs) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs ^ rhs), m_lhs, "^", rhs };
-        }
 
         template<typename RhsT>
         auto operator && ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {

include/internal/catch_default_main.hpp

@@ -9,11 +9,10 @@
 #define TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED
 
 #include "catch_session.h"
-#include "catch_platform.h"
 
 #ifndef __OBJC__
 
-#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
+#if defined(CATCH_CONFIG_WCHAR) && defined(WIN32) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
 // Standard C/C++ Win32 Unicode wmain entry point
 extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) {
 #else

include/internal/catch_enforce.h

@@ -38,13 +38,13 @@ namespace Catch {
     (Catch::ReusableStringStream() << __VA_ARGS__).str()
 
 #define CATCH_INTERNAL_ERROR(...) \
-    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))
+    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__));
 
 #define CATCH_ERROR(...) \
-    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
+    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ));
 
 #define CATCH_RUNTIME_ERROR(...) \
-    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
+    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ));
 
 #define CATCH_ENFORCE( condition, ... ) \
     do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)

include/internal/catch_enum_values_registry.cpp

@@ -18,25 +18,13 @@ namespace Catch {
 
     namespace Detail {
 
-        namespace {
-            // Extracts the actual name part of an enum instance
-            // In other words, it returns the Blue part of Bikeshed::Colour::Blue
-            StringRef extractInstanceName(StringRef enumInstance) {
-                // Find last occurence of ":"
-                size_t name_start = enumInstance.size();
-                while (name_start > 0 && enumInstance[name_start - 1] != ':') {
-                    --name_start;
-                }
-                return enumInstance.substr(name_start, enumInstance.size() - name_start);
-            }
-        }
-
-        std::vector<StringRef> parseEnums( StringRef enums ) {
+        std::vector<std::string> parseEnums( StringRef enums ) {
             auto enumValues = splitStringRef( enums, ',' );
-            std::vector<StringRef> parsed;
+            std::vector<std::string> parsed;
             parsed.reserve( enumValues.size() );
             for( auto const& enumValue : enumValues ) {
-                parsed.push_back(trim(extractInstanceName(enumValue)));
+                auto identifiers = splitStringRef( enumValue, ':' );
+                parsed.push_back( Catch::trim( identifiers.back() ) );
             }
             return parsed;
         }
@@ -48,7 +36,7 @@ namespace Catch {
                 if( valueToName.first == value )
                     return valueToName.second;
             }
-            return "{** unexpected enum value **}"_sr;
+            return "{** unexpected enum value **}";
         }
 
         std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
@@ -60,14 +48,16 @@ namespace Catch {
             assert( valueNames.size() == values.size() );
             std::size_t i = 0;
             for( auto value : values )
-                enumInfo->m_values.emplace_back(value, valueNames[i++]);
+                enumInfo->m_values.push_back({ value, valueNames[i++] });
 
             return enumInfo;
         }
 
         EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
-            m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
-            return *m_enumInfos.back();
+            auto enumInfo = makeEnumInfo( enumName, allValueNames, values );
+            EnumInfo* raw = enumInfo.get();
+            m_enumInfos.push_back( std::move( enumInfo ) );
+            return *raw;
         }
 
     } // Detail

include/internal/catch_enum_values_registry.h

@@ -26,7 +26,7 @@ namespace Catch {
             EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values) override;
         };
 
-        std::vector<StringRef> parseEnums( StringRef enums );
+        std::vector<std::string> parseEnums( StringRef enums );
 
     } // Detail
 

include/internal/catch_fatal_condition.cpp

@@ -97,7 +97,7 @@ namespace Catch {
     
     // 32kb for the alternate stack seems to be sufficient. However, this value
     // is experimentally determined, so that's not guaranteed.
-    static constexpr std::size_t sigStackSize = 32768 >= MINSIGSTKSZ ? 32768 : MINSIGSTKSZ;
+    constexpr static std::size_t sigStackSize = 32768 >= MINSIGSTKSZ ? 32768 : MINSIGSTKSZ;
 
     static SignalDefs signalDefs[] = {
         { SIGINT,  "SIGINT - Terminal interrupt signal" },

include/internal/catch_generators.cpp

@@ -24,8 +24,8 @@ namespace Generators {
 
     GeneratorUntypedBase::~GeneratorUntypedBase() {}
 
-    auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
-        return getResultCapture().acquireGeneratorTracker( generatorName, lineInfo );
+    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+        return getResultCapture().acquireGeneratorTracker( lineInfo );
     }
 
 } // namespace Generators

include/internal/catch_generators.hpp

@@ -10,7 +10,6 @@
 #include "catch_interfaces_generatortracker.h"
 #include "catch_common.h"
 #include "catch_enforce.h"
-#include "catch_stringref.h"
 
 #include <memory>
 #include <vector>
@@ -58,6 +57,7 @@ namespace Generators {
     class SingleValueGenerator final : public IGenerator<T> {
         T m_value;
     public:
+        SingleValueGenerator(T const& value) : m_value( value ) {}
         SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
 
         T const& get() const override {
@@ -71,7 +71,7 @@ namespace Generators {
     template<typename T>
     class FixedValuesGenerator final : public IGenerator<T> {
         static_assert(!std::is_same<T, bool>::value,
-            "FixedValuesGenerator does not support bools because of std::vector<bool>"
+            "ValuesGenerator does not support bools because of std::vector<bool>"
             "specialization, use SingleValue Generator instead.");
         std::vector<T> m_values;
         size_t m_idx = 0;
@@ -120,21 +120,21 @@ namespace Generators {
             m_generators.emplace_back(std::move(generator));
         }
         void populate(T&& val) {
-            m_generators.emplace_back(value(std::forward<T>(val)));
+            m_generators.emplace_back(value(std::move(val)));
         }
         template<typename U>
         void populate(U&& val) {
-            populate(T(std::forward<U>(val)));
+            populate(T(std::move(val)));
         }
         template<typename U, typename... Gs>
-        void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
+        void populate(U&& valueOrGenerator, Gs... moreGenerators) {
             populate(std::forward<U>(valueOrGenerator));
             populate(std::forward<Gs>(moreGenerators)...);
         }
 
     public:
         template <typename... Gs>
-        Generators(Gs &&... moreGenerators) {
+        Generators(Gs... moreGenerators) {
             m_generators.reserve(sizeof...(Gs));
             populate(std::forward<Gs>(moreGenerators)...);
         }
@@ -166,7 +166,7 @@ namespace Generators {
     struct as {};
 
     template<typename T, typename... Gs>
-    auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreGenerators ) -> Generators<T> {
+    auto makeGenerators( GeneratorWrapper<T>&& generator, Gs... moreGenerators ) -> Generators<T> {
         return Generators<T>(std::move(generator), std::forward<Gs>(moreGenerators)...);
     }
     template<typename T>
@@ -174,24 +174,24 @@ namespace Generators {
         return Generators<T>(std::move(generator));
     }
     template<typename T, typename... Gs>
-    auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generators<T> {
+    auto makeGenerators( T&& val, Gs... moreGenerators ) -> Generators<T> {
         return makeGenerators( value( std::forward<T>( val ) ), std::forward<Gs>( moreGenerators )... );
     }
     template<typename T, typename U, typename... Gs>
-    auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Generators<T> {
+    auto makeGenerators( as<T>, U&& val, Gs... moreGenerators ) -> Generators<T> {
         return makeGenerators( value( T( std::forward<U>( val ) ) ), std::forward<Gs>( moreGenerators )... );
     }
 
-    auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker&;
+    auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker&;
 
     template<typename L>
     // Note: The type after -> is weird, because VS2015 cannot parse
     //       the expression used in the typedef inside, when it is in
     //       return type. Yeah.
-    auto generate( StringRef generatorName, SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>().get()) {
+    auto generate( SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>().get()) {
         using UnderlyingType = typename decltype(generatorExpression())::type;
 
-        IGeneratorTracker& tracker = acquireGeneratorTracker( generatorName, lineInfo );
+        IGeneratorTracker& tracker = acquireGeneratorTracker( lineInfo );
         if (!tracker.hasGenerator()) {
             tracker.setGenerator(pf::make_unique<Generators<UnderlyingType>>(generatorExpression()));
         }
@@ -204,16 +204,10 @@ namespace Generators {
 } // namespace Catch
 
 #define GENERATE( ... ) \
-    Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
-                                 CATCH_INTERNAL_LINEINFO, \
-                                 [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } )
 #define GENERATE_COPY( ... ) \
-    Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
-                                 CATCH_INTERNAL_LINEINFO, \
-                                 [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } )
 #define GENERATE_REF( ... ) \
-    Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
-                                 CATCH_INTERNAL_LINEINFO, \
-                                 [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } )
 
 #endif // TWOBLUECUBES_CATCH_GENERATORS_HPP_INCLUDED

include/internal/catch_generators_generic.hpp

@@ -8,7 +8,6 @@
 #define TWOBLUECUBES_CATCH_GENERATORS_GENERIC_HPP_INCLUDED
 
 #include "catch_generators.hpp"
-#include "catch_meta.hpp"
 
 namespace Catch {
 namespace Generators {
@@ -173,7 +172,18 @@ namespace Generators {
         }
     };
 
-    template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
+#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
+    // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
+    // replaced with std::invoke_result here. Also *_t format is preferred over
+    // typename *::type format.
+    template <typename Func, typename U>
+    using MapFunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U>>>;
+#else
+    template <typename Func, typename U>
+    using MapFunctionReturnType = typename std::remove_reference<typename std::remove_cv<typename std::result_of<Func(U)>::type>::type>::type;
+#endif
+
+    template <typename Func, typename U, typename T = MapFunctionReturnType<Func, U>>
     GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
         return GeneratorWrapper<T>(
             pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))

include/internal/catch_generators_specific.hpp

@@ -10,7 +10,6 @@
 #include "catch_context.h"
 #include "catch_generators.hpp"
 #include "catch_interfaces_config.h"
-#include "catch_random_number_generator.h"
 
 #include <random>
 
@@ -19,13 +18,14 @@ namespace Generators {
 
 template <typename Float>
 class RandomFloatingGenerator final : public IGenerator<Float> {
-    Catch::SimplePcg32& m_rng;
+    // FIXME: What is the right seed?
+    std::minstd_rand m_rand;
     std::uniform_real_distribution<Float> m_dist;
     Float m_current_number;
 public:
 
     RandomFloatingGenerator(Float a, Float b):
-        m_rng(rng()),
+        m_rand(getCurrentContext().getConfig()->rngSeed()),
         m_dist(a, b) {
         static_cast<void>(next());
     }
@@ -34,20 +34,20 @@ public:
         return m_current_number;
     }
     bool next() override {
-        m_current_number = m_dist(m_rng);
+        m_current_number = m_dist(m_rand);
         return true;
     }
 };
 
 template <typename Integer>
 class RandomIntegerGenerator final : public IGenerator<Integer> {
-    Catch::SimplePcg32& m_rng;
+    std::minstd_rand m_rand;
     std::uniform_int_distribution<Integer> m_dist;
     Integer m_current_number;
 public:
 
     RandomIntegerGenerator(Integer a, Integer b):
-        m_rng(rng()),
+        m_rand(getCurrentContext().getConfig()->rngSeed()),
         m_dist(a, b) {
         static_cast<void>(next());
     }
@@ -56,7 +56,7 @@ public:
         return m_current_number;
     }
     bool next() override {
-        m_current_number = m_dist(m_rng);
+        m_current_number = m_dist(m_rand);
         return true;
     }
 };
@@ -117,7 +117,7 @@ public:
 
 template <typename T>
 GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
-    static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
+    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
     return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end, step));
 }
 
@@ -128,46 +128,6 @@ GeneratorWrapper<T> range(T const& start, T const& end) {
 }
 
 
-template <typename T>
-class IteratorGenerator final : public IGenerator<T> {
-    static_assert(!std::is_same<T, bool>::value,
-        "IteratorGenerator currently does not support bools"
-        "because of std::vector<bool> specialization");
-
-    std::vector<T> m_elems;
-    size_t m_current = 0;
-public:
-    template <typename InputIterator, typename InputSentinel>
-    IteratorGenerator(InputIterator first, InputSentinel last):m_elems(first, last) {
-        if (m_elems.empty()) {
-            Catch::throw_exception(GeneratorException("IteratorGenerator received no valid values"));
-        }
-    }
-
-    T const& get() const override {
-        return m_elems[m_current];
-    }
-
-    bool next() override {
-        ++m_current;
-        return m_current != m_elems.size();
-    }
-};
-
-template <typename InputIterator,
-          typename InputSentinel,
-          typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
-GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
-    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(from, to));
-}
-
-template <typename Container,
-          typename ResultType = typename Container::value_type>
-GeneratorWrapper<ResultType> from_range(Container const& cnt) {
-    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(cnt.begin(), cnt.end()));
-}
-
-
 } // namespace Generators
 } // namespace Catch
 

include/internal/catch_interfaces_capture.h

@@ -44,7 +44,7 @@ namespace Catch {
         virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
         virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
 
-        virtual auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;
+        virtual auto acquireGeneratorTracker( SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;
 
 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
         virtual void benchmarkPreparing( std::string const& name ) = 0;

include/internal/catch_interfaces_config.cpp

@@ -1,4 +1,4 @@
-#include "catch_interfaces_config.h"
+#include "internal/catch_interfaces_config.h"
 
 namespace Catch {
     IConfig::~IConfig() = default;

include/internal/catch_interfaces_config.h

@@ -11,7 +11,6 @@
 #include "catch_common.h"
 #include "catch_option.hpp"
 
-#include <chrono>
 #include <iosfwd>
 #include <string>
 #include <vector>
@@ -69,7 +68,6 @@ namespace Catch {
         virtual int abortAfter() const = 0;
         virtual bool showInvisibles() const = 0;
         virtual ShowDurations::OrNot showDurations() const = 0;
-        virtual double minDuration() const = 0;
         virtual TestSpec const& testSpec() const = 0;
         virtual bool hasTestFilters() const = 0;
         virtual std::vector<std::string> const& getTestsOrTags() const = 0;
@@ -83,7 +81,6 @@ namespace Catch {
         virtual int benchmarkSamples() const = 0;
         virtual double benchmarkConfidenceInterval() const = 0;
         virtual unsigned int benchmarkResamples() const = 0;
-        virtual std::chrono::milliseconds benchmarkWarmupTime() const = 0;
     };
 
     using IConfigPtr = std::shared_ptr<IConfig const>;

include/internal/catch_interfaces_enum_values_registry.h

@@ -17,7 +17,7 @@ namespace Catch {
     namespace Detail {
         struct EnumInfo {
             StringRef m_name;
-            std::vector<std::pair<int, StringRef>> m_values;
+            std::vector<std::pair<int, std::string>> m_values;
 
             ~EnumInfo();
 
@@ -32,7 +32,6 @@ namespace Catch {
 
         template<typename E>
         Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
-            static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
             std::vector<int> intValues;
             intValues.reserve( values.size() );
             for( auto enumValue : values )

include/internal/catch_interfaces_exception.cpp

@@ -1,4 +1,4 @@
-#include "catch_interfaces_exception.h"
+#include "internal/catch_interfaces_exception.h"
 
 namespace Catch {
     IExceptionTranslator::~IExceptionTranslator() = default;

include/internal/catch_interfaces_exception.h

@@ -46,9 +46,6 @@ namespace Catch {
             {}
 
             std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
-#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
-                return "";
-#else
                 try {
                     if( it == itEnd )
                         std::rethrow_exception(std::current_exception());
@@ -58,7 +55,6 @@ namespace Catch {
                 catch( T& ex ) {
                     return m_translateFunction( ex );
                 }
-#endif
             }
 
         protected:
@@ -77,10 +73,9 @@ namespace Catch {
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
     static std::string translatorName( signature ); \
-    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
     CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
     namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
-    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
     static std::string translatorName( signature )
 
 #define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )

include/internal/catch_interfaces_registry_hub.cpp

@@ -1,4 +1,4 @@
-#include "catch_interfaces_registry_hub.h"
+#include "internal/catch_interfaces_registry_hub.h"
 
 namespace Catch {
     IRegistryHub::~IRegistryHub() = default;

include/internal/catch_interfaces_reporter.h

@@ -214,8 +214,6 @@ namespace Catch {
 
         virtual void noMatchingTestCases( std::string const& spec ) = 0;
 
-        virtual void reportInvalidArguments(std::string const&) {}
-        
         virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
         virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
 

include/internal/catch_interfaces_runner.cpp

@@ -1,4 +1,4 @@
-#include "catch_interfaces_runner.h"
+#include "internal/catch_interfaces_runner.h"
 
 namespace Catch {
     IRunner::~IRunner() = default;

include/internal/catch_interfaces_testcase.cpp

@@ -1,4 +1,4 @@
-#include "catch_interfaces_testcase.h"
+#include "internal/catch_interfaces_testcase.h"
 
 namespace Catch {
     ITestInvoker::~ITestInvoker() = default;

include/internal/catch_interfaces_testcase.h

@@ -28,7 +28,6 @@ namespace Catch {
         virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
     };
 
-    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
     bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
     std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
     std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );

include/internal/catch_list.cpp

@@ -28,7 +28,7 @@
 namespace Catch {
 
     std::size_t listTests( Config const& config ) {
-        TestSpec const& testSpec = config.testSpec();
+        TestSpec testSpec = config.testSpec();
         if( config.hasTestFilters() )
             Catch::cout() << "Matching test cases:\n";
         else {
@@ -62,7 +62,7 @@ namespace Catch {
     }
 
     std::size_t listTestsNamesOnly( Config const& config ) {
-        TestSpec const& testSpec = config.testSpec();
+        TestSpec testSpec = config.testSpec();
         std::size_t matchedTests = 0;
         std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
         for( auto const& testCaseInfo : matchedTestCases ) {
@@ -84,23 +84,14 @@ namespace Catch {
     }
 
     std::string TagInfo::all() const {
-        size_t size = 0;
-        for (auto const& spelling : spellings) {
-            // Add 2 for the brackes
-            size += spelling.size() + 2;
-        }
-
-        std::string out; out.reserve(size);
-        for (auto const& spelling : spellings) {
-            out += '[';
-            out += spelling;
-            out += ']';
-        }
+        std::string out;
+        for( auto const& spelling : spellings )
+            out += "[" + spelling + "]";
         return out;
     }
 
     std::size_t listTags( Config const& config ) {
-        TestSpec const& testSpec = config.testSpec();
+        TestSpec testSpec = config.testSpec();
         if( config.hasTestFilters() )
             Catch::cout() << "Tags for matching test cases:\n";
         else {

include/internal/catch_matchers.h

@@ -44,15 +44,6 @@ namespace Matchers {
             virtual bool match( ObjectT const& arg ) const = 0;
         };
 
-#if defined(__OBJC__)
-        // Hack to fix Catch GH issue #1661. Could use id for generic Object support.
-        // use of const for Object pointers is very uncommon and under ARC it causes some kind of signature mismatch that breaks compilation
-        template<>
-        struct MatcherMethod<NSString*> {
-            virtual bool match( NSString* arg ) const = 0;
-        };
-#endif
-
 #ifdef __clang__
 #    pragma clang diagnostic pop
 #endif
@@ -91,10 +82,9 @@ namespace Matchers {
                 return description;
             }
 
-            MatchAllOf<ArgT> operator && ( MatcherBase<ArgT> const& other ) {
-                auto copy(*this);
-                copy.m_matchers.push_back( &other );
-                return copy;
+            MatchAllOf<ArgT>& operator && ( MatcherBase<ArgT> const& other ) {
+                m_matchers.push_back( &other );
+                return *this;
             }
 
             std::vector<MatcherBase<ArgT> const*> m_matchers;
@@ -125,10 +115,9 @@ namespace Matchers {
                 return description;
             }
 
-            MatchAnyOf<ArgT> operator || ( MatcherBase<ArgT> const& other ) {
-                auto copy(*this);
-                copy.m_matchers.push_back( &other );
-                return copy;
+            MatchAnyOf<ArgT>& operator || ( MatcherBase<ArgT> const& other ) {
+                m_matchers.push_back( &other );
+                return *this;
             }
 
             std::vector<MatcherBase<ArgT> const*> m_matchers;