v2.11.2

Move all scripts to Python3
Update wandbox script to use https endpoint and Python3
2020-03-19 12:37:51 +01:00 · 2020-03-19 12:36:30 +01:00 · 2020-03-19 12:32:34 +01:00 · 2020-03-19 11:08:01 +01:00 · 2020-03-19 11:08:01 +01:00 · 2020-03-19 09:45:41 +01:00
85 changed files with 1951 additions and 1445 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -14,7 +14,7 @@ if (CMAKE_BINARY_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
 endif()


-project(Catch2 LANGUAGES CXX VERSION 2.10.2)
+project(Catch2 LANGUAGES CXX VERSION 2.11.2)

 # Provide path for scripts
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/CMake")
--- a/README.md
+++ b/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/LzYWgcPrcy9yQmed)
+[![Try online](https://img.shields.io/badge/try-online-blue.svg)](https://wandbox.org/permlink/ZI5SYb7JE1UJhAKP)
 [![Join the chat in Discord: https://discord.gg/4CWS9zD](https://img.shields.io/badge/Discord-Chat!-brightgreen.svg)](https://discord.gg/4CWS9zD)


-<a href="https://github.com/catchorg/Catch2/releases/download/v2.10.2/catch.hpp">The latest version of the single header can be downloaded directly using this link</a>
+<a href="https://github.com/catchorg/Catch2/releases/download/v2.11.2/catch.hpp">The latest version of the single header can be downloaded directly using this link</a>

 ## Catch2 is released!

--- a/appveyor.yml
+++ b/appveyor.yml
@ -1,6 +1,11 @@
 # 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.+/
@ -62,7 +67,7 @@ matrix:


 install:
-  - 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" ) { 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.
--- a/docs/Readme.md
+++ b/docs/Readme.md
@ -35,6 +35,7 @@ FAQ:
 Other:
 * [Why Catch?](why-catch.md#top)
 * [Open Source Projects using Catch](opensource-users.md#top)
+* [Commercial Projects using Catch](commercial-users.md#top)
 * [Contributing](contributing.md#top)
 * [Release Notes](release-notes.md#top)
 * [Deprecations and incoming changes](deprecations.md#top)
--- a/docs/benchmarks.md
+++ b/docs/benchmarks.md
@ -168,7 +168,7 @@ Note that it is not possible to simply use the same instance for different runs
 and resetting it between each run since that would pollute the measurements with
 the resetting code.

-It is also possible to just provide an argument name to the simple `BENCHMARK` macro to get 
+It is also possible to just provide an argument name to the simple `BENCHMARK` macro to get
 the same semantics as providing a callable to `meter.measure` with `int` argument:

 ```c++
@ -189,19 +189,17 @@ construct and destroy objects without dynamic allocation and in a way that lets
 you measure construction and destruction separately.

 ```c++
-BENCHMARK_ADVANCED("construct")(Catch::Benchmark::Chronometer meter)
-{
+BENCHMARK_ADVANCED("construct")(Catch::Benchmark::Chronometer meter) {
    std::vector<Catch::Benchmark::storage_for<std::string>> storage(meter.runs());
    meter.measure([&](int i) { storage[i].construct("thing"); });
-})
+};

-BENCHMARK_ADVANCED("destroy", [](Catch::Benchmark::Chronometer meter)
-{
+BENCHMARK_ADVANCED("destroy")(Catch::Benchmark::Chronometer meter) {
    std::vector<Catch::Benchmark::destructable_object<std::string>> storage(meter.runs());
    for(auto&& o : storage)
        o.construct("thing");
    meter.measure([&](int i) { storage[i].destruct(); });
-})
+};
 ```

 `Catch::Benchmark::storage_for<T>` objects are just pieces of raw storage suitable for `T`
--- a/docs/command-line.md
+++ b/docs/command-line.md
@ -24,6 +24,7 @@
 [Specify the number of resamples for bootstrapping](#specify-the-number-of-resamples-for-bootstrapping)<br>
 [Specify the confidence-interval for bootstrapping](#specify-the-confidence-interval-for-bootstrapping)<br>
 [Disable statistical analysis of collected benchmark samples](#disable-statistical-analysis-of-collected-benchmark-samples)<br>
+[Specify the amount of time in milliseconds spent on warming up each test](#specify-the-amount-of-time-in-milliseconds-spent-on-warming-up-each-test)<br>
 [Usage](#usage)<br>
 [Specify the section to run](#specify-the-section-to-run)<br>
 [Filenames as tags](#filenames-as-tags)<br>
@ -64,6 +65,7 @@ Click one of the following links to take you straight to that option - or scroll
 <a href="#benchmark-resamples">                         `    --benchmark-resamples`</a><br />
 <a href="#benchmark-confidence-interval">               `    --benchmark-confidence-interval`</a><br />
 <a href="#benchmark-no-analysis">                       `    --benchmark-no-analysis`</a><br />
+<a href="#benchmark-warmup-time">                       `    --benchmark-warmup-time`</a><br />
 <a href="#use-colour">                                  `    --use-colour`</a><br />

 </br>
@ -269,7 +271,7 @@ See [The LibIdentify repo for more information and examples](https://github.com/

 <a id="wait-for-keypress"></a>
 ## Wait for key before continuing
-<pre>--wait-for-keypress &lt;start|exit|both&gt;</pre>
+<pre>--wait-for-keypress &lt;never|start|exit|both&gt;</pre>

 Will cause the executable to print a message and wait until the return/ enter key is pressed before continuing -
 either before running any tests, after running all tests - or both, depending on the argument.
@ -317,6 +319,14 @@ Must be between 0 and 1 and defaults to 0.95.
 When this flag is specified no bootstrapping or any other statistical analysis is performed.
 Instead the user code is only measured and the plain mean from the samples is reported.

+<a id="benchmark-warmup-time"></a>
+## Specify the amount of time in milliseconds spent on warming up each test
+<pre>--benchmark-warmup-time</pre>
+
+> [Introduced](https://github.com/catchorg/Catch2/pull/1844) in Catch 2.11.2.
+
+Configure the amount of time spent warming up each test.
+
 <a id="usage"></a>
 ## Usage
 <pre>-h, -?, --help</pre>
--- a/docs/commercial-users.md
+++ b/docs/commercial-users.md
@ -17,4 +17,6 @@ fact then please let us know - either directly, via a PR or
 - NASA
 - [Inscopix Inc.](https://www.inscopix.com/)
 - [Makimo](https://makimo.pl/)
- - [UX3D] (https://ux3d.io)
+ - [UX3D](https://ux3d.io)
+ - [King](https://king.com)
+ 
--- a/docs/configuration.md
+++ b/docs/configuration.md
@ -16,6 +16,7 @@
 [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```).

@ -257,6 +258,18 @@ namespace Catch {
 }
 ```

+## Overriding Catch's debug break (`-b`)
+
+> [Introduced](https://github.com/catchorg/Catch2/pull/1846) in Catch 2.11.2.
+
+You can override Catch2's break-into-debugger code by defining the
+`CATCH_BREAK_INTO_DEBUGGER()` macro. This can be used if e.g. Catch2 does
+not know your platform, or your platform is misdetected.
+
+The macro will be used as is, that is, `CATCH_BREAK_INTO_DEBUGGER();`
+must compile and must break into debugger.
+
+
 ---

 [Home](Readme.md#top)
--- a/docs/deprecations.md
+++ b/docs/deprecations.md
@ -45,6 +45,34 @@ 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


--- a/docs/generators.md
+++ b/docs/generators.md
@ -78,7 +78,7 @@ type, making their usage much nicer. These are

 > `from_range` has been introduced in Catch 2.10.0

-> `range()` for floating point numbers has been introduced in Catch X.Y.Z
+> `range()` for floating point numbers has been introduced in Catch 2.11.0

 And can be used as shown in the example below to create a generator
 that returns 100 odd random number:
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@ -2,6 +2,9 @@

 # Release notes
 **Contents**<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>
@ -31,6 +34,61 @@
 [Even Older versions](#even-older-versions)<br>


+## 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
--- a/docs/release-process.md
+++ b/docs/release-process.md
@ -67,6 +67,7 @@ $ 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._
--- a/docs/slow-compiles.md
+++ b/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`:
--- a/docs/tutorial.md
+++ b/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.

--- a/examples/210-Evt-EventListeners.cpp
+++ b/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 ( auto x : v )
+    for ( const 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 ( auto x : v )
+    for ( const 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();

--- a/examples/231-Cfg-OutputStreams.cpp
+++ b/examples/231-Cfg-OutputStreams.cpp
@ -10,12 +10,13 @@
 #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() { pubsync(); }
-    int sync() {
+    out_buff(std::FILE* stream):m_stream(stream) {}
+    ~out_buff();
+    int sync() override {
        int ret = 0;
        for (unsigned char c : str()) {
            if (putc(c, m_stream) == EOF) {
@ -29,6 +30,12 @@ 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));
--- a/examples/301-Gen-MapTypeConversion.cpp
+++ b/examples/301-Gen-MapTypeConversion.cpp
@ -22,15 +22,17 @@ public:
        }
    }

-    std::string const& get() const override {
-        return m_line;
-    }
+    std::string const& get() const override;
    
    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>>.
--- a/include/catch.hpp
+++ b/include/catch.hpp
@ -10,7 +10,7 @@
 #define TWOBLUECUBES_CATCH_HPP_INCLUDED

 #define CATCH_VERSION_MAJOR 2
-#define CATCH_VERSION_MINOR 10
+#define CATCH_VERSION_MINOR 11
 #define CATCH_VERSION_PATCH 2

 #ifdef __clang__
@ -80,7 +80,7 @@
 #endif

 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
-#include "internal/benchmark/catch_benchmark.hpp"
+#include "internal/benchmark/catch_benchmarking_all.hpp"
 #endif

 #endif // ! CATCH_CONFIG_IMPL_ONLY
--- a/include/internal/benchmark/catch_benchmark.hpp
+++ b/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)>(Detail::warmup_time));
+                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
                auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(run_time), 1, fun);
                int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
-                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FloatDuration<Clock>>(Detail::warmup_time), Detail::warmup_iterations };
+                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FloatDuration<Clock>>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
            }

            template <typename Clock = default_clock>
@ -79,7 +79,7 @@ namespace Catch {
                    });

                    auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
-                    BenchmarkStats<std::chrono::duration<double, std::nano>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
+                    BenchmarkStats<FloatDuration<Clock>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
                    getResultCapture().benchmarkEnded(stats);

                } CATCH_CATCH_ALL{
--- a/include/internal/benchmark/catch_benchmarking_all.hpp
+++ b/include/internal/benchmark/catch_benchmarking_all.hpp
@ -0,0 +1,29 @@
+/*
+ *  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"
--- a/include/internal/benchmark/catch_constructor.hpp
+++ b/include/internal/benchmark/catch_constructor.hpp
@ -14,60 +14,66 @@
 #include <type_traits>

 namespace Catch {
-    namespace Detail {
-        template <typename T, bool Destruct>
-        struct ObjectStorage
-        {
-            using TStorage = typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type;
-
-            ObjectStorage() : data() {}
-
-            ObjectStorage(const ObjectStorage& other)
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T, bool Destruct>
+            struct ObjectStorage
            {
-                new(&data) T(other.stored_object());
-            }
+                using TStorage = typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type;

-            ObjectStorage(ObjectStorage&& other)
-            {
-                new(&data) T(std::move(other.stored_object()));
-            }
+                ObjectStorage() : data() {}

-            ~ObjectStorage() { destruct_on_exit<T>(); }
+                ObjectStorage(const ObjectStorage& other)
+                {
+                    new(&data) T(other.stored_object());
+                }

-            template <typename... Args>
-            void construct(Args&&... args)
-            {
-                new (&data) T(std::forward<Args>(args)...);
-            }
+                ObjectStorage(ObjectStorage&& other)
+                {
+                    new(&data) T(std::move(other.stored_object()));
+                }

-            template <bool AllowManualDestruction = !Destruct>
-            typename std::enable_if<AllowManualDestruction>::type destruct()
-            {
-                stored_object().~T();
-            }
+                ~ObjectStorage() { destruct_on_exit<T>(); }

-        private:
-            // If this is a constructor benchmark, destruct the underlying object
-            template <typename U>
-            void destruct_on_exit(typename std::enable_if<Destruct, U>::type* = 0) { destruct<true>(); }
-            // Otherwise, don't
-            template <typename U>
-            void destruct_on_exit(typename std::enable_if<!Destruct, U>::type* = 0) { }
+                template <typename... Args>
+                void construct(Args&&... args)
+                {
+                    new (&data) T(std::forward<Args>(args)...);
+                }

-            T& stored_object()
-            {
-                return *static_cast<T*>(static_cast<void*>(&data));
-            }
+                template <bool AllowManualDestruction = !Destruct>
+                typename std::enable_if<AllowManualDestruction>::type destruct()
+                {
+                    stored_object().~T();
+                }

-            TStorage data;
-        };
+            private:
+                // If this is a constructor benchmark, destruct the underlying object
+                template <typename U>
+                void destruct_on_exit(typename std::enable_if<Destruct, U>::type* = 0) { destruct<true>(); }
+                // Otherwise, don't
+                template <typename U>
+                void destruct_on_exit(typename std::enable_if<!Destruct, U>::type* = 0) { }
+
+                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>;
    }
-
-    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
--- a/include/internal/benchmark/detail/catch_stats.hpp
+++ b/include/internal/benchmark/detail/catch_stats.hpp
@ -18,11 +18,13 @@
 #include <algorithm>
 #include <functional>
 #include <vector>
+#include <iterator>
 #include <numeric>
 #include <tuple>
 #include <cmath>
 #include <utility>
 #include <cstddef>
+#include <random>

 namespace Catch {
    namespace Benchmark {
--- a/include/internal/catch_capture.hpp
+++ b/include/internal/catch_capture.hpp
@ -41,6 +41,8 @@
 ///////////////////////////////////////////////////////////////////////////////
 #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 \
@ -49,8 +51,7 @@
            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } 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 &&.
+    } while( false )

 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
--- a/include/internal/catch_commandline.cpp
+++ b/include/internal/catch_commandline.cpp
@ -50,14 +50,13 @@ namespace Catch {
                        if( !startsWith( line, '"' ) )
                            line = '"' + line + '"';
                        config.testsOrTags.push_back( line );
-                        config.testsOrTags.push_back( "," );
-                        
+                        config.testsOrTags.emplace_back( "," );
                    }
                }
                //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 ) {
@ -92,14 +91,16 @@ namespace Catch {
            };
        auto const setWaitForKeypress = [&]( std::string const& keypress ) {
                auto keypressLc = toLower( keypress );
-                if( keypressLc == "start" )
+                if (keypressLc == "never")
+                    config.waitForKeypress = WaitForKeypress::Never;
+                else 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: start, exit or both. '" + keypress + "' not recognised" );
+                    return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" );
            return ParserResult::ok( ParseResultType::Matched );
            };
        auto const setVerbosity = [&]( std::string const& verbosity ) {
@ -199,7 +200,7 @@ namespace Catch {
            | Opt( config.libIdentify )
                ["--libidentify"]
                ( "report name and version according to libidentify standard" )
-            | Opt( setWaitForKeypress, "start|exit|both" )
+            | Opt( setWaitForKeypress, "never|start|exit|both" )
                ["--wait-for-keypress"]
                ( "waits for a keypress before exiting" )
            | Opt( config.benchmarkSamples, "samples" )
@ -214,7 +215,10 @@ namespace Catch {
            | Opt( config.benchmarkNoAnalysis )
                ["--benchmark-no-analysis"]
                ( "perform only measurements; do not perform any analysis" )
-			| Arg( config.testsOrTags, "test name|pattern|tags" )
+            | 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" )
                ( "which test or tests to use" );

        return cli;
--- a/include/internal/catch_compiler_capabilities.h
+++ b/include/internal/catch_compiler_capabilities.h
@ -48,6 +48,9 @@
 #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" )
+
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
+
 #endif

 #if defined(__clang__)
@ -55,6 +58,9 @@
 #    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
 #    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )

+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
+
+
 #    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
@ -134,6 +140,8 @@
 #  define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )
 #  define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  __pragma( warning(pop) )

+#  define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)sizeof(__VA_ARGS__)
+
 #  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
 #    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
 #  endif
@ -149,9 +157,12 @@
 // 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(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
-#    define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
-#  endif
+#  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__
+
 #endif // _MSC_VER

 #if defined(_REENTRANT) || defined(_MSC_VER)
@ -200,7 +211,7 @@
    #define CATCH_CONFIG_COLOUR_NONE
 #endif

-#if defined(__UCLIBC__)
+#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
 #define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
 #endif

@ -329,6 +340,11 @@
 #   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
--- a/include/internal/catch_config.cpp
+++ b/include/internal/catch_config.cpp
@ -72,10 +72,11 @@ 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; }
+    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); }

    IStream const* Config::openStream() {
        return Catch::makeStream(m_data.outputFilename);
--- a/include/internal/catch_config.hpp
+++ b/include/internal/catch_config.hpp
@ -47,6 +47,7 @@ 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;
@ -113,6 +114,7 @@ namespace Catch {
        int benchmarkSamples() const override;
        double benchmarkConfidenceInterval() const override;
        unsigned int benchmarkResamples() const override;
+        std::chrono::milliseconds benchmarkWarmupTime() const override;

    private:

--- a/include/internal/catch_console_colour.cpp
+++ b/include/internal/catch_console_colour.cpp
@ -34,7 +34,7 @@ namespace Catch {
        };

        struct NoColourImpl : IColourImpl {
-            void use( Colour::Code ) {}
+            void use( Colour::Code ) override {}

            static IColourImpl* instance() {
                static NoColourImpl s_instance;
@ -167,7 +167,7 @@ namespace {

    bool useColourOnPlatform() {
        return
-#ifdef CATCH_PLATFORM_MAC
+#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
            !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&& rhs ) noexcept {
-        m_moved = rhs.m_moved;
-        rhs.m_moved = true;
+    Colour::Colour( 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;
+    Colour& Colour::operator=( Colour&& other ) noexcept {
+        m_moved = other.m_moved;
+        other.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 != NULL) {
+        if (impl != nullptr) {
            impl->use( _colourCode );
        }
    }
--- a/include/internal/catch_debugger.cpp
+++ b/include/internal/catch_debugger.cpp
@ -12,7 +12,7 @@
 #include "catch_stream.h"
 #include "catch_platform.h"

-#ifdef CATCH_PLATFORM_MAC
+#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)

 #  include <assert.h>
 #  include <stdbool.h>
--- a/include/internal/catch_debugger.h
+++ b/include/internal/catch_debugger.h
@ -19,6 +19,19 @@ namespace Catch {

    #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */

+#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
+
 #elif defined(CATCH_PLATFORM_LINUX)
    // If we can use inline assembler, do it because this allows us to break
    // directly at the location of the failing check instead of breaking inside
@ -37,10 +50,12 @@ namespace Catch {
    #define CATCH_TRAP() DebugBreak()
 #endif

-#ifdef CATCH_TRAP
-    #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
-#else
-    #define CATCH_BREAK_INTO_DEBUGGER() []{}()
+#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
 #endif

 #endif // TWOBLUECUBES_CATCH_DEBUGGER_H_INCLUDED
--- a/include/internal/catch_default_main.hpp
+++ b/include/internal/catch_default_main.hpp
@ -9,10 +9,11 @@
 #define TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED

 #include "catch_session.h"
+#include "catch_platform.h"

 #ifndef __OBJC__

-#if defined(CATCH_CONFIG_WCHAR) && defined(WIN32) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
+#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && 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
--- a/include/internal/catch_enum_values_registry.cpp
+++ b/include/internal/catch_enum_values_registry.cpp
@ -60,7 +60,7 @@ namespace Catch {
            assert( valueNames.size() == values.size() );
            std::size_t i = 0;
            for( auto value : values )
-                enumInfo->m_values.push_back({ value, valueNames[i++] });
+                enumInfo->m_values.emplace_back(value, valueNames[i++]);

            return enumInfo;
        }
--- a/include/internal/catch_generators.hpp
+++ b/include/internal/catch_generators.hpp
@ -57,7 +57,6 @@ 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 {
@ -120,21 +119,21 @@ namespace Generators {
            m_generators.emplace_back(std::move(generator));
        }
        void populate(T&& val) {
-            m_generators.emplace_back(value(std::move(val)));
+            m_generators.emplace_back(value(std::forward<T>(val)));
        }
        template<typename U>
        void populate(U&& val) {
-            populate(T(std::move(val)));
+            populate(T(std::forward<U>(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 +165,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,11 +173,11 @@ 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 )... );
    }

@ -204,10 +203,10 @@ namespace Generators {
 } // namespace Catch

 #define GENERATE( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } )
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
 #define GENERATE_COPY( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } )
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
 #define GENERATE_REF( ... ) \
-    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } )
+    Catch::Generators::generate( CATCH_INTERNAL_LINEINFO, [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)

 #endif // TWOBLUECUBES_CATCH_GENERATORS_HPP_INCLUDED
--- a/include/internal/catch_interfaces_config.h
+++ b/include/internal/catch_interfaces_config.h
@ -11,6 +11,7 @@
 #include "catch_common.h"
 #include "catch_option.hpp"

+#include <chrono>
 #include <iosfwd>
 #include <string>
 #include <vector>
@ -81,6 +82,7 @@ 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>;
--- a/include/internal/catch_list.cpp
+++ b/include/internal/catch_list.cpp
@ -28,7 +28,7 @@
 namespace Catch {

    std::size_t listTests( Config const& config ) {
-        TestSpec testSpec = config.testSpec();
+        TestSpec const& 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 testSpec = config.testSpec();
+        TestSpec const& testSpec = config.testSpec();
        std::size_t matchedTests = 0;
        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
        for( auto const& testCaseInfo : matchedTestCases ) {
@ -100,7 +100,7 @@ namespace Catch {
    }

    std::size_t listTags( Config const& config ) {
-        TestSpec testSpec = config.testSpec();
+        TestSpec const& testSpec = config.testSpec();
        if( config.hasTestFilters() )
            Catch::cout() << "Tags for matching test cases:\n";
        else {
--- a/include/internal/catch_matchers.h
+++ b/include/internal/catch_matchers.h
@ -91,9 +91,10 @@ namespace Matchers {
                return description;
            }

-            MatchAllOf<ArgT>& operator && ( MatcherBase<ArgT> const& other ) {
-                m_matchers.push_back( &other );
-                return *this;
+            MatchAllOf<ArgT> operator && ( MatcherBase<ArgT> const& other ) {
+                auto copy(*this);
+                copy.m_matchers.push_back( &other );
+                return copy;
            }

            std::vector<MatcherBase<ArgT> const*> m_matchers;
@ -124,9 +125,10 @@ namespace Matchers {
                return description;
            }

-            MatchAnyOf<ArgT>& operator || ( MatcherBase<ArgT> const& other ) {
-                m_matchers.push_back( &other );
-                return *this;
+            MatchAnyOf<ArgT> operator || ( MatcherBase<ArgT> const& other ) {
+                auto copy(*this);
+                copy.m_matchers.push_back( &other );
+                return copy;
            }

            std::vector<MatcherBase<ArgT> const*> m_matchers;
--- a/include/internal/catch_matchers_floating.cpp
+++ b/include/internal/catch_matchers_floating.cpp
@ -59,16 +59,8 @@ namespace {
        return static_cast<uint64_t>(ulpDiff) <= maxUlpDiff;
    }

-} //end anonymous namespace
-
 #if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)

-#if defined(__clang__)
-#pragma clang diagnostic push
-// The long double overload is currently unused
-#pragma clang diagnostic ignored "-Wunused-function"
-#endif
-
    float nextafter(float x, float y) {
        return ::nextafterf(x, y);
    }
@ -77,18 +69,8 @@ namespace {
        return ::nextafter(x, y);
    }

-    long double nextafter(long double x, long double y) {
-        return ::nextafterl(x, y);
-    }
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
 #endif // ^^^ CATCH_CONFIG_GLOBAL_NEXTAFTER ^^^

-namespace {
-
 template <typename FP>
 FP step(FP start, FP direction, uint64_t steps) {
    for (uint64_t i = 0; i < steps; ++i) {
--- a/include/internal/catch_message.cpp
+++ b/include/internal/catch_message.cpp
@ -111,7 +111,7 @@ namespace Catch {
                pos = skipq(pos, c);
                break;
            case ',':
-                if (start != pos && openings.size() == 0) {
+                if (start != pos && openings.empty()) {
                    m_messages.emplace_back(macroName, lineInfo, resultType);
                    m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
                    m_messages.back().message += " := ";
@ -119,7 +119,7 @@ namespace Catch {
                }
            }
        }
-        assert(openings.size() == 0 && "Mismatched openings");
+        assert(openings.empty() && "Mismatched openings");
        m_messages.emplace_back(macroName, lineInfo, resultType);
        m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
        m_messages.back().message += " := ";
--- a/include/internal/catch_session.cpp
+++ b/include/internal/catch_session.cpp
@ -69,7 +69,7 @@ namespace Catch {
                auto const& allTestCases = getAllTestCasesSorted(*m_config);
                m_matches = m_config->testSpec().matchesByFilter(allTestCases, *m_config);
                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
-                
+
                if (m_matches.empty() && invalidArgs.empty()) {
                    for (auto const& test : allTestCases)
                        if (!test.isHidden())
@ -97,12 +97,12 @@ namespace Catch {
                        totals.error = -1;
                    }
                }
-                
+
                if (!invalidArgs.empty()) {
-                    for (auto const& invalidArg: invalidArgs)                   
+                    for (auto const& invalidArg: invalidArgs)
                         m_context.reporter().reportInvalidArguments(invalidArg);
-                }   
-                
+                }
+
                m_context.testGroupEnded(m_config->name(), totals, 1, 1);
                return totals;
            }
@ -220,11 +220,11 @@ namespace Catch {
        char **utf8Argv = new char *[ argc ];

        for ( int i = 0; i < argc; ++i ) {
-            int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, NULL, 0, NULL, NULL );
+            int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr );

            utf8Argv[ i ] = new char[ bufSize ];

-            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, NULL, NULL );
+            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr );
        }

        int returnCode = applyCommandLine( argc, utf8Argv );
--- a/include/internal/catch_stream.h
+++ b/include/internal/catch_stream.h
@ -9,6 +9,8 @@
 #ifndef TWOBLUECUBES_CATCH_STREAM_H_INCLUDED
 #define TWOBLUECUBES_CATCH_STREAM_H_INCLUDED

+#include "catch_common.h"
+
 #include <iosfwd>
 #include <cstddef>
 #include <ostream>
@ -28,7 +30,7 @@ namespace Catch {

    auto makeStream( StringRef const &filename ) -> IStream const*;

-    class ReusableStringStream {
+    class ReusableStringStream : NonCopyable {
        std::size_t m_index;
        std::ostream* m_oss;
    public:
--- a/include/internal/catch_test_case_info.cpp
+++ b/include/internal/catch_test_case_info.cpp
@ -89,7 +89,8 @@ namespace Catch {
            }
        }
        if( isHidden ) {
-            tags.push_back( "." );
+            // Add all "hidden" tags to make them behave identically
+            tags.insert( tags.end(), { ".", "!hide" } );
        }

        TestCaseInfo info( static_cast<std::string>(nameAndTags.name), _className, desc, tags, _lineInfo );
--- a/include/internal/catch_test_case_tracker.cpp
+++ b/include/internal/catch_test_case_tracker.cpp
@ -225,8 +225,8 @@ namespace TestCaseTracking {
    void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
        if( !filters.empty() ) {
            m_filters.reserve( m_filters.size() + filters.size() + 2 );
-            m_filters.push_back(""); // Root - should never be consulted
-            m_filters.push_back(""); // Test Case - not a section filter
+            m_filters.emplace_back(""); // Root - should never be consulted
+            m_filters.emplace_back(""); // Test Case - not a section filter
            m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
        }
    }
--- a/include/internal/catch_test_spec_parser.cpp
+++ b/include/internal/catch_test_spec_parser.cpp
@ -20,10 +20,10 @@ namespace Catch {
        m_substring.reserve(m_arg.size());
        m_patternName.reserve(m_arg.size());
        m_realPatternPos = 0;
-        
+
        for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
          //if visitChar fails
-           if( !visitChar( m_arg[m_pos] ) ){ 
+           if( !visitChar( m_arg[m_pos] ) ){
               m_testSpec.m_invalidArgs.push_back(arg);
               break;
           }
@ -113,9 +113,9 @@ namespace Catch {
        switch( m_mode ) {
        case Name:
        case QuotedName:
-            return addPattern<TestSpec::NamePattern>();
+            return addNamePattern();
        case Tag:
-            return addPattern<TestSpec::TagPattern>();
+            return addTagPattern();
        case EscapedName:
            revertBackToLastMode();
            return;
@ -156,12 +156,12 @@ namespace Catch {
    void TestSpecParser::saveLastMode() {
      lastMode = m_mode;
    }
-    
+
    void TestSpecParser::revertBackToLastMode() {
      m_mode = lastMode;
    }
-    
-    bool TestSpecParser::separate() {  
+
+    bool TestSpecParser::separate() {
      if( (m_mode==QuotedName) || (m_mode==Tag) ){
         //invalid argument, signal failure to previous scope.
         m_mode = None;
@ -174,7 +174,63 @@ namespace Catch {
      addFilter();
      return true; //success
    }
-    
+
+    std::string TestSpecParser::preprocessPattern() {
+        std::string token = m_patternName;
+        for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
+            token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
+        m_escapeChars.clear();
+        if (startsWith(token, "exclude:")) {
+            m_exclusion = true;
+            token = token.substr(8);
+        }
+
+        m_patternName.clear();
+
+        return token;
+    }
+
+    void TestSpecParser::addNamePattern() {
+        auto token = preprocessPattern();
+
+        if (!token.empty()) {
+            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::NamePattern>(token, m_substring);
+            if (m_exclusion)
+                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+            m_currentFilter.m_patterns.push_back(pattern);
+        }
+        m_substring.clear();
+        m_exclusion = false;
+        m_mode = None;
+    }
+
+    void TestSpecParser::addTagPattern() {
+        auto token = preprocessPattern();
+
+        if (!token.empty()) {
+            // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
+            // we have to create a separate hide tag and shorten the real one
+            if (token.size() > 1 && token[0] == '.') {
+                token.erase(token.begin());
+                TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(".", m_substring);
+                if (m_exclusion) {
+                    pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+                }
+                m_currentFilter.m_patterns.push_back(pattern);
+            }
+
+            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(token, m_substring);
+
+            if (m_exclusion) {
+                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+            }
+            m_currentFilter.m_patterns.push_back(pattern);
+        }
+        m_substring.clear();
+        m_exclusion = false;
+        m_mode = None;
+    }
+
    TestSpec parseTestSpec( std::string const& arg ) {
        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
    }
--- a/include/internal/catch_test_spec_parser.h
+++ b/include/internal/catch_test_spec_parser.h
@ -53,35 +53,20 @@ namespace Catch {
        void revertBackToLastMode();
        void addFilter();
        bool separate();
-        
-        template<typename T>
-        void addPattern() {
-            std::string token = m_patternName;
-            for( std::size_t i = 0; i < m_escapeChars.size(); ++i )
-                token = token.substr( 0, m_escapeChars[i] - i ) + token.substr( m_escapeChars[i] -i +1 );
-            m_escapeChars.clear();
-            if( startsWith( token, "exclude:" ) ) {
-                m_exclusion = true;
-                token = token.substr( 8 );
-            }
-            if( !token.empty() ) {
-                TestSpec::PatternPtr pattern = std::make_shared<T>( token, m_substring );
-                if( m_exclusion )
-                    pattern = std::make_shared<TestSpec::ExcludedPattern>( pattern );
-                m_currentFilter.m_patterns.push_back( pattern );
-            }
-            m_substring.clear();
-            m_patternName.clear();
-            m_exclusion = false;
-            m_mode = None;
-        }
-        
+
+        // Handles common preprocessing of the pattern for name/tag patterns
+        std::string preprocessPattern();
+        // Adds the current pattern as a test name
+        void addNamePattern();
+        // Adds the current pattern as a tag
+        void addTagPattern();
+
        inline void addCharToPattern(char c) {
            m_substring += c;
            m_patternName += c;
            m_realPatternPos++;
        }
-        
+
    };
    TestSpec parseTestSpec( std::string const& arg );

--- a/include/internal/catch_version.cpp
+++ b/include/internal/catch_version.cpp
@ -37,7 +37,7 @@ namespace Catch {
    }

    Version const& libraryVersion() {
-        static Version version( 2, 10, 2, "", 0 );
+        static Version version( 2, 11, 2, "", 0 );
        return version;
    }

--- a/include/internal/catch_xmlwriter.cpp
+++ b/include/internal/catch_xmlwriter.cpp
@ -12,8 +12,6 @@
 #include <iomanip>
 #include <type_traits>

-using uchar = unsigned char;
-
 namespace Catch {

 namespace {
@ -87,7 +85,7 @@ namespace {
        // (see: http://www.w3.org/TR/xml/#syntax)

        for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
-            uchar c = m_str[idx];
+            unsigned char c = m_str[idx];
            switch (c) {
            case '<':   os << "&lt;"; break;
            case '&':   os << "&amp;"; break;
@ -147,7 +145,7 @@ namespace {
                bool valid = true;
                uint32_t value = headerValue(c);
                for (std::size_t n = 1; n < encBytes; ++n) {
-                    uchar nc = m_str[idx + n];
+                    unsigned char nc = m_str[idx + n];
                    valid &= ((nc & 0xC0) == 0x80);
                    value = (value << 6) | (nc & 0x3F);
                }
--- a/include/reporters/catch_reporter_console.cpp
+++ b/include/reporters/catch_reporter_console.cpp
@ -210,15 +210,11 @@ class Duration {
    static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
    static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;

-    uint64_t m_inNanoseconds;
+    double m_inNanoseconds;
    Unit m_units;

 public:
-	explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
-        : Duration(static_cast<uint64_t>(inNanoseconds), units) {
-    }
-
-    explicit Duration(uint64_t inNanoseconds, Unit units = Unit::Auto)
+    explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
        : m_inNanoseconds(inNanoseconds),
        m_units(units) {
        if (m_units == Unit::Auto) {
@ -247,7 +243,7 @@ public:
        case Unit::Minutes:
            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
        default:
-            return static_cast<double>(m_inNanoseconds);
+            return m_inNanoseconds;
        }
    }
    auto unitsAsString() const -> std::string {
@ -684,8 +680,10 @@ void ConsoleReporter::printSummaryDivider() {
 }

 void ConsoleReporter::printTestFilters() {
-    if (m_config->testSpec().hasFilters())
-        stream << Colour(Colour::BrightYellow) << "Filters: " << serializeFilters( m_config->getTestsOrTags() ) << '\n';
+    if (m_config->testSpec().hasFilters()) {
+        Colour guard(Colour::BrightYellow);
+        stream << "Filters: " << serializeFilters(m_config->getTestsOrTags()) << '\n';
+    }
 }

 CATCH_REGISTER_REPORTER("console", ConsoleReporter)
@ -698,4 +696,4 @@ CATCH_REGISTER_REPORTER("console", ConsoleReporter)

 #if defined(__clang__)
 #  pragma clang diagnostic pop
-#endif
+#endif
--- a/include/reporters/catch_reporter_junit.cpp
+++ b/include/reporters/catch_reporter_junit.cpp
@ -223,11 +223,7 @@ namespace Catch {
                    elementName = "error";
                    break;
                case ResultWas::ExplicitFailure:
-                    elementName = "failure";
-                    break;
                case ResultWas::ExpressionFailed:
-                    elementName = "failure";
-                    break;
                case ResultWas::DidntThrowException:
                    elementName = "failure";
                    break;
--- a/include/reporters/catch_reporter_xml.cpp
+++ b/include/reporters/catch_reporter_xml.cpp
@ -229,16 +229,16 @@ namespace Catch {
        m_xml.writeAttribute("samples", info.samples)
            .writeAttribute("resamples", info.resamples)
            .writeAttribute("iterations", info.iterations)
-            .writeAttribute("clockResolution", static_cast<uint64_t>(info.clockResolution))
-            .writeAttribute("estimatedDuration", static_cast<uint64_t>(info.estimatedDuration))
+            .writeAttribute("clockResolution", info.clockResolution)
+            .writeAttribute("estimatedDuration", info.estimatedDuration)
            .writeComment("All values in nano seconds");
    }

    void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
        m_xml.startElement("mean")
-            .writeAttribute("value", static_cast<uint64_t>(benchmarkStats.mean.point.count()))
-            .writeAttribute("lowerBound", static_cast<uint64_t>(benchmarkStats.mean.lower_bound.count()))
-            .writeAttribute("upperBound", static_cast<uint64_t>(benchmarkStats.mean.upper_bound.count()))
+            .writeAttribute("value", benchmarkStats.mean.point.count())
+            .writeAttribute("lowerBound", benchmarkStats.mean.lower_bound.count())
+            .writeAttribute("upperBound", benchmarkStats.mean.upper_bound.count())
            .writeAttribute("ci", benchmarkStats.mean.confidence_interval);
        m_xml.endElement();
        m_xml.startElement("standardDeviation")
--- a/projects/ExtraTests/CMakeLists.txt
+++ b/projects/ExtraTests/CMakeLists.txt
@ -137,6 +137,14 @@ if (MSVC)
    add_test(NAME WindowsHeader COMMAND WindowsHeader -r compact)
 endif()

+add_executable(DebugBreakMacros ${TESTS_DIR}/X12-CustomDebugBreakMacro.cpp)
+add_test(NAME DebugBreakMacros COMMAND DebugBreakMacros --break)
+set_tests_properties(
+    DebugBreakMacros
+  PROPERTIES
+    PASS_REGULAR_EXPRESSION "Pretty please, break into debugger"
+)
+
 set( EXTRA_TEST_BINARIES
    PrefixedMacros
    DisabledMacros
@ -145,6 +153,7 @@ set( EXTRA_TEST_BINARIES
    FallbackStringifier
    DisableStringification
    BenchmarkingMacros
+    DebugBreakMacros
 )

 # Shared config
--- a/projects/ExtraTests/X12-CustomDebugBreakMacro.cpp
+++ b/projects/ExtraTests/X12-CustomDebugBreakMacro.cpp
@ -0,0 +1,17 @@
+// X12-CustomDebugBreakMacro.cpp
+// Test that user-defined `CATCH_BREAK_INTO_DEBUGGER` is respected and used.
+
+#include <iostream>
+
+void custom_debug_break() {
+    std::cerr << "Pretty please, break into debugger\n";
+}
+
+#define CATCH_BREAK_INTO_DEBUGGER() custom_debug_break()
+
+#define CATCH_CONFIG_MAIN
+#include <catch2/catch.hpp>
+
+TEST_CASE("Failing test that breaks into debugger", "[macros]") {
+    REQUIRE(1 == 2);
+}
--- a/projects/ExtraTests/X20-BenchmarkingMacros.cpp
+++ b/projects/ExtraTests/X20-BenchmarkingMacros.cpp
@ -26,14 +26,6 @@ TEST_CASE("Benchmark factorial", "[benchmark]") {
    BENCHMARK("factorial 14") {
        return factorial(14);
    };
-//
-//    BENCHMARK("factorial 20") {
-//        return factorial(20);
-//    };
-//
-//    BENCHMARK("factorial 35") {
-//        return factorial(35);
-//    };
 }

 TEST_CASE("Benchmark containers", "[.][benchmark]") {
--- a/projects/SelfTest/Baselines/compact.sw.approved.txt
+++ b/projects/SelfTest/Baselines/compact.sw.approved.txt
@ -312,6 +312,8 @@ Condition.tests.cpp:<line number>: passed: 4 == ul for: 4 == 4
 Condition.tests.cpp:<line number>: passed: 5 == c for: 5 == 5
 Condition.tests.cpp:<line number>: passed: 6 == uc for: 6 == 6
 Condition.tests.cpp:<line number>: passed: (std::numeric_limits<uint32_t>::max)() > ul for: 4294967295 (0x<hex digits>) > 4
+Matchers.tests.cpp:<line number>: passed: testStringForMatching2(), !composed1 for: "some completely different text that contains one common word" not ( contains: "string" or contains: "random" )
+Matchers.tests.cpp:<line number>: passed: testStringForMatching2(), composed2 for: "some completely different text that contains one common word" ( contains: "string" or contains: "random" or contains: "different" )
 Matchers.tests.cpp:<line number>: failed: testStringForMatching(), Contains("not there", Catch::CaseSensitive::No) for: "this string contains 'abc' as a substring" contains: "not there" (case insensitive)
 Matchers.tests.cpp:<line number>: failed: testStringForMatching(), Contains("STRING") for: "this string contains 'abc' as a substring" contains: "STRING"
 Generators.tests.cpp:<line number>: passed: elem % 2 == 1 for: 1 == 1
@ -1027,6 +1029,12 @@ CmdLine.tests.cpp:<line number>: passed: spec.matches( fakeTestCase( "  aardvark
 CmdLine.tests.cpp:<line number>: passed: spec.matches( fakeTestCase( " aardvark " ) ) for: true
 CmdLine.tests.cpp:<line number>: passed: spec.matches( fakeTestCase( "aardvark " ) ) for: true
 CmdLine.tests.cpp:<line number>: passed: spec.matches( fakeTestCase( "aardvark" ) ) for: true
+CmdLine.tests.cpp:<line number>: passed: spec.matches(fakeTestCase("hidden and foo", "[.][foo]")) for: true
+CmdLine.tests.cpp:<line number>: passed: !(spec.matches(fakeTestCase("only foo", "[foo]"))) for: !false
+CmdLine.tests.cpp:<line number>: passed: !(spec.matches(fakeTestCase("hidden and foo", "[.][foo]"))) for: !false
+CmdLine.tests.cpp:<line number>: passed: !(spec.matches(fakeTestCase("only foo", "[foo]"))) for: !false
+CmdLine.tests.cpp:<line number>: passed: !(spec.matches(fakeTestCase("only hidden", "[.]"))) for: !false
+CmdLine.tests.cpp:<line number>: passed: spec.matches(fakeTestCase("neither foo nor hidden", "[bar]")) for: true
 Condition.tests.cpp:<line number>: passed: p == 0 for: 0 == 0
 Condition.tests.cpp:<line number>: passed: p == pNULL for: 0 == 0
 Condition.tests.cpp:<line number>: passed: p != 0 for: 0x<hex digits> != 0
@ -1080,6 +1088,16 @@ CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "-x", "2"}) for: {?}
 CmdLine.tests.cpp:<line number>: passed: config.abortAfter == 2 for: 2 == 2
 CmdLine.tests.cpp:<line number>: passed: !result for: true
 CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), Contains("convert") && Contains("oops") for: "Unable to convert 'oops' to destination type" ( contains: "convert" and contains: "oops" )
+CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.waitForKeypress == std::get<1>(input) for: 0 == 0
+CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.waitForKeypress == std::get<1>(input) for: 1 == 1
+CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.waitForKeypress == std::get<1>(input) for: 2 == 2
+CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.waitForKeypress == std::get<1>(input) for: 3 == 3
+CmdLine.tests.cpp:<line number>: passed: !result for: true
+CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), Contains("never") && Contains("both") for: "keypress argument must be one of: never, start, exit or both. 'sometimes' not recognised" ( contains: "never" and contains: "both" )
 CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "-e"}) for: {?}
 CmdLine.tests.cpp:<line number>: passed: config.noThrow for: true
 CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "--nothrow"}) for: {?}
@ -1110,6 +1128,8 @@ CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--benchmark-confid
 CmdLine.tests.cpp:<line number>: passed: config.benchmarkConfidenceInterval == Catch::Detail::Approx(0.99) for: 0.99 == Approx( 0.99 )
 CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--benchmark-no-analysis" }) for: {?}
 CmdLine.tests.cpp:<line number>: passed: config.benchmarkNoAnalysis for: true
+CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--benchmark-warmup-time=10" }) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.benchmarkWarmupTime == 10 for: 10 == 10
 Misc.tests.cpp:<line number>: passed: std::tuple_size<TestType>::value >= 1 for: 3 >= 1
 Misc.tests.cpp:<line number>: passed: std::tuple_size<TestType>::value >= 1 for: 2 >= 1
 Misc.tests.cpp:<line number>: passed: std::tuple_size<TestType>::value >= 1 for: 1 >= 1
@ -1186,7 +1206,7 @@ String.tests.cpp:<line number>: passed: s.data() == s2.data() for: "hello world!
 String.tests.cpp:<line number>: passed: s.data() == ss.data() for: "hello world!" == "hello world!"
 String.tests.cpp:<line number>: passed: s.substr(s.size() + 1, 123).empty() for: true
 String.tests.cpp:<line number>: passed: std::strcmp(ss.c_str(), "world!") == 0 for: 0 == 0
-String.tests.cpp:<line number>: passed: buffer1 != buffer2 for: "Hello" != "Hello"
+String.tests.cpp:<line number>: passed: (char*)buffer1 != (char*)buffer2 for: "Hello" != "Hello"
 String.tests.cpp:<line number>: passed: left == right for: Hello == Hello
 String.tests.cpp:<line number>: passed: left != left.substr(0, 3) for: Hello != Hel
 String.tests.cpp:<line number>: passed: sr == "a standard string" for: a standard string == "a standard string"
@ -1561,48 +1581,9 @@ Xml.tests.cpp:<line number>: passed: encode( stringWithQuotes, Catch::XmlEncode:
 "don't &quot;quote&quot; me on that"
 Xml.tests.cpp:<line number>: passed: encode( "[\x01]" ) == "[\\x01]" for: "[\x01]" == "[\x01]"
 Xml.tests.cpp:<line number>: passed: encode( "[\x7F]" ) == "[\\x7F]" for: "[\x7F]" == "[\x7F]"
-Xml.tests.cpp:<line number>: passed: encode(u8"Here be 👾") == u8"Here be 👾" for: "Here be 👾" == "Here be 👾"
-Xml.tests.cpp:<line number>: passed: encode(u8"šš") == u8"šš" for: "šš" == "šš"
-Xml.tests.cpp:<line number>: passed: encode("\xDF\xBF") == "\xDF\xBF" for: "߿" == "߿"
-Xml.tests.cpp:<line number>: passed: encode("\xE0\xA0\x80") == "\xE0\xA0\x80" for: "ࠀ" == "ࠀ"
-Xml.tests.cpp:<line number>: passed: encode("\xED\x9F\xBF") == "\xED\x9F\xBF" for: "퟿" == "퟿"
-Xml.tests.cpp:<line number>: passed: encode("\xEE\x80\x80") == "\xEE\x80\x80" for: "" == ""
-Xml.tests.cpp:<line number>: passed: encode("\xEF\xBF\xBF") == "\xEF\xBF\xBF" for: "" == ""
-Xml.tests.cpp:<line number>: passed: encode("\xF0\x90\x80\x80") == "\xF0\x90\x80\x80" for: "𐀀" == "𐀀"
-Xml.tests.cpp:<line number>: passed: encode("\xF4\x8F\xBF\xBF") == "\xF4\x8F\xBF\xBF" for: "􏿿" == "􏿿"
-Xml.tests.cpp:<line number>: passed: encode("Here \xFF be 👾") == u8"Here \\xFF be 👾" for: "Here \xFF be 👾" == "Here \xFF be 👾"
-Xml.tests.cpp:<line number>: passed: encode("\xFF") == "\\xFF" for: "\xFF" == "\xFF"
-Xml.tests.cpp:<line number>: passed: encode("\xC5\xC5\xA0") == u8"\\xC5Š" for: "\xC5Š" == "\xC5Š"
-Xml.tests.cpp:<line number>: passed: encode("\xF4\x90\x80\x80") == u8"\\xF4\\x90\\x80\\x80" for: "\xF4\x90\x80\x80" == "\xF4\x90\x80\x80"
-Xml.tests.cpp:<line number>: passed: encode("\xC0\x80") == u8"\\xC0\\x80" for: "\xC0\x80" == "\xC0\x80"
-Xml.tests.cpp:<line number>: passed: encode("\xF0\x80\x80\x80") == u8"\\xF0\\x80\\x80\\x80" for: "\xF0\x80\x80\x80" == "\xF0\x80\x80\x80"
-Xml.tests.cpp:<line number>: passed: encode("\xC1\xBF") == u8"\\xC1\\xBF" for: "\xC1\xBF" == "\xC1\xBF"
-Xml.tests.cpp:<line number>: passed: encode("\xE0\x9F\xBF") == u8"\\xE0\\x9F\\xBF" for: "\xE0\x9F\xBF" == "\xE0\x9F\xBF"
-Xml.tests.cpp:<line number>: passed: encode("\xF0\x8F\xBF\xBF") == u8"\\xF0\\x8F\\xBF\\xBF" for: "\xF0\x8F\xBF\xBF" == "\xF0\x8F\xBF\xBF"
-Xml.tests.cpp:<line number>: passed: encode("\xED\xA0\x80") == "\xED\xA0\x80" for: "<22><><EFBFBD>" == "<22><><EFBFBD>"
-Xml.tests.cpp:<line number>: passed: encode("\xED\xAF\xBF") == "\xED\xAF\xBF" for: "<22><><EFBFBD>" == "<22><><EFBFBD>"
-Xml.tests.cpp:<line number>: passed: encode("\xED\xB0\x80") == "\xED\xB0\x80" for: "<22><><EFBFBD>" == "<22><><EFBFBD>"
-Xml.tests.cpp:<line number>: passed: encode("\xED\xBF\xBF") == "\xED\xBF\xBF" for: "<22><><EFBFBD>" == "<22><><EFBFBD>"
-Xml.tests.cpp:<line number>: passed: encode("\x80") == u8"\\x80" for: "\x80" == "\x80"
-Xml.tests.cpp:<line number>: passed: encode("\x81") == u8"\\x81" for: "\x81" == "\x81"
-Xml.tests.cpp:<line number>: passed: encode("\xBC") == u8"\\xBC" for: "\xBC" == "\xBC"
-Xml.tests.cpp:<line number>: passed: encode("\xBF") == u8"\\xBF" for: "\xBF" == "\xBF"
-Xml.tests.cpp:<line number>: passed: encode("\xF5\x80\x80\x80") == u8"\\xF5\\x80\\x80\\x80" for: "\xF5\x80\x80\x80" == "\xF5\x80\x80\x80"
-Xml.tests.cpp:<line number>: passed: encode("\xF6\x80\x80\x80") == u8"\\xF6\\x80\\x80\\x80" for: "\xF6\x80\x80\x80" == "\xF6\x80\x80\x80"
-Xml.tests.cpp:<line number>: passed: encode("\xF7\x80\x80\x80") == u8"\\xF7\\x80\\x80\\x80" for: "\xF7\x80\x80\x80" == "\xF7\x80\x80\x80"
-Xml.tests.cpp:<line number>: passed: encode("\xDE") == u8"\\xDE" for: "\xDE" == "\xDE"
-Xml.tests.cpp:<line number>: passed: encode("\xDF") == u8"\\xDF" for: "\xDF" == "\xDF"
-Xml.tests.cpp:<line number>: passed: encode("\xE0") == u8"\\xE0" for: "\xE0" == "\xE0"
-Xml.tests.cpp:<line number>: passed: encode("\xEF") == u8"\\xEF" for: "\xEF" == "\xEF"
-Xml.tests.cpp:<line number>: passed: encode("\xF0") == u8"\\xF0" for: "\xF0" == "\xF0"
-Xml.tests.cpp:<line number>: passed: encode("\xF4") == u8"\\xF4" for: "\xF4" == "\xF4"
-Xml.tests.cpp:<line number>: passed: encode("\xE0\x80") == u8"\\xE0\\x80" for: "\xE0\x80" == "\xE0\x80"
-Xml.tests.cpp:<line number>: passed: encode("\xE0\xBF") == u8"\\xE0\\xBF" for: "\xE0\xBF" == "\xE0\xBF"
-Xml.tests.cpp:<line number>: passed: encode("\xE1\x80") == u8"\\xE1\\x80" for: "\xE1\x80" == "\xE1\x80"
-Xml.tests.cpp:<line number>: passed: encode("\xF0\x80") == u8"\\xF0\\x80" for: "\xF0\x80" == "\xF0\x80"
-Xml.tests.cpp:<line number>: passed: encode("\xF4\x80") == u8"\\xF4\\x80" for: "\xF4\x80" == "\xF4\x80"
-Xml.tests.cpp:<line number>: passed: encode("\xF0\x80\x80") == u8"\\xF0\\x80\\x80" for: "\xF0\x80\x80" == "\xF0\x80\x80"
-Xml.tests.cpp:<line number>: passed: encode("\xF4\x80\x80") == u8"\\xF4\\x80\\x80" for: "\xF4\x80\x80" == "\xF4\x80\x80"
+Tag.tests.cpp:<line number>: passed: testcase.tags, VectorContains(std::string(".")) && VectorContains(std::string("!hide")) for: { "!hide", "." } ( Contains: "." and Contains: "!hide" )
+Tag.tests.cpp:<line number>: passed: testcase.tags, VectorContains(std::string(".")) && VectorContains(std::string("!hide")) for: { "!hide", "." } ( Contains: "." and Contains: "!hide" )
+Tag.tests.cpp:<line number>: passed: testcase.tags, VectorContains(std::string(".")) && VectorContains(std::string("!hide")) for: { "!hide", ".", "foo" } ( Contains: "." and Contains: "!hide" )
 ToStringVector.tests.cpp:<line number>: passed: Catch::Detail::stringify( empty ) == "{  }" for: "{  }" == "{  }"
 ToStringVector.tests.cpp:<line number>: passed: Catch::Detail::stringify( oneValue ) == "{ 42 }" for: "{ 42 }" == "{ 42 }"
 ToStringVector.tests.cpp:<line number>: passed: Catch::Detail::stringify( twoValues ) == "{ 42, 250 }" for: "{ 42, 250 }" == "{ 42, 250 }"
@ -1704,7 +1685,7 @@ StringManip.tests.cpp:<line number>: passed: Catch::replaceInPlace(s, "'", "|'")
 StringManip.tests.cpp:<line number>: passed: s == "didn|'t" for: "didn|'t" == "didn|'t"
 Misc.tests.cpp:<line number>: failed: false with 1 message: '3'
 Message.tests.cpp:<line number>: failed: false with 2 messages: 'hi' and 'i := 7'
-Tag.tests.cpp:<line number>: passed: testcase.tags, Catch::VectorContains(std::string("magic-tag")) && Catch::VectorContains(std::string(".")) for: { ".", "magic-tag" } ( Contains: "magic-tag" and Contains: "." )
+Tag.tests.cpp:<line number>: passed: testcase.tags, Catch::VectorContains(std::string("magic-tag")) && Catch::VectorContains(std::string(".")) for: { "!hide", ".", "magic-tag" } ( Contains: "magic-tag" and Contains: "." )
 StringManip.tests.cpp:<line number>: passed: splitStringRef("", ','), Equals(std::vector<StringRef>()) for: {  } Equals: {  }
 StringManip.tests.cpp:<line number>: passed: splitStringRef("abc", ','), Equals(std::vector<StringRef>{"abc"}) for: { abc } Equals: { abc }
 StringManip.tests.cpp:<line number>: passed: splitStringRef("abc,def", ','), Equals(std::vector<StringRef>{"abc", "def"}) for: { abc, def } Equals: { abc, def }
--- a/projects/SelfTest/Baselines/console.std.approved.txt
+++ b/projects/SelfTest/Baselines/console.std.approved.txt
@ -1380,6 +1380,6 @@ due to unexpected exception with message:
  Why would you throw a std::string?

 ===============================================================================
-test cases:  305 |  231 passed |  70 failed |  4 failed as expected
-assertions: 1695 | 1543 passed | 131 failed | 21 failed as expected
+test cases:  306 |  232 passed |  70 failed |  4 failed as expected
+assertions: 1676 | 1524 passed | 131 failed | 21 failed as expected

--- a/projects/SelfTest/Baselines/console.sw.approved.txt
+++ b/projects/SelfTest/Baselines/console.sw.approved.txt
@ -2390,6 +2390,24 @@ Condition.tests.cpp:<line number>: PASSED:
 with expansion:
  4294967295 (0x<hex digits>) > 4

+-------------------------------------------------------------------------------
+Composed matchers are distinct
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( testStringForMatching2(), !composed1 )
+with expansion:
+  "some completely different text that contains one common word" not (
+  contains: "string" or contains: "random" )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( testStringForMatching2(), composed2 )
+with expansion:
+  "some completely different text that contains one common word" ( contains:
+  "string" or contains: "random" or contains: "different" )
+
 -------------------------------------------------------------------------------
 Contains string matcher
 -------------------------------------------------------------------------------
@ -7361,6 +7379,50 @@ CmdLine.tests.cpp:<line number>: PASSED:
 with expansion:
  true

+-------------------------------------------------------------------------------
+Parse test names and tags
+  Shortened hide tags are split apart when parsing
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  CHECK( spec.matches(fakeTestCase("hidden and foo", "[.][foo]")) )
+with expansion:
+  true
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  CHECK_FALSE( spec.matches(fakeTestCase("only foo", "[foo]")) )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Parse test names and tags
+  Shortened hide tags also properly handle exclusion
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  CHECK_FALSE( spec.matches(fakeTestCase("hidden and foo", "[.][foo]")) )
+with expansion:
+  !false
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  CHECK_FALSE( spec.matches(fakeTestCase("only foo", "[foo]")) )
+with expansion:
+  !false
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  CHECK_FALSE( spec.matches(fakeTestCase("only hidden", "[.]")) )
+with expansion:
+  !false
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  CHECK( spec.matches(fakeTestCase("neither foo nor hidden", "[bar]")) )
+with expansion:
+  true
+
 -------------------------------------------------------------------------------
 Pointers can be compared to null
 -------------------------------------------------------------------------------
@ -7772,6 +7834,102 @@ with expansion:
  "Unable to convert 'oops' to destination type" ( contains: "convert" and
  contains: "oops" )

+-------------------------------------------------------------------------------
+Process can be configured on command line
+  abort
+  wait-for-keypress
+  Accepted options
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  CHECK( cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) )
+with expansion:
+  {?}
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  REQUIRE( config.waitForKeypress == std::get<1>(input) )
+with expansion:
+  0 == 0
+
+-------------------------------------------------------------------------------
+Process can be configured on command line
+  abort
+  wait-for-keypress
+  Accepted options
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  CHECK( cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) )
+with expansion:
+  {?}
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  REQUIRE( config.waitForKeypress == std::get<1>(input) )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+Process can be configured on command line
+  abort
+  wait-for-keypress
+  Accepted options
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  CHECK( cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) )
+with expansion:
+  {?}
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  REQUIRE( config.waitForKeypress == std::get<1>(input) )
+with expansion:
+  2 == 2
+
+-------------------------------------------------------------------------------
+Process can be configured on command line
+  abort
+  wait-for-keypress
+  Accepted options
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  CHECK( cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) )
+with expansion:
+  {?}
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  REQUIRE( config.waitForKeypress == std::get<1>(input) )
+with expansion:
+  3 == 3
+
+-------------------------------------------------------------------------------
+Process can be configured on command line
+  abort
+  wait-for-keypress
+  invalid options are reported
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  CHECK( !result )
+with expansion:
+  true
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( result.errorMessage(), Contains("never") && Contains("both") )
+with expansion:
+  "keypress argument must be one of: never, start, exit or both. 'sometimes'
+  not recognised" ( contains: "never" and contains: "both" )
+
 -------------------------------------------------------------------------------
 Process can be configured on command line
  nothrow
@ -8002,7 +8160,7 @@ with expansion:
 -------------------------------------------------------------------------------
 Process can be configured on command line
  Benchmark options
-  resamples
+  confidence-interval
 -------------------------------------------------------------------------------
 CmdLine.tests.cpp:<line number>
 ...............................................................................
@ -8020,7 +8178,7 @@ with expansion:
 -------------------------------------------------------------------------------
 Process can be configured on command line
  Benchmark options
-  resamples
+  no-analysis
 -------------------------------------------------------------------------------
 CmdLine.tests.cpp:<line number>
 ...............................................................................
@ -8035,6 +8193,24 @@ CmdLine.tests.cpp:<line number>: PASSED:
 with expansion:
  true

+-------------------------------------------------------------------------------
+Process can be configured on command line
+  Benchmark options
+  warmup-time
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  CHECK( cli.parse({ "test", "--benchmark-warmup-time=10" }) )
+with expansion:
+  {?}
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  REQUIRE( config.benchmarkWarmupTime == 10 )
+with expansion:
+  10 == 10
+
 -------------------------------------------------------------------------------
 Product with differing arities - std::tuple<int, double, float>
 -------------------------------------------------------------------------------
@ -8670,7 +8846,7 @@ String.tests.cpp:<line number>
 ...............................................................................

 String.tests.cpp:<line number>: PASSED:
-  CHECK( buffer1 != buffer2 )
+  CHECK( (char*)buffer1 != (char*)buffer2 )
 with expansion:
  "Hello" != "Hello"

@ -11422,261 +11598,37 @@ with expansion:
  "[\x7F]" == "[\x7F]"

 -------------------------------------------------------------------------------
-XmlEncode: UTF-8
-  Valid utf-8 strings
+adding a hide tag implicitly enables all others
 -------------------------------------------------------------------------------
-Xml.tests.cpp:<line number>
+Tag.tests.cpp:<line number>
 ...............................................................................

-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode(u8"Here be 👾") == u8"Here be 👾" )
+Tag.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( testcase.tags, VectorContains(std::string(".")) && VectorContains(std::string("!hide")) )
 with expansion:
-  "Here be 👾" == "Here be 👾"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode(u8"šš") == u8"šš" )
-with expansion:
-  "šš" == "šš"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xDF\xBF") == "\xDF\xBF" )
-with expansion:
-  "߿" == "߿"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xE0\xA0\x80") == "\xE0\xA0\x80" )
-with expansion:
-  "ࠀ" == "ࠀ"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xED\x9F\xBF") == "\xED\x9F\xBF" )
-with expansion:
-  "퟿" == "퟿"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xEE\x80\x80") == "\xEE\x80\x80" )
-with expansion:
-  "" == ""
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xEF\xBF\xBF") == "\xEF\xBF\xBF" )
-with expansion:
-  "" == ""
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xF0\x90\x80\x80") == "\xF0\x90\x80\x80" )
-with expansion:
-  "𐀀" == "𐀀"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xF4\x8F\xBF\xBF") == "\xF4\x8F\xBF\xBF" )
-with expansion:
-  "􏿿" == "􏿿"
+  { "!hide", "." } ( Contains: "." and Contains: "!hide" )

 -------------------------------------------------------------------------------
-XmlEncode: UTF-8
-  Invalid utf-8 strings
-  Various broken strings
+adding a hide tag implicitly enables all others
 -------------------------------------------------------------------------------
-Xml.tests.cpp:<line number>
+Tag.tests.cpp:<line number>
 ...............................................................................

-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("Here \xFF be 👾") == u8"Here \\xFF be 👾" )
+Tag.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( testcase.tags, VectorContains(std::string(".")) && VectorContains(std::string("!hide")) )
 with expansion:
-  "Here \xFF be 👾" == "Here \xFF be 👾"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xFF") == "\\xFF" )
-with expansion:
-  "\xFF" == "\xFF"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xC5\xC5\xA0") == u8"\\xC5Š" )
-with expansion:
-  "\xC5Š" == "\xC5Š"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xF4\x90\x80\x80") == u8"\\xF4\\x90\\x80\\x80" )
-with expansion:
-  "\xF4\x90\x80\x80" == "\xF4\x90\x80\x80"
+  { "!hide", "." } ( Contains: "." and Contains: "!hide" )

 -------------------------------------------------------------------------------
-XmlEncode: UTF-8
-  Invalid utf-8 strings
-  Overlong encodings
+adding a hide tag implicitly enables all others
 -------------------------------------------------------------------------------
-Xml.tests.cpp:<line number>
+Tag.tests.cpp:<line number>
 ...............................................................................

-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xC0\x80") == u8"\\xC0\\x80" )
+Tag.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( testcase.tags, VectorContains(std::string(".")) && VectorContains(std::string("!hide")) )
 with expansion:
-  "\xC0\x80" == "\xC0\x80"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xF0\x80\x80\x80") == u8"\\xF0\\x80\\x80\\x80" )
-with expansion:
-  "\xF0\x80\x80\x80" == "\xF0\x80\x80\x80"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xC1\xBF") == u8"\\xC1\\xBF" )
-with expansion:
-  "\xC1\xBF" == "\xC1\xBF"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xE0\x9F\xBF") == u8"\\xE0\\x9F\\xBF" )
-with expansion:
-  "\xE0\x9F\xBF" == "\xE0\x9F\xBF"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xF0\x8F\xBF\xBF") == u8"\\xF0\\x8F\\xBF\\xBF" )
-with expansion:
-  "\xF0\x8F\xBF\xBF" == "\xF0\x8F\xBF\xBF"
-
-------------------------------------------------------------------------------
-XmlEncode: UTF-8
-  Invalid utf-8 strings
-  Surrogate pairs
-------------------------------------------------------------------------------
-Xml.tests.cpp:<line number>
-...............................................................................
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xED\xA0\x80") == "\xED\xA0\x80" )
-with expansion:
-  "<22><><EFBFBD>" == "<22><><EFBFBD>"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xED\xAF\xBF") == "\xED\xAF\xBF" )
-with expansion:
-  "<22><><EFBFBD>" == "<22><><EFBFBD>"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xED\xB0\x80") == "\xED\xB0\x80" )
-with expansion:
-  "<22><><EFBFBD>" == "<22><><EFBFBD>"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xED\xBF\xBF") == "\xED\xBF\xBF" )
-with expansion:
-  "<22><><EFBFBD>" == "<22><><EFBFBD>"
-
-------------------------------------------------------------------------------
-XmlEncode: UTF-8
-  Invalid utf-8 strings
-  Invalid start byte
-------------------------------------------------------------------------------
-Xml.tests.cpp:<line number>
-...............................................................................
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\x80") == u8"\\x80" )
-with expansion:
-  "\x80" == "\x80"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\x81") == u8"\\x81" )
-with expansion:
-  "\x81" == "\x81"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xBC") == u8"\\xBC" )
-with expansion:
-  "\xBC" == "\xBC"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xBF") == u8"\\xBF" )
-with expansion:
-  "\xBF" == "\xBF"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xF5\x80\x80\x80") == u8"\\xF5\\x80\\x80\\x80" )
-with expansion:
-  "\xF5\x80\x80\x80" == "\xF5\x80\x80\x80"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xF6\x80\x80\x80") == u8"\\xF6\\x80\\x80\\x80" )
-with expansion:
-  "\xF6\x80\x80\x80" == "\xF6\x80\x80\x80"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xF7\x80\x80\x80") == u8"\\xF7\\x80\\x80\\x80" )
-with expansion:
-  "\xF7\x80\x80\x80" == "\xF7\x80\x80\x80"
-
-------------------------------------------------------------------------------
-XmlEncode: UTF-8
-  Invalid utf-8 strings
-  Missing continuation byte(s)
-------------------------------------------------------------------------------
-Xml.tests.cpp:<line number>
-...............................................................................
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xDE") == u8"\\xDE" )
-with expansion:
-  "\xDE" == "\xDE"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xDF") == u8"\\xDF" )
-with expansion:
-  "\xDF" == "\xDF"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xE0") == u8"\\xE0" )
-with expansion:
-  "\xE0" == "\xE0"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xEF") == u8"\\xEF" )
-with expansion:
-  "\xEF" == "\xEF"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xF0") == u8"\\xF0" )
-with expansion:
-  "\xF0" == "\xF0"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xF4") == u8"\\xF4" )
-with expansion:
-  "\xF4" == "\xF4"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xE0\x80") == u8"\\xE0\\x80" )
-with expansion:
-  "\xE0\x80" == "\xE0\x80"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xE0\xBF") == u8"\\xE0\\xBF" )
-with expansion:
-  "\xE0\xBF" == "\xE0\xBF"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xE1\x80") == u8"\\xE1\\x80" )
-with expansion:
-  "\xE1\x80" == "\xE1\x80"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xF0\x80") == u8"\\xF0\\x80" )
-with expansion:
-  "\xF0\x80" == "\xF0\x80"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xF4\x80") == u8"\\xF4\\x80" )
-with expansion:
-  "\xF4\x80" == "\xF4\x80"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xF0\x80\x80") == u8"\\xF0\\x80\\x80" )
-with expansion:
-  "\xF0\x80\x80" == "\xF0\x80\x80"
-
-Xml.tests.cpp:<line number>: PASSED:
-  CHECK( encode("\xF4\x80\x80") == u8"\\xF4\\x80\\x80" )
-with expansion:
-  "\xF4\x80\x80" == "\xF4\x80\x80"
+  { "!hide", ".", "foo" } ( Contains: "." and Contains: "!hide" )

 -------------------------------------------------------------------------------
 array<int, N> -> toString
@ -12600,7 +12552,7 @@ Tag.tests.cpp:<line number>
 Tag.tests.cpp:<line number>: PASSED:
  REQUIRE_THAT( testcase.tags, Catch::VectorContains(std::string("magic-tag")) && Catch::VectorContains(std::string(".")) )
 with expansion:
-  { ".", "magic-tag" } ( Contains: "magic-tag" and Contains: "." )
+  { "!hide", ".", "magic-tag" } ( Contains: "magic-tag" and Contains: "." )

 -------------------------------------------------------------------------------
 splitString
@ -13464,6 +13416,6 @@ Misc.tests.cpp:<line number>
 Misc.tests.cpp:<line number>: PASSED:

 ===============================================================================
-test cases:  305 |  215 passed |  86 failed |  4 failed as expected
-assertions: 1712 | 1543 passed | 148 failed | 21 failed as expected
+test cases:  306 |  216 passed |  86 failed |  4 failed as expected
+assertions: 1693 | 1524 passed | 148 failed | 21 failed as expected

--- a/projects/SelfTest/Baselines/junit.sw.approved.txt
+++ b/projects/SelfTest/Baselines/junit.sw.approved.txt
@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <testsuitesloose text artifact
 >
-  <testsuite name="<exe-name>" errors="17" failures="132" tests="1713" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
+  <testsuite name="<exe-name>" errors="17" failures="132" tests="1694" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
    <properties>
      <property name="filters" value="~[!nonportable]~[!benchmark]~[approvals]"/>
      <property name="random-seed" value="1"/>
@ -356,6 +356,7 @@ Exception.tests.cpp:<line number>
    <testcase classname="<exe-name>.global" name="Comparisons between ints where one side is computed" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="Comparisons between unsigned ints and negative signed ints match c++ standard behaviour" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="Comparisons with int literals don't warn when mixing signed/ unsigned" time="{duration}"/>
+    <testcase classname="<exe-name>.global" name="Composed matchers are distinct" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="Contains string matcher" time="{duration}">
      <failure message="testStringForMatching(), Contains(&quot;not there&quot;, Catch::CaseSensitive::No)" type="CHECK_THAT">
 FAILED:
@ -982,6 +983,8 @@ Message.tests.cpp:<line number>
    <testcase classname="<exe-name>.global" name="Parse test names and tags/quoted string followed by tag exclusion" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="Parse test names and tags/Leading and trailing spaces in test spec" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="Parse test names and tags/Leading and trailing spaces in test name" time="{duration}"/>
+    <testcase classname="<exe-name>.global" name="Parse test names and tags/Shortened hide tags are split apart when parsing" time="{duration}"/>
+    <testcase classname="<exe-name>.global" name="Parse test names and tags/Shortened hide tags also properly handle exclusion" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="Pointers can be compared to null" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="Precision of floating point stringification can be set/Floats" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="Precision of floating point stringification can be set/Double" time="{duration}"/>
@ -1001,6 +1004,8 @@ Message.tests.cpp:<line number>
    <testcase classname="<exe-name>.global" name="Process can be configured on command line/abort/-a aborts after first failure" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="Process can be configured on command line/abort/-x 2 aborts after two failures" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="Process can be configured on command line/abort/-x must be numeric" time="{duration}"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/abort/wait-for-keypress/Accepted options" time="{duration}"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/abort/wait-for-keypress/invalid options are reported" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="Process can be configured on command line/nothrow/-e" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="Process can be configured on command line/nothrow/--nothrow" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="Process can be configured on command line/output filename/-o filename" time="{duration}"/>
@ -1013,8 +1018,9 @@ Message.tests.cpp:<line number>
    <testcase classname="<exe-name>.global" name="Process can be configured on command line/use-colour/error" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="Process can be configured on command line/Benchmark options/samples" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="Process can be configured on command line/Benchmark options/resamples" time="{duration}"/>
-    <testcase classname="<exe-name>.global" name="Process can be configured on command line/Benchmark options/resamples" time="{duration}"/>
-    <testcase classname="<exe-name>.global" name="Process can be configured on command line/Benchmark options/resamples" time="{duration}"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/Benchmark options/confidence-interval" time="{duration}"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/Benchmark options/no-analysis" time="{duration}"/>
+    <testcase classname="<exe-name>.global" name="Process can be configured on command line/Benchmark options/warmup-time" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="Product with differing arities - std::tuple&lt;int, double, float>" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="Product with differing arities - std::tuple&lt;int, double>" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="Product with differing arities - std::tuple&lt;int>" time="{duration}"/>
@ -1402,12 +1408,7 @@ Exception.tests.cpp:<line number>
    <testcase classname="<exe-name>.global" name="XmlEncode/string with quotes" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="XmlEncode/string with control char (1)" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="XmlEncode/string with control char (x7F)" time="{duration}"/>
-    <testcase classname="<exe-name>.global" name="XmlEncode: UTF-8/Valid utf-8 strings" time="{duration}"/>
-    <testcase classname="<exe-name>.global" name="XmlEncode: UTF-8/Invalid utf-8 strings/Various broken strings" time="{duration}"/>
-    <testcase classname="<exe-name>.global" name="XmlEncode: UTF-8/Invalid utf-8 strings/Overlong encodings" time="{duration}"/>
-    <testcase classname="<exe-name>.global" name="XmlEncode: UTF-8/Invalid utf-8 strings/Surrogate pairs" time="{duration}"/>
-    <testcase classname="<exe-name>.global" name="XmlEncode: UTF-8/Invalid utf-8 strings/Invalid start byte" time="{duration}"/>
-    <testcase classname="<exe-name>.global" name="XmlEncode: UTF-8/Invalid utf-8 strings/Missing continuation byte(s)" time="{duration}"/>
+    <testcase classname="<exe-name>.global" name="adding a hide tag implicitly enables all others" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="array&lt;int, N> -> toString" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="atomic if" time="{duration}"/>
    <testcase classname="<exe-name>.global" name="boolean member" time="{duration}"/>
--- a/projects/SelfTest/Baselines/sonarqube.sw.approved.txt
+++ b/projects/SelfTest/Baselines/sonarqube.sw.approved.txt
@ -35,6 +35,8 @@
    <testCase name="Parse test names and tags/quoted string followed by tag exclusion" duration="{duration}"/>
    <testCase name="Parse test names and tags/Leading and trailing spaces in test spec" duration="{duration}"/>
    <testCase name="Parse test names and tags/Leading and trailing spaces in test name" duration="{duration}"/>
+    <testCase name="Parse test names and tags/Shortened hide tags are split apart when parsing" duration="{duration}"/>
+    <testCase name="Parse test names and tags/Shortened hide tags also properly handle exclusion" duration="{duration}"/>
    <testCase name="Process can be configured on command line/empty args don't cause a crash" duration="{duration}"/>
    <testCase name="Process can be configured on command line/default - no arguments" duration="{duration}"/>
    <testCase name="Process can be configured on command line/test lists/Specify one test case using" duration="{duration}"/>
@ -50,6 +52,8 @@
    <testCase name="Process can be configured on command line/abort/-a aborts after first failure" duration="{duration}"/>
    <testCase name="Process can be configured on command line/abort/-x 2 aborts after two failures" duration="{duration}"/>
    <testCase name="Process can be configured on command line/abort/-x must be numeric" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/abort/wait-for-keypress/Accepted options" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/abort/wait-for-keypress/invalid options are reported" duration="{duration}"/>
    <testCase name="Process can be configured on command line/nothrow/-e" duration="{duration}"/>
    <testCase name="Process can be configured on command line/nothrow/--nothrow" duration="{duration}"/>
    <testCase name="Process can be configured on command line/output filename/-o filename" duration="{duration}"/>
@ -62,8 +66,9 @@
    <testCase name="Process can be configured on command line/use-colour/error" duration="{duration}"/>
    <testCase name="Process can be configured on command line/Benchmark options/samples" duration="{duration}"/>
    <testCase name="Process can be configured on command line/Benchmark options/resamples" duration="{duration}"/>
-    <testCase name="Process can be configured on command line/Benchmark options/resamples" duration="{duration}"/>
-    <testCase name="Process can be configured on command line/Benchmark options/resamples" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/Benchmark options/confidence-interval" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/Benchmark options/no-analysis" duration="{duration}"/>
+    <testCase name="Process can be configured on command line/Benchmark options/warmup-time" duration="{duration}"/>
    <testCase name="Test with special, characters &quot;in name" duration="{duration}"/>
  </file>
  <file path="projects/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp">
@ -140,6 +145,7 @@
  <file path="projects/<exe-name>/IntrospectiveTests/Tag.tests.cpp">
    <testCase name="Tag alias can be registered against tag patterns/The same tag alias can only be registered once" duration="{duration}"/>
    <testCase name="Tag alias can be registered against tag patterns/Tag aliases must be of the form [@name]" duration="{duration}"/>
+    <testCase name="adding a hide tag implicitly enables all others" duration="{duration}"/>
    <testCase name="shortened hide tags are split apart" duration="{duration}"/>
  </file>
  <file path="projects/<exe-name>/IntrospectiveTests/ToString.tests.cpp">
@ -157,12 +163,6 @@
    <testCase name="XmlEncode/string with quotes" duration="{duration}"/>
    <testCase name="XmlEncode/string with control char (1)" duration="{duration}"/>
    <testCase name="XmlEncode/string with control char (x7F)" duration="{duration}"/>
-    <testCase name="XmlEncode: UTF-8/Valid utf-8 strings" duration="{duration}"/>
-    <testCase name="XmlEncode: UTF-8/Invalid utf-8 strings/Various broken strings" duration="{duration}"/>
-    <testCase name="XmlEncode: UTF-8/Invalid utf-8 strings/Overlong encodings" duration="{duration}"/>
-    <testCase name="XmlEncode: UTF-8/Invalid utf-8 strings/Surrogate pairs" duration="{duration}"/>
-    <testCase name="XmlEncode: UTF-8/Invalid utf-8 strings/Invalid start byte" duration="{duration}"/>
-    <testCase name="XmlEncode: UTF-8/Invalid utf-8 strings/Missing continuation byte(s)" duration="{duration}"/>
  </file>
  <file path="projects/<exe-name>/UsageTests/Approx.tests.cpp">
    <testCase name="A comparison that uses literals instead of the normal constructor" duration="{duration}"/>
@ -894,6 +894,7 @@ Exception.tests.cpp:<line number>
  <file path="projects/<exe-name>/UsageTests/Matchers.tests.cpp">
    <testCase name="Arbitrary predicate matcher/Function pointer" duration="{duration}"/>
    <testCase name="Arbitrary predicate matcher/Lambdas + different type" duration="{duration}"/>
+    <testCase name="Composed matchers are distinct" duration="{duration}"/>
    <testCase name="Contains string matcher" duration="{duration}">
      <failure message="CHECK_THAT(testStringForMatching(), Contains(&quot;not there&quot;, Catch::CaseSensitive::No))">
 FAILED:
--- a/projects/SelfTest/Baselines/xml.sw.approved.txt
+++ b/projects/SelfTest/Baselines/xml.sw.approved.txt
--- a/projects/SelfTest/IntrospectiveTests/CmdLine.tests.cpp
+++ b/projects/SelfTest/IntrospectiveTests/CmdLine.tests.cpp
@ -17,7 +17,7 @@

 inline Catch::TestCase fakeTestCase(const char* name, const char* desc = "") { return Catch::makeTestCase(nullptr, "", { name, desc }, CATCH_INTERNAL_LINEINFO); }

-TEST_CASE( "Parse test names and tags" ) {
+TEST_CASE( "Parse test names and tags", "[command-line][test-spec]" ) {

    using Catch::parseTestSpec;
    using Catch::TestSpec;
@ -269,7 +269,6 @@ TEST_CASE( "Parse test names and tags" ) {
        CHECK( spec.matches( fakeTestCase( " aardvark " ) ) );
        CHECK( spec.matches( fakeTestCase( "aardvark " ) ) );
        CHECK( spec.matches( fakeTestCase( "aardvark" ) ) );
-
    }
    SECTION( "Leading and trailing spaces in test name" ) {
        TestSpec spec = parseTestSpec( "aardvark" );
@ -278,7 +277,18 @@ TEST_CASE( "Parse test names and tags" ) {
        CHECK( spec.matches( fakeTestCase( " aardvark " ) ) );
        CHECK( spec.matches( fakeTestCase( "aardvark " ) ) );
        CHECK( spec.matches( fakeTestCase( "aardvark" ) ) );
-
+    }
+    SECTION("Shortened hide tags are split apart when parsing") {
+        TestSpec spec = parseTestSpec("[.foo]");
+        CHECK(spec.matches(fakeTestCase("hidden and foo", "[.][foo]")));
+        CHECK_FALSE(spec.matches(fakeTestCase("only foo", "[foo]")));
+    }
+    SECTION("Shortened hide tags also properly handle exclusion") {
+        TestSpec spec = parseTestSpec("~[.foo]");
+        CHECK_FALSE(spec.matches(fakeTestCase("hidden and foo", "[.][foo]")));
+        CHECK_FALSE(spec.matches(fakeTestCase("only foo", "[foo]")));
+        CHECK_FALSE(spec.matches(fakeTestCase("only hidden", "[.]")));
+        CHECK(spec.matches(fakeTestCase("neither foo nor hidden", "[bar]")));
    }
 }

@ -402,9 +412,33 @@ TEST_CASE( "Process can be configured on command line", "[config][command-line]"

 #ifndef CATCH_CONFIG_DISABLE_MATCHERS
            REQUIRE_THAT(result.errorMessage(), Contains("convert") && Contains("oops"));
+#endif
+        }
+
+     SECTION("wait-for-keypress") {
+        SECTION("Accepted options") {
+            using tuple_type = std::tuple<char const*, Catch::WaitForKeypress::When>;
+            auto input = GENERATE(table<char const*, Catch::WaitForKeypress::When>({
+                tuple_type{"never", Catch::WaitForKeypress::Never},
+                tuple_type{"start", Catch::WaitForKeypress::BeforeStart},
+                tuple_type{"exit",  Catch::WaitForKeypress::BeforeExit},
+                tuple_type{"both",  Catch::WaitForKeypress::BeforeStartAndExit},
+            }));
+            CHECK(cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}));
+
+            REQUIRE(config.waitForKeypress == std::get<1>(input));
+        }
+
+        SECTION("invalid options are reported") {
+            auto result = cli.parse({"test", "--wait-for-keypress", "sometimes"});
+            CHECK(!result);
+
+#ifndef CATCH_CONFIG_DISABLE_MATCHERS
+            REQUIRE_THAT(result.errorMessage(), Contains("never") && Contains("both"));
 #endif
        }
    }
+   }

    SECTION("nothrow") {
        SECTION("-e") {
@ -486,24 +520,30 @@ TEST_CASE( "Process can be configured on command line", "[config][command-line]"

            REQUIRE(config.benchmarkSamples == 200);
        }
-        
+
        SECTION("resamples") {
            CHECK(cli.parse({ "test", "--benchmark-resamples=20000" }));

            REQUIRE(config.benchmarkResamples == 20000);
        }

-        SECTION("resamples") {
+        SECTION("confidence-interval") {
            CHECK(cli.parse({ "test", "--benchmark-confidence-interval=0.99" }));

            REQUIRE(config.benchmarkConfidenceInterval == Catch::Detail::Approx(0.99));
        }

-        SECTION("resamples") {
+        SECTION("no-analysis") {
            CHECK(cli.parse({ "test", "--benchmark-no-analysis" }));

            REQUIRE(config.benchmarkNoAnalysis);
        }
+
+        SECTION("warmup-time") {
+            CHECK(cli.parse({ "test", "--benchmark-warmup-time=10" }));
+
+            REQUIRE(config.benchmarkWarmupTime == 10);
+        }
    }
 }

--- a/projects/SelfTest/IntrospectiveTests/GeneratorsImpl.tests.cpp
+++ b/projects/SelfTest/IntrospectiveTests/GeneratorsImpl.tests.cpp
@ -181,7 +181,7 @@ TEST_CASE("Generators internals", "[generators][internals]") {
                    const auto step = .1;

                    auto gen = range(rangeStart, rangeEnd, step);
-                    auto expected = rangeStart; 
+                    auto expected = rangeStart;
                    while( (rangeEnd - expected) > step ) {
                        INFO( "Current expected value is " << expected )
                        REQUIRE(gen.get() == Approx(expected));
@ -198,7 +198,7 @@ TEST_CASE("Generators internals", "[generators][internals]") {
                    const auto step = .3;

                    auto gen = range(rangeStart, rangeEnd, step);
-                    auto expected = rangeStart; 
+                    auto expected = rangeStart;
                    while( (rangeEnd - expected) > step ) {
                       INFO( "Current expected value is " << expected )
                       REQUIRE(gen.get() == Approx(expected));
@ -214,7 +214,7 @@ TEST_CASE("Generators internals", "[generators][internals]") {
                    const auto step = .3;

                    auto gen = range(rangeStart, rangeEnd, step);
-                    auto expected = rangeStart; 
+                    auto expected = rangeStart;
                    while( (rangeEnd - expected) > step ) {
                       INFO( "Current expected value is " << expected )
                       REQUIRE(gen.get() == Approx(expected));
@ -223,7 +223,7 @@ TEST_CASE("Generators internals", "[generators][internals]") {
                       expected += step;
                    }
                    REQUIRE_FALSE(gen.next());
-                }                
+                }
            }
        }
        SECTION("Negative manual step") {
@ -311,6 +311,21 @@ TEST_CASE("GENERATE capture macros", "[generators][internals][approvals]") {
    REQUIRE(value == value2);
 }

+TEST_CASE("#1809 - GENERATE_COPY and SingleValueGenerator does not compile", "[generators][compilation][approvals]") {
+    // Verify Issue #1809 fix, only needs to compile.
+    auto a = GENERATE_COPY(1, 2);
+    (void)a;
+    auto b = GENERATE_COPY(as<long>{}, 1, 2);
+    (void)b;
+    int i = 1;
+    int j = 2;
+    auto c = GENERATE_COPY(i, j);
+    (void)c;
+    auto d = GENERATE_COPY(as<long>{}, i, j);
+    (void)d;
+    SUCCEED();
+}
+
 TEST_CASE("Multiple random generators in one test case output different values", "[generators][internals][approvals]") {
    SECTION("Integer") {
        auto random1 = Catch::Generators::random(0, 1000);
--- a/projects/SelfTest/IntrospectiveTests/String.tests.cpp
+++ b/projects/SelfTest/IntrospectiveTests/String.tests.cpp
@ -79,7 +79,7 @@ TEST_CASE( "StringRef", "[Strings][StringRef]" ) {
    SECTION( "Comparisons are deep" ) {
        char buffer1[] = "Hello";
        char buffer2[] = "Hello";
-        CHECK(buffer1 != buffer2);
+        CHECK((char*)buffer1 != (char*)buffer2);

        StringRef left(buffer1), right(buffer2);
        REQUIRE( left == right );
--- a/projects/SelfTest/IntrospectiveTests/Tag.tests.cpp
+++ b/projects/SelfTest/IntrospectiveTests/Tag.tests.cpp
@ -45,3 +45,10 @@ TEST_CASE("shortened hide tags are split apart") {
    auto testcase = Catch::makeTestCase(nullptr, "", {"fake test name", "[.magic-tag]"}, CATCH_INTERNAL_LINEINFO);
    REQUIRE_THAT(testcase.tags, Catch::VectorContains(std::string("magic-tag")) && Catch::VectorContains(std::string(".")));
 }
+
+TEST_CASE("adding a hide tag implicitly enables all others", "[tags]") {
+    using Catch::VectorContains;
+    auto tag = GENERATE(as<char const*>{}, "[!hide]", "[.]", "[.foo]");
+    auto testcase = Catch::makeTestCase(nullptr, "", {"fake test name", tag}, CATCH_INTERNAL_LINEINFO);
+    REQUIRE_THAT(testcase.tags, VectorContains(std::string(".")) && VectorContains(std::string("!hide")));
+}
--- a/projects/SelfTest/IntrospectiveTests/Xml.tests.cpp
+++ b/projects/SelfTest/IntrospectiveTests/Xml.tests.cpp
@ -40,10 +40,11 @@ TEST_CASE( "XmlEncode", "[XML]" ) {
 }

 // Thanks to Peter Bindels (dascandy) for some of the tests
-TEST_CASE("XmlEncode: UTF-8", "[XML][UTF-8]") {
+TEST_CASE("XmlEncode: UTF-8", "[XML][UTF-8][approvals]") {
+#define ESC(lit) (char*)(lit)
    SECTION("Valid utf-8 strings") {
-        CHECK(encode(u8"Here be 👾") == u8"Here be 👾");
-        CHECK(encode(u8"šš") == u8"šš");
+        CHECK(encode(ESC(u8"Here be 👾")) == ESC(u8"Here be 👾"));
+        CHECK(encode(ESC(u8"šš")) == ESC(u8"šš"));

        CHECK(encode("\xDF\xBF")         == "\xDF\xBF"); // 0x7FF
        CHECK(encode("\xE0\xA0\x80")     == "\xE0\xA0\x80"); // 0x800
@ -55,18 +56,18 @@ TEST_CASE("XmlEncode: UTF-8", "[XML][UTF-8]") {
    }
    SECTION("Invalid utf-8 strings") {
        SECTION("Various broken strings") {
-            CHECK(encode("Here \xFF be 👾") == u8"Here \\xFF be 👾");
+            CHECK(encode(ESC("Here \xFF be \xF0\x9F\x91\xBE")) == ESC(u8"Here \\xFF be 👾"));
            CHECK(encode("\xFF") == "\\xFF");
-            CHECK(encode("\xC5\xC5\xA0") == u8"\\xC5Š");
-            CHECK(encode("\xF4\x90\x80\x80") == u8"\\xF4\\x90\\x80\\x80"); // 0x110000 -- out of unicode range
+            CHECK(encode("\xC5\xC5\xA0") == ESC(u8"\\xC5Š"));
+            CHECK(encode("\xF4\x90\x80\x80") == ESC(u8"\\xF4\\x90\\x80\\x80")); // 0x110000 -- out of unicode range
        }

        SECTION("Overlong encodings") {
-            CHECK(encode("\xC0\x80") == u8"\\xC0\\x80"); // \0
-            CHECK(encode("\xF0\x80\x80\x80") == u8"\\xF0\\x80\\x80\\x80"); // Super-over-long \0
-            CHECK(encode("\xC1\xBF") == u8"\\xC1\\xBF"); // ASCII char as UTF-8 (0x7F)
-            CHECK(encode("\xE0\x9F\xBF") == u8"\\xE0\\x9F\\xBF"); // 0x7FF
-            CHECK(encode("\xF0\x8F\xBF\xBF") == u8"\\xF0\\x8F\\xBF\\xBF"); // 0xFFFF
+            CHECK(encode("\xC0\x80") == "\\xC0\\x80"); // \0
+            CHECK(encode("\xF0\x80\x80\x80") == "\\xF0\\x80\\x80\\x80"); // Super-over-long \0
+            CHECK(encode("\xC1\xBF") == "\\xC1\\xBF"); // ASCII char as UTF-8 (0x7F)
+            CHECK(encode("\xE0\x9F\xBF") == "\\xE0\\x9F\\xBF"); // 0x7FF
+            CHECK(encode("\xF0\x8F\xBF\xBF") == "\\xF0\\x8F\\xBF\\xBF"); // 0xFFFF
        }

        // Note that we actually don't modify surrogate pairs, as we do not do strict checking
@ -78,35 +79,36 @@ TEST_CASE("XmlEncode: UTF-8", "[XML][UTF-8]") {
        }

        SECTION("Invalid start byte") {
-            CHECK(encode("\x80") == u8"\\x80");
-            CHECK(encode("\x81") == u8"\\x81");
-            CHECK(encode("\xBC") == u8"\\xBC");
-            CHECK(encode("\xBF") == u8"\\xBF");
+            CHECK(encode("\x80") == "\\x80");
+            CHECK(encode("\x81") == "\\x81");
+            CHECK(encode("\xBC") == "\\xBC");
+            CHECK(encode("\xBF") == "\\xBF");
            // Out of range
-            CHECK(encode("\xF5\x80\x80\x80") == u8"\\xF5\\x80\\x80\\x80");
-            CHECK(encode("\xF6\x80\x80\x80") == u8"\\xF6\\x80\\x80\\x80");
-            CHECK(encode("\xF7\x80\x80\x80") == u8"\\xF7\\x80\\x80\\x80");
+            CHECK(encode("\xF5\x80\x80\x80") == "\\xF5\\x80\\x80\\x80");
+            CHECK(encode("\xF6\x80\x80\x80") == "\\xF6\\x80\\x80\\x80");
+            CHECK(encode("\xF7\x80\x80\x80") == "\\xF7\\x80\\x80\\x80");
        }

        SECTION("Missing continuation byte(s)") {
            // Missing first continuation byte
-            CHECK(encode("\xDE") == u8"\\xDE");
-            CHECK(encode("\xDF") == u8"\\xDF");
-            CHECK(encode("\xE0") == u8"\\xE0");
-            CHECK(encode("\xEF") == u8"\\xEF");
-            CHECK(encode("\xF0") == u8"\\xF0");
-            CHECK(encode("\xF4") == u8"\\xF4");
+            CHECK(encode("\xDE") == "\\xDE");
+            CHECK(encode("\xDF") == "\\xDF");
+            CHECK(encode("\xE0") == "\\xE0");
+            CHECK(encode("\xEF") == "\\xEF");
+            CHECK(encode("\xF0") == "\\xF0");
+            CHECK(encode("\xF4") == "\\xF4");

            // Missing second continuation byte
-            CHECK(encode("\xE0\x80") == u8"\\xE0\\x80");
-            CHECK(encode("\xE0\xBF") == u8"\\xE0\\xBF");
-            CHECK(encode("\xE1\x80") == u8"\\xE1\\x80");
-            CHECK(encode("\xF0\x80") == u8"\\xF0\\x80");
-            CHECK(encode("\xF4\x80") == u8"\\xF4\\x80");
+            CHECK(encode("\xE0\x80") == "\\xE0\\x80");
+            CHECK(encode("\xE0\xBF") == "\\xE0\\xBF");
+            CHECK(encode("\xE1\x80") == "\\xE1\\x80");
+            CHECK(encode("\xF0\x80") == "\\xF0\\x80");
+            CHECK(encode("\xF4\x80") == "\\xF4\\x80");

            // Missing third continuation byte
-            CHECK(encode("\xF0\x80\x80") == u8"\\xF0\\x80\\x80");
-            CHECK(encode("\xF4\x80\x80") == u8"\\xF4\\x80\\x80");
+            CHECK(encode("\xF0\x80\x80") == "\\xF0\\x80\\x80");
+            CHECK(encode("\xF4\x80\x80") == "\\xF4\\x80\\x80");
        }
    }
+#undef ESC
 }
--- a/projects/SelfTest/UsageTests/Benchmark.tests.cpp
+++ b/projects/SelfTest/UsageTests/Benchmark.tests.cpp
@ -126,5 +126,19 @@ TEST_CASE("Benchmark containers", "[!benchmark]") {
            REQUIRE(v[i] == generated);
        }
    }
+
+    SECTION("construct and destroy example") {
+        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) {
+            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(); });
+        };
+    }
 }
 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
--- a/projects/SelfTest/UsageTests/Compilation.tests.cpp
+++ b/projects/SelfTest/UsageTests/Compilation.tests.cpp
@ -205,10 +205,19 @@ namespace { namespace CompilationTests {
        inline static void synchronizing_callback( void * ) { }
    }

+#if defined (_MSC_VER)
+#pragma warning(push)
+// The function pointer comparison below triggers warning because of
+// calling conventions
+#pragma warning(disable:4244)
+#endif
    TEST_CASE("#925: comparing function pointer to function address failed to compile", "[!nonportable]" ) {
        TestClass test;
        REQUIRE(utility::synchronizing_callback != test.testMethod_uponComplete_arg);
    }
+#if defined (_MSC_VER)
+#pragma warning(pop)
+#endif

    TEST_CASE( "#1027: Bitfields can be captured" ) {
        struct Y {
--- a/projects/SelfTest/UsageTests/Matchers.tests.cpp
+++ b/projects/SelfTest/UsageTests/Matchers.tests.cpp
@ -552,6 +552,16 @@ namespace { namespace MatchersTests {
            REQUIRE_THROWS_MATCHES(throwsSpecialException(2), SpecialException, !Message("DerivedException::what"));
            REQUIRE_THROWS_MATCHES(throwsSpecialException(2), SpecialException,  Message("SpecialException::what"));
        }
+        
+        TEST_CASE("Composed matchers are distinct", "[matchers][composed]") {
+            auto m1 = Contains("string");
+            auto m2 = Contains("random");
+            auto composed1 = m1 || m2;
+            auto m3 = Contains("different");
+            auto composed2 = composed1 || m3;
+            REQUIRE_THAT(testStringForMatching2(), !composed1);
+            REQUIRE_THAT(testStringForMatching2(), composed2);
+        }

 } } // namespace MatchersTests

--- a/projects/SelfTest/UsageTests/ToStringVariant.tests.cpp
+++ b/projects/SelfTest/UsageTests/ToStringVariant.tests.cpp
@ -9,12 +9,12 @@
 // We need 2 types with non-trivial copies/moves
 struct MyType1 {
    MyType1() = default;
-    MyType1(MyType1 const&) { throw 1; }
+    [[noreturn]] MyType1(MyType1 const&) { throw 1; }
    MyType1& operator=(MyType1 const&) { throw 3; }
 };
 struct MyType2 {
    MyType2() = default;
-    MyType2(MyType2 const&) { throw 2; }
+    [[noreturn]] MyType2(MyType2 const&) { throw 2; }
    MyType2& operator=(MyType2 const&) { throw 4; }
 };

--- a/projects/SelfTest/UsageTests/ToStringVector.tests.cpp
+++ b/projects/SelfTest/UsageTests/ToStringVector.tests.cpp
@ -17,9 +17,9 @@ TEST_CASE( "vector<string> -> toString", "[toString][vector]" )
 {
    std::vector<std::string> vv;
    REQUIRE( ::Catch::Detail::stringify(vv) == "{  }" );
-    vv.push_back( "hello" );
+    vv.emplace_back( "hello" );
    REQUIRE( ::Catch::Detail::stringify(vv) == "{ \"hello\" }" );
-    vv.push_back( "world" );
+    vv.emplace_back( "world" );
    REQUIRE( ::Catch::Detail::stringify(vv) == "{ \"hello\", \"world\" }" );
 }

@ -83,4 +83,4 @@ TEST_CASE( "array<int, N> -> toString", "[toString][containers][array]" ) {
    REQUIRE( Catch::Detail::stringify( oneValue ) == "{ 42 }" );
    std::array<int, 2> twoValues = {{ 42, 250 }};
    REQUIRE( Catch::Detail::stringify( twoValues ) == "{ 42, 250 }" );
-}
+}
--- a/projects/SelfTest/UsageTests/Tricky.tests.cpp
+++ b/projects/SelfTest/UsageTests/Tricky.tests.cpp
@ -17,7 +17,7 @@

 #include "catch.hpp"

-#include <stdio.h>
+#include <cstdio>
 #include <sstream>
 #include <iostream>

--- a/scripts/approvalTests.py
+++ b/scripts/approvalTests.py
@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3

 from __future__ import print_function

--- a/scripts/approve.py
+++ b/scripts/approve.py
@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3

 from  __future__ import  print_function

--- a/scripts/benchmarkCompile.py
+++ b/scripts/benchmarkCompile.py
@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3

 from __future__ import print_function

--- a/scripts/developBuild.py
+++ b/scripts/developBuild.py
@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3

 from  __future__ import  print_function
 import releaseCommon
--- a/scripts/embedClara.py
+++ b/scripts/embedClara.py
@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3

 # Execute this script any time you import a new copy of Clara into the third_party area
 import os
--- a/scripts/extractFeaturesFromReleaseNotes.py
+++ b/scripts/extractFeaturesFromReleaseNotes.py
@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3

 #
 # extractFeaturesFromReleaseNotes.py
--- a/scripts/fixWhitespace.py
+++ b/scripts/fixWhitespace.py
@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3

 from  __future__ import  print_function
 import os
--- a/scripts/generateSingleHeader.py
+++ b/scripts/generateSingleHeader.py
@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3

 from __future__ import print_function

@ -23,6 +23,7 @@ def generate(v):
    blankParser = re.compile( r'^\s*$')

    seenHeaders = set([])
+    possibleHeaders = set([])
    rootPath = os.path.join( catchPath, 'include/' )
    outputPath = os.path.join( catchPath, 'single_include/catch2/catch.hpp' )

@ -52,8 +53,20 @@ def generate(v):
        if globals['includeImpl'] or globals['implIfDefs'] == -1:
            out.write( line )

+    def getDirsToSearch( ):
+        return [os.path.join( rootPath, s) for s in ['', 'internal', 'reporters', 'internal/benchmark', 'internal/benchmark/detail']]
+
+    def collectPossibleHeaders():
+        dirs = getDirsToSearch()
+        for dir in dirs:
+            hpps = glob(os.path.join(dir, '*.hpp'))
+            hs = glob(os.path.join(dir, '*.h'))
+            possibleHeaders.update( hpp.rpartition( os.sep )[2] for hpp in hpps )
+            possibleHeaders.update( h.rpartition( os.sep )[2] for h in hs )
+
+
    def insertCpps():
-        dirs = [os.path.join( rootPath, s) for s in ['', 'internal', 'reporters', 'internal/benchmark', 'internal/benchmark/detail']]
+        dirs = getDirsToSearch()
        cppFiles = []
        for dir in dirs:
            cppFiles += glob(os.path.join(dir, '*.cpp'))
@ -103,6 +116,13 @@ def generate(v):
                        write( line.rstrip() + "\n" )
        write( u'// end {}\n'.format(filename) )

+    def warnUnparsedHeaders():
+        unparsedHeaders = possibleHeaders.difference( seenHeaders )
+        # These headers aren't packaged into the unified header, exclude them from any warning
+        whitelist = ['catch.hpp', 'catch_reporter_teamcity.hpp', 'catch_with_main.hpp', 'catch_reporter_automake.hpp', 'catch_reporter_tap.hpp', 'catch_reporter_sonarqube.hpp']
+        unparsedHeaders = unparsedHeaders.difference( whitelist )
+        if unparsedHeaders:
+            print( "WARNING: unparsed headers detected\n{0}\n".format( unparsedHeaders ) )

    write( u"/*\n" )
    write( u" *  Catch v{0}\n".format( v.getVersionString() ) )
@ -117,11 +137,13 @@ def generate(v):
    write( u"#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED\n" )
    write( u"#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED\n" )

+    collectPossibleHeaders()
    parseFile( rootPath, 'catch.hpp' )
+    warnUnparsedHeaders()

    write( u"#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED\n\n" )
    out.close()
-    print ("Generated single include for Catch v{0}\n".format( v.getVersionString() ) )
+    print( "Generated single include for Catch v{0}\n".format( v.getVersionString() ) )


 if __name__ == '__main__':
--- a/scripts/majorRelease.py
+++ b/scripts/majorRelease.py
@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3

 from  __future__ import  print_function
 import releaseCommon
--- a/scripts/minorRelease.py
+++ b/scripts/minorRelease.py
@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3

 from  __future__ import  print_function
 import releaseCommon
--- a/scripts/patchRelease.py
+++ b/scripts/patchRelease.py
@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3

 from  __future__ import  print_function
 import releaseCommon
--- a/scripts/releaseNotes.py
+++ b/scripts/releaseNotes.py
@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3

 from __future__ import print_function

--- a/scripts/updateDocumentToC.py
+++ b/scripts/updateDocumentToC.py
@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3

 #
 # updateDocumentToC.py
--- a/scripts/updateWandbox.py
+++ b/scripts/updateWandbox.py
@ -1,16 +1,22 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3

 import json
 import os
-import urllib2
+import urllib.request
+import urllib.parse
+

 from scriptCommon import catchPath

 def upload(options):
-    request = urllib2.Request('http://melpon.org/wandbox/api/compile.json')
-    request.add_header('Content-Type', 'application/json')
-    response = urllib2.urlopen(request, json.dumps(options))
-    return json.loads(response.read())
+#    request_blah = urllib.request.Request('https://
+
+    request = urllib.request.Request('https://melpon.org/wandbox/api/compile.json', method='POST')
+    json_bytes = json.dumps(options).encode('utf-8')
+    request.add_header('Content-Type', 'application/json; charset=utf-8')
+    request.add_header('Content-Length', len(json_bytes))
+    response = urllib.request.urlopen(request, json_bytes)
+    return json.loads(response.read().decode('utf-8'))

 main_file = '''
 #define CATCH_CONFIG_MAIN  // This tells Catch to provide a main() - only do this in one cpp file
--- a/single_include/catch2/catch.hpp
+++ b/single_include/catch2/catch.hpp
--- a/single_include/catch2/catch_reporter_sonarqube.hpp
+++ b/single_include/catch2/catch_reporter_sonarqube.hpp
@ -0,0 +1,181 @@
+/*
+ *  Created by Daniel Garcia on 2018-12-04.
+ *  Copyright Social Point SL. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+#define CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+
+
+// Don't #include any Catch headers here - we can assume they are already
+// included before this header.
+// This is not good practice in general but is necessary in this case so this
+// file can be distributed as a single header that works with the main
+// Catch single header.
+
+#include <map>
+
+namespace Catch {
+
+    struct SonarQubeReporter : CumulativeReporterBase<SonarQubeReporter> {
+
+        SonarQubeReporter(ReporterConfig const& config)
+        : CumulativeReporterBase(config)
+        , xml(config.stream()) {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+            m_reporterPrefs.shouldReportAllAssertions = true;
+        }
+
+        ~SonarQubeReporter() override;
+
+        static std::string getDescription() {
+            return "Reports test results in the Generic Test Data SonarQube XML format";
+        }
+
+        static std::set<Verbosity> getSupportedVerbosities() {
+            return { Verbosity::Normal };
+        }
+
+        void noMatchingTestCases(std::string const& /*spec*/) override {}
+
+        void testRunStarting(TestRunInfo const& testRunInfo) override {
+            CumulativeReporterBase::testRunStarting(testRunInfo);
+            xml.startElement("testExecutions");
+            xml.writeAttribute("version", "1");
+        }
+
+        void testGroupEnded(TestGroupStats const& testGroupStats) override {
+            CumulativeReporterBase::testGroupEnded(testGroupStats);
+            writeGroup(*m_testGroups.back());
+        }
+
+        void testRunEndedCumulative() override {
+            xml.endElement();
+        }
+
+        void writeGroup(TestGroupNode const& groupNode) {
+            std::map<std::string, TestGroupNode::ChildNodes> testsPerFile;
+            for(auto const& child : groupNode.children)
+                testsPerFile[child->value.testInfo.lineInfo.file].push_back(child);
+
+            for(auto const& kv : testsPerFile)
+                writeTestFile(kv.first.c_str(), kv.second);
+        }
+
+        void writeTestFile(const char* filename, TestGroupNode::ChildNodes const& testCaseNodes) {
+            XmlWriter::ScopedElement e = xml.scopedElement("file");
+            xml.writeAttribute("path", filename);
+
+            for(auto const& child : testCaseNodes)
+                writeTestCase(*child);
+        }
+
+        void writeTestCase(TestCaseNode const& testCaseNode) {
+            // All test cases have exactly one section - which represents the
+            // test case itself. That section may have 0-n nested sections
+            assert(testCaseNode.children.size() == 1);
+            SectionNode const& rootSection = *testCaseNode.children.front();
+            writeSection("", rootSection, testCaseNode.value.testInfo.okToFail());
+        }
+
+        void writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) {
+            std::string name = trim(sectionNode.stats.sectionInfo.name);
+            if(!rootName.empty())
+                name = rootName + '/' + name;
+
+            if(!sectionNode.assertions.empty() || !sectionNode.stdOut.empty() || !sectionNode.stdErr.empty()) {
+                XmlWriter::ScopedElement e = xml.scopedElement("testCase");
+                xml.writeAttribute("name", name);
+                xml.writeAttribute("duration", static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
+
+                writeAssertions(sectionNode, okToFail);
+            }
+
+            for(auto const& childNode : sectionNode.childSections)
+                writeSection(name, *childNode, okToFail);
+        }
+
+        void writeAssertions(SectionNode const& sectionNode, bool okToFail) {
+            for(auto const& assertion : sectionNode.assertions)
+                writeAssertion( assertion, okToFail);
+        }
+
+        void writeAssertion(AssertionStats const& stats, bool okToFail) {
+            AssertionResult const& result = stats.assertionResult;
+            if(!result.isOk()) {
+                std::string elementName;
+                if(okToFail) {
+                    elementName = "skipped";
+                }
+                else {
+                    switch(result.getResultType()) {
+                        case ResultWas::ThrewException:
+                        case ResultWas::FatalErrorCondition:
+                            elementName = "error";
+                            break;
+                        case ResultWas::ExplicitFailure:
+                            elementName = "failure";
+                            break;
+                        case ResultWas::ExpressionFailed:
+                            elementName = "failure";
+                            break;
+                        case ResultWas::DidntThrowException:
+                            elementName = "failure";
+                            break;
+
+                            // We should never see these here:
+                        case ResultWas::Info:
+                        case ResultWas::Warning:
+                        case ResultWas::Ok:
+                        case ResultWas::Unknown:
+                        case ResultWas::FailureBit:
+                        case ResultWas::Exception:
+                            elementName = "internalError";
+                            break;
+                    }
+                }
+
+                XmlWriter::ScopedElement e = xml.scopedElement(elementName);
+
+                ReusableStringStream messageRss;
+                messageRss << result.getTestMacroName() << "(" << result.getExpression() << ")";
+                xml.writeAttribute("message", messageRss.str());
+
+                ReusableStringStream textRss;
+                if (stats.totals.assertions.total() > 0) {
+                    textRss << "FAILED:\n";
+                    if (result.hasExpression()) {
+                        textRss << "\t" << result.getExpressionInMacro() << "\n";
+                    }
+                    if (result.hasExpandedExpression()) {
+                        textRss << "with expansion:\n\t" << result.getExpandedExpression() << "\n";
+                    }
+                }
+
+                if(!result.getMessage().empty())
+                    textRss << result.getMessage() << "\n";
+
+                for(auto const& msg : stats.infoMessages)
+                    if(msg.type == ResultWas::Info)
+                        textRss << msg.message << "\n";
+
+                textRss << "at " << result.getSourceInfo();
+                xml.writeText(textRss.str(), XmlFormatting::Newline);
+            }
+        }
+
+    private:
+        XmlWriter xml;
+    };
+
+#ifdef CATCH_IMPL
+    SonarQubeReporter::~SonarQubeReporter() {}
+#endif
+
+    CATCH_REGISTER_REPORTER( "sonarqube", SonarQubeReporter )
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
Author	SHA1	Message	Date
Martin Hořeňovský	5f94c8dafb	v2.11.2	2020-03-19 12:37:51 +01:00
Martin Hořeňovský	695a356f93	Move all scripts to Python3	2020-03-19 12:36:30 +01:00
Martin Hořeňovský	020b655635	Update wandbox script to use https endpoint and Python3	2020-03-19 12:32:34 +01:00
Martin Hořeňovský	5561d0342d	Different approach to proper colouring of filters	2020-03-19 11:08:01 +01:00
Till Hofmann	3a15315a37	Switch back to uncolored output after printing filters After printing the list of filters, switch back from yellow to black before printing a newline to avoid the remaining output to be colored in yellow.	2020-03-19 11:08:01 +01:00
Martin Hořeňovský	b7b346c3e5	Make warnings in assertions fire for GCC/Clang again The old code caused warnings to fire under MSVC, and Clang <3.8. I could not find a GCC version where it worked, but I assume that it did at some point. This new code causes all of MSVC, GCC, Clang, in current versions, to emit signed/unsigned comparison warning in test like this: ```cpp TEST_CASE() { int32_t i = -1; uint32_t j = 1; REQUIRE(i != j); } ``` Where previously only MSVC would emit the warning. Fixes #1880	2020-03-19 09:45:41 +01:00
Julius Hülsmann	9e09d79946	Update tutorial.md Fix: typo; remove trailing ","	2020-03-18 15:36:19 +01:00
Julius Hülsmann	7048c2c269	Update slow-compiles.md Add missing "."	2020-03-18 15:35:56 +01:00
magnus.ornebring	6f77d59b16	Add king as user	2020-03-11 09:32:16 +01:00
khyperia	022b61ff92	Don't cast nanoseconds to integers when writing output	2020-03-08 12:10:44 +01:00
khyperia	87b5bf77bc	include <iterator> in catch_stats.hpp needed for std::back_inserter on some platforms	2020-02-24 19:36:34 +01:00
Martin Hořeňovský	81d52c4a5f	Specialize CATCH_TRAP() for iOS + thumb instruction set combo Fixes #1862	2020-02-15 21:45:09 +01:00
Tristan Stenner	200b8b6fc0	Add command line option 'never' to --wait-for-keypress (#1866 ) Co-authored-by: Martin Hořeňovský <martin.horenovsky@gmail.com>	2020-02-15 20:42:57 +01:00
offa	e70fd2a4b9	Variables made const-ref.	2020-02-08 14:27:40 +01:00
offa	36170d60ca	stdio.h replaced with cstdio.	2020-02-08 14:27:40 +01:00
Clare Macrae	917e92c162	Add link to list of commercial user projects	2020-02-07 15:33:55 +01:00
Clare Macrae	f54950744f	Fix typo in link in docs	2020-02-07 15:33:35 +01:00
Martin Hořeňovský	b3b07215d1	Merge pull request #1854 from neheb/patch-1 catch_compiler_capabilities.h: use proper math define	2020-02-03 11:26:31 +01:00
Martin Hořeňovský	2652bb86e3	Cleanup nextafter workaround	2020-02-03 10:05:23 +01:00
Martin Hořeňovský	1715b6b923	Check for Windows instead of WIN32 for wmain entry point Closes #1849	2020-02-03 09:33:42 +01:00
Martin Hořeňovský	f20a9dbc6e	Fix significant bug with storing composed matchers Given that in the 2 or so years that matchers are thing nobody complained, it seems that people do not actually write this sort of code, and the possibility will be removed in v3. However, to avoid correctness bugs, we will have to support this weird code in v2.	2020-02-01 21:06:07 +01:00
Martin Hořeňovský	273c3f85eb	Add missing ToC entry in release notes	2020-02-01 20:24:53 +01:00
Martin Hořeňovský	6a3d0dc176	Add a test for custom debug break macros See #1846	2020-02-01 20:18:05 +01:00
khyperia	ccb1f70629	Make CATCH_BREAK_INTO_DEBUGGER be user-configurable	2020-02-01 17:01:50 +01:00
khyperia	4a5bc0f39a	Make CATCH_BREAK_INTO_DEBUGGER be user-configurable	2020-02-01 12:20:40 +01:00
Rosen Penev	f96e89e016	catch_compiler_capabilities.h: use proper math define C++11 math requires _GLIBCXX_USE_C99_MATH_TR1 to be true with gcc/clang. Also fixes an issue with uClibc-ng where __UCLIBC__ is defined in features.h but that is not included here and is thus no-op.	2020-01-31 22:20:59 -08:00
dmsteck	481f54b357	Make hidden tags behave identically (#1847 ) Add both `[.]` and `[!hide]` tags when registering a hidden test case, as per documentation. Co-authored-by: Martin Hořeňovský <martin.horenovsky@gmail.com>	2020-01-31 21:44:06 +01:00
offa	2d172dc688	Some refactorings: - Overrides added - usages of push_back() replaced with emplace_back() - Loop variable made const-refernce - NULL replaced with nullptr - Names used in the declaration and definition unified - size() replaced with empty - Identical cases merged	2020-01-25 09:01:04 +01:00
Daniel Griscom	587a20b312	Removed unneeded 'using uchar = unsigned char'	2020-01-24 14:26:22 +01:00
Martin Hořeňovský	bff44f8b01	Merge pull request #1831 from matt77hias/master Added <random> include for std::uniform_int_distribution	2020-01-14 14:05:50 +01:00
Matthias Moulin	4ea74ff966	Added <random> include for std::uniform_int_distribution	2020-01-14 12:48:09 +01:00
Martin Hořeňovský	d10b9bd02e	v2.11.1	2019-12-28 21:24:04 +01:00
Martin Hořeňovský	55794e9b27	Avoid detecting Clang as having MSVC's traditional preprocessor Fixes #1806	2019-12-28 18:57:24 +01:00
ptc-tgamper	fa6211bfc2	catch_debugger.h - implement break into debugger assembler instructions for iOS	2019-12-23 21:26:13 +01:00
ptc-tgamper	4e90f910dc	catch_console_colour.cpp - adjust useColourOnPlatform for iOS	2019-12-23 21:26:13 +01:00
ptc-tgamper	0c59cc83cf	catch_debugger.cpp - debugger detection is identical on Mac OS X and iOS	2019-12-23 21:26:13 +01:00
Martin Hořeňovský	e4004e0adb	Provide const overload of ObjectStorage::stored_object() Fixes #1820	2019-12-23 21:22:32 +01:00
Joe Burzinski	6c9a255dc2	Fix forwarding in SingleValueGenerator and generator creation Fixes #1809	2019-12-15 20:50:43 +01:00
Joe Burzinski	9a8963133f	Update single header generation script to warn about unused headers	2019-11-21 16:22:04 +01:00
Joe Burzinski	cfba9dce97	Fix wrong namespacing of benchmarking constructor helpers	2019-11-21 16:22:04 +01:00
Martin Hořeňovský	a537ccae22	Suppress using-namespace lint in GENERATE* macros Closes #1799	2019-11-16 17:39:28 +01:00
Martin Hořeňovský	e1c9d5569d	v2.11.0	2019-11-15 15:06:17 +01:00
Martin Hořeňovský	d512decaac	Mention the sonarqube reporter in release process	2019-11-15 14:59:35 +01:00
Martin Hořeňovský	f23f96883a	Ensure the full benchmarking support is present in the single header Fixes #1800	2019-11-15 11:59:43 +01:00
Martin Hořeňovský	d7b8c3ace3	Minor cleanup in the benchmarking tests	2019-11-15 11:59:35 +01:00
Martin Hořeňovský	32733e08c0	Use newer version of Python on AppVeyor	2019-11-13 20:58:15 +01:00
Martin Hořeňovský	930f49a641	Split [.foo] into [.][foo] when parsing test specs `b77cec05c0` fixed this problem for tagging tests, so that a test case tagged with `[.foo]` would be parsed as tagged with `[.][foo]`. This does the same for the test spec parsing. Fixes #1798	2019-11-05 23:28:47 +01:00
Martin Hořeňovský	c409dccee5	Cleanup tests for C++20	2019-11-04 10:42:34 +01:00
Martin Hořeňovský	95bfb33167	Forbid copying ReusableStringStream Copying a `ReusableStringStream` would lead to "double free" of the stream, and thus it could be used in multiple places at the same time, breaking the output.	2019-11-04 00:05:35 +01:00
Martin Hořeňovský	59d2d08c0f	Merge pull request #1794 from cericks0n/patch-1 Fix error when period of steady_clock is not nano	2019-11-03 18:22:56 +01:00
cericks0n	fa6d52e2a3	Fix error when period of steady_clock is not nano On systems where std::chrono::steady_clock::period is not std::nano, benchmark tests fail to compile due to trying to convert analysis.samples from a vector of duration<double, clock::period> to a vector of std::chrono::duration<double, std::nano>.	2019-11-01 15:52:38 -05:00
Martin Hořeňovský	5ac348cd6e	Fix compilation error in examples	2019-10-31 16:08:37 +01:00
Martin Hořeňovský	776a4686c7	Warning fixes in examples and tests	2019-10-31 14:29:59 +01:00