Progmasoft Git

catch3

Progmasoft Catch3: an independently maintained C++17 test framework with a parallel runner, property checks, snapshots and structured results.

Clonegit clone https://git.progmasoft.com/catch3

Add support for multiple parallel reporters

This requires a bunch of different changes across the reporter
subsystem.

* We need to handle multiple reporters and their differing
  preferences in `ListeningReporter`, e.g. what to do when
  we mix reporters that capture and don't capture stdout.
* We need to change how the reporter is given output and
  how we parse reporter's output destination from CLI.
* Approval tests need to handle multireporter option
Commit
ccd67b293d7595a0cf2dc6c4bfb2017fc18c1f14
Author
Martin Jeřábek ·
Committer
Martin Hořeňovský
Parents
6b55f5d780c5

Files · Download .tar.gz

Changes

 docs/command-line.md                               |    15 +-
 docs/reporters.md                                  |    15 +-
 src/catch2/catch_config.cpp                        |    67 +-
 src/catch2/catch_config.hpp                        |    33 +-
 src/catch2/catch_session.cpp                       |    20 +-
 src/catch2/interfaces/catch_interfaces_config.hpp  |     2 +-
 .../interfaces/catch_interfaces_reporter.cpp       |     3 -
 .../interfaces/catch_interfaces_reporter.hpp       |     2 -
 .../catch_interfaces_reporter_registry.hpp         |     3 +-
 src/catch2/internal/catch_commandline.cpp          |    60 +-
 src/catch2/internal/catch_console_colour.cpp       |     2 +-
 src/catch2/internal/catch_reporter_registry.cpp    |     4 +-
 src/catch2/internal/catch_reporter_registry.hpp    |     2 +-
 src/catch2/reporters/catch_reporter_listening.cpp  |   153 +-
 src/catch2/reporters/catch_reporter_listening.hpp  |    17 +-
 .../Baselines/automake.sw.multi.approved.txt       |   380 +
 tests/SelfTest/Baselines/compact.sw.approved.txt   |    47 +-
 .../Baselines/compact.sw.multi.approved.txt        |  2480 +++
 tests/SelfTest/Baselines/console.std.approved.txt  |     2 +-
 tests/SelfTest/Baselines/console.sw.approved.txt   |   179 +-
 .../Baselines/console.sw.multi.approved.txt        | 17650 ++++++++++++++++
 .../Baselines/default.sw.multi.approved.txt        |     8 +
 tests/SelfTest/Baselines/junit.sw.approved.txt     |     9 +-
 .../SelfTest/Baselines/junit.sw.multi.approved.txt |  1902 ++
 tests/SelfTest/Baselines/sonarqube.sw.approved.txt |     7 +-
 .../Baselines/sonarqube.sw.multi.approved.txt      |  1920 ++
 tests/SelfTest/Baselines/tap.sw.approved.txt       |    46 +-
 tests/SelfTest/Baselines/tap.sw.multi.approved.txt |  4416 ++++
 .../Baselines/teamcity.sw.multi.approved.txt       |   922 +
 tests/SelfTest/Baselines/xml.sw.approved.txt       |   219 +-
 tests/SelfTest/Baselines/xml.sw.multi.approved.txt | 20738 +++++++++++++++++++
 .../SelfTest/IntrospectiveTests/CmdLine.tests.cpp  |    64 +-
 tools/scripts/approvalTests.py                     |    45 +-
 33 files changed, 51221 insertions(+), 211 deletions(-)

diff --git a/docs/command-line.md b/docs/command-line.md
index b03e7e3c..0bc7744b 100644
--- a/docs/command-line.md
+++ b/docs/command-line.md
@@ -123,7 +123,7 @@ Test names containing special characters, such as `,` or `[` can specify them on
 <a id="choosing-a-reporter-to-use"></a>
 ## Choosing a reporter to use
 
-<pre>-r, --reporter &lt;reporter></pre>
+<pre>-r, --reporter &lt;reporter[::output-file]&gt;</pre>
 
 A reporter is an object that formats and structures the output of running tests, and potentially summarises the results. By default a console reporter is used that writes, IDE friendly, textual output. Catch comes bundled with some alternative reporters, but more can be added in client code.<br />
 The bundled reporters are:
@@ -136,6 +136,13 @@ The bundled reporters are:
 
 The JUnit reporter is an xml format that follows the structure of the JUnit XML Report ANT task, as consumed by a number of third-party tools, including Continuous Integration servers such as Jenkins. If not otherwise needed, the standard XML reporter is preferred as this is a streaming reporter, whereas the Junit reporter needs to hold all its results until the end so it can write the overall results into attributes of the root node.
 
+This option may be passed multiple times to use multiple (different) reporters  at the same time. See [Reporters](reporters.md#multiple-reporters) for details.
+
+_Note: There is currently no way to escape `::` in the reporter spec,
+and thus reporter/file names with `::` in them will not work properly.
+As `::` in paths is relatively obscure (unlike `:`), we do not consider
+this an issue._
+
 <a id="breaking-into-the-debugger"></a>
 ## Breaking into the debugger
 <pre>-b, --break</pre>
@@ -178,7 +185,7 @@ If one or more test-specs have been supplied too then only the matching tests wi
 
 <a id="sending-output-to-a-file"></a>
 ## Sending output to a file
-<pre>-o, --out &lt;filename>
+<pre>-o, --out &lt;filename&gt;
 </pre>
 
 Use this option to send all output to a file. By default output is sent to stdout (note that uses of stdout and stderr *from within test cases* are redirected and included in the report - so even stderr will effectively end up on stdout).
@@ -414,7 +421,7 @@ There are some limitations of this feature to be aware of:
 - Code outside of sections being skipped will still be executed - e.g. any set-up code in the TEST_CASE before the
 start of the first section.</br>
 - At time of writing, wildcards are not supported in section names.
-- If you specify a section without narrowing to a test case first then all test cases will be executed 
+- If you specify a section without narrowing to a test case first then all test cases will be executed
 (but only matching sections within them).
 
 
@@ -422,7 +429,7 @@ start of the first section.</br>
 ## Filenames as tags
 <pre>-#, --filenames-as-tags</pre>
 
-When this option is used then every test is given an additional tag which is formed of the unqualified 
+When this option is used then every test is given an additional tag which is formed of the unqualified
 filename it is found in, with any extension stripped, prefixed with the `#` character.
 
 So, for example,  tests within the file `~\Dev\MyProject\Ferrets.cpp` would be tagged `[#Ferrets]`.
diff --git a/docs/reporters.md b/docs/reporters.md
index a33e55bf..81baa308 100644
--- a/docs/reporters.md
+++ b/docs/reporters.md
@@ -19,13 +19,13 @@ There are four reporters built in to the single include:
 * `console` writes as lines of text, formatted to a typical terminal width, with colours if a capable terminal is detected.
 * `compact` similar to `console` but optimised for minimal output - each entry on one line
 * `junit` writes xml that corresponds to Ant's [junitreport](http://help.catchsoftware.com/display/ET/JUnit+Format) target. Useful for build systems that understand Junit.
-Because of the way the junit format is structured the run must complete before anything is written. 
+Because of the way the junit format is structured the run must complete before anything is written.
 * `xml` writes an xml format tailored to Catch. Unlike `junit` this is a streaming format so results are delivered progressively.
 
 There are a few additional reporters, for specific build systems, in the Catch repository (in `include\reporters`) which you can `#include` in your project if you would like to make use of them.
 Do this in one source file - the same one you have `CATCH_CONFIG_MAIN` or `CATCH_CONFIG_RUNNER`.
 
-* `teamcity` writes the native, streaming, format that [TeamCity](https://www.jetbrains.com/teamcity/) understands. 
+* `teamcity` writes the native, streaming, format that [TeamCity](https://www.jetbrains.com/teamcity/) understands.
 Use this when building as part of a TeamCity build to see results as they happen ([code example](../examples/207-Rpt-TeamCityReporter.cpp)).
 * `tap` writes in the TAP ([Test Anything Protocol](https://en.wikipedia.org/wiki/Test_Anything_Protocol)) format.
 * `automake` writes in a format that correspond to [automake  .trs](https://www.gnu.org/software/automake/manual/html_node/Log-files-generation-and-test-results-recording.html) files
@@ -35,6 +35,17 @@ You see what reporters are available from the command line by running with `--li
 
 By default all these reports are written to stdout, but can be redirected to a file with [`-o` or `--out`](command-line.md#sending-output-to-a-file)
 
+<a id="multiple-reporters"></a>
+## Using multiple reporters
+
+Multiple reporters may be used at the same time, e.g. to save a machine-readable output to a file but still print the human-readable output to the console:
+```
+-r console -r xml::result.xml -r junit::result-junit.xml
+```
+
+The output file name is given after the reporter name, delimited by a colon. If omitted, it defaults to the file name specified by `-o` (or stdout). Only one reporter may use the default output.
+
+
 ## Writing your own reporter
 
 You can write your own custom reporter and register it with Catch.
diff --git a/src/catch2/catch_config.cpp b/src/catch2/catch_config.cpp
index da9457da..c507b1b6 100644
--- a/src/catch2/catch_config.cpp
+++ b/src/catch2/catch_config.cpp
@@ -13,13 +13,39 @@
 #include <catch2/internal/catch_test_spec_parser.hpp>
 #include <catch2/interfaces/catch_interfaces_tag_alias_registry.hpp>
 
+#include <ostream>
 
 namespace Catch {
+    namespace Detail {
+        namespace {
+            class RDBufStream : public IStream {
+                mutable std::ostream m_os;
+
+            public:
+                //! The streambuf `sb` must outlive the constructed object.
+                RDBufStream( std::streambuf* sb ): m_os( sb ) {}
+                ~RDBufStream() override = default;
+
+            public: // IStream
+                std::ostream& stream() const override { return m_os; }
+            };
+        } // unnamed namespace
+    }     // namespace Detail
+
+    std::ostream& operator<<( std::ostream& os,
+                              ConfigData::ReporterAndFile const& reporter ) {
+        os << "{ " << reporter.reporterName << ", ";
+        if ( reporter.outputFileName ) {
+            os << *reporter.outputFileName;
+        } else {
+            os << "<default-output>";
+        }
+        return os << " }";
+    }
 
-    Config::Config( ConfigData const& data )
-    :   m_data( data ),
-        m_stream( Catch::makeStream(m_data.outputFilename) )
-    {
+    Config::Config( ConfigData const& data ):
+        m_data( data ),
+        m_defaultStream( openStream( data.defaultOutputFilename ) ) {
         // We need to trim filter specs to avoid trouble with superfluous
         // whitespace (esp. important for bdd macros, as those are manually
         // aligned with whitespace).
@@ -39,24 +65,37 @@ namespace Catch {
             }
         }
         m_testSpec = parser.testSpec();
+
+        m_reporterStreams.reserve( m_data.reporterSpecifications.size() );
+        for ( auto const& reporterAndFile : m_data.reporterSpecifications ) {
+            if ( reporterAndFile.outputFileName.none() ) {
+                m_reporterStreams.emplace_back( new Detail::RDBufStream(
+                    m_defaultStream->stream().rdbuf() ) );
+            } else {
+                m_reporterStreams.emplace_back(
+                    openStream( *reporterAndFile.outputFileName ) );
+            }
+        }
     }
 
     Config::~Config() = default;
 
 
-    std::string const& Config::getFilename() const {
-        return m_data.outputFilename ;
-    }
-
     bool Config::listTests() const          { return m_data.listTests; }
     bool Config::listTags() const           { return m_data.listTags; }
     bool Config::listReporters() const      { return m_data.listReporters; }
 
-    std::string const& Config::getReporterName() const { return m_data.reporterName; }
-
     std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
     std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
 
+    std::vector<ConfigData::ReporterAndFile> const& Config::getReportersAndOutputFiles() const {
+        return m_data.reporterSpecifications;
+    }
+
+    std::ostream& Config::getReporterOutputStream(std::size_t reporterIdx) const {
+        return m_reporterStreams.at(reporterIdx)->stream();
+    }
+
     TestSpec const& Config::testSpec() const { return m_testSpec; }
     bool Config::hasTestFilters() const { return m_hasTestFilters; }
 
@@ -64,8 +103,8 @@ namespace Catch {
 
     // IConfig interface
     bool Config::allowThrows() const                   { return !m_data.noThrow; }
-    std::ostream& Config::stream() const               { return m_stream->stream(); }
-    StringRef Config::name() const                     { return m_data.name.empty() ? m_data.processName : m_data.name; }
+    std::ostream& Config::defaultStream() const        { return m_defaultStream->stream(); }
+    StringRef Config::name() const { return m_data.name.empty() ? m_data.processName : m_data.name; }
     bool Config::includeSuccessfulResults() const      { return m_data.showSuccessfulTests; }
     bool Config::warnAboutMissingAssertions() const {
         return !!( m_data.warnings & WarnAbout::NoAssertions );
@@ -92,4 +131,8 @@ namespace Catch {
     unsigned int Config::benchmarkResamples() const               { return m_data.benchmarkResamples; }
     std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
 
+    Detail::unique_ptr<IStream const> Config::openStream(std::string const& outputFileName) {
+        return Catch::makeStream(outputFileName);
+    }
+
 } // end namespace Catch
diff --git a/src/catch2/catch_config.hpp b/src/catch2/catch_config.hpp
index 2b881f6b..1aaa9828 100644
--- a/src/catch2/catch_config.hpp
+++ b/src/catch2/catch_config.hpp
@@ -14,6 +14,7 @@
 #include <catch2/internal/catch_optional.hpp>
 #include <catch2/internal/catch_random_seed_generation.hpp>
 
+#include <iosfwd>
 #include <vector>
 #include <string>
 
@@ -22,6 +23,18 @@ namespace Catch {
     struct IStream;
 
     struct ConfigData {
+        struct ReporterAndFile {
+            std::string reporterName;
+
+            // If none, the output goes to the default output.
+            Optional<std::string> outputFileName;
+
+            friend bool operator==(ReporterAndFile const& lhs, ReporterAndFile const& rhs) {
+                return lhs.reporterName == rhs.reporterName && lhs.outputFileName == rhs.outputFileName;
+            }
+            friend std::ostream& operator<<(std::ostream &os, ReporterAndFile const& reporter);
+        };
+
         bool listTests = false;
         bool listTags = false;
         bool listReporters = false;
@@ -55,13 +68,17 @@ namespace Catch {
         UseColour useColour = UseColour::Auto;
         WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
 
-        std::string outputFilename;
+        std::string defaultOutputFilename;
         std::string name;
         std::string processName;
 #ifndef CATCH_CONFIG_DEFAULT_REPORTER
 #define CATCH_CONFIG_DEFAULT_REPORTER "console"
 #endif
-        std::string reporterName = CATCH_CONFIG_DEFAULT_REPORTER;
+        std::vector<ReporterAndFile> reporterSpecifications = {
+            {CATCH_CONFIG_DEFAULT_REPORTER, {}}
+        };
+        // Internal: used as parser state
+        bool _nonDefaultReporterSpecifications = false;
 #undef CATCH_CONFIG_DEFAULT_REPORTER
 
         std::vector<std::string> testsOrTags;
@@ -76,13 +93,12 @@ namespace Catch {
         Config( ConfigData const& data );
         ~Config() override; // = default in the cpp file
 
-        std::string const& getFilename() const;
-
         bool listTests() const;
         bool listTags() const;
         bool listReporters() const;
 
-        std::string const& getReporterName() const;
+        std::vector<ConfigData::ReporterAndFile> const& getReportersAndOutputFiles() const;
+        std::ostream& getReporterOutputStream(std::size_t reporterIdx) const;
 
         std::vector<std::string> const& getTestsOrTags() const override;
         std::vector<std::string> const& getSectionsToRun() const override;
@@ -94,7 +110,7 @@ namespace Catch {
 
         // IConfig interface
         bool allowThrows() const override;
-        std::ostream& stream() const override;
+        std::ostream& defaultStream() const override;
         StringRef name() const override;
         bool includeSuccessfulResults() const override;
         bool warnAboutMissingAssertions() const override;
@@ -118,13 +134,14 @@ namespace Catch {
         std::chrono::milliseconds benchmarkWarmupTime() const override;
 
     private:
+        Detail::unique_ptr<IStream const> openStream(std::string const& outputFileName);
         ConfigData m_data;
 
-        Detail::unique_ptr<IStream const> m_stream;
+        Detail::unique_ptr<IStream const> m_defaultStream;
+        std::vector<Detail::unique_ptr<IStream const>> m_reporterStreams;
         TestSpec m_testSpec;
         bool m_hasTestFilters = false;
     };
-
 } // end namespace Catch
 
 #endif // CATCH_CONFIG_HPP_INCLUDED
diff --git a/src/catch2/catch_session.cpp b/src/catch2/catch_session.cpp
index 38111fe8..2325bf2f 100644
--- a/src/catch2/catch_session.cpp
+++ b/src/catch2/catch_session.cpp
@@ -34,7 +34,7 @@ namespace Catch {
     namespace {
         const int MaxExitCode = 255;
 
-        IStreamingReporterPtr createReporter(std::string const& reporterName, IConfig const* config) {
+        IStreamingReporterPtr createReporter(std::string const& reporterName, ReporterConfig const& config) {
             auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, config);
             CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << '\'');
 
@@ -42,16 +42,26 @@ namespace Catch {
         }
 
         IStreamingReporterPtr makeReporter(Config const* config) {
-            if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()) {
-                return createReporter(config->getReporterName(), config);
+            if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()
+                    && config->getReportersAndOutputFiles().size() == 1) {
+                auto& stream = config->getReporterOutputStream(0);
+                return createReporter(config->getReportersAndOutputFiles()[0].reporterName, ReporterConfig(config, stream));
             }
 
             auto multi = Detail::make_unique<ListeningReporter>(config);
+
             auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
             for (auto const& listener : listeners) {
-                multi->addListener(listener->create(Catch::ReporterConfig(config)));
+                multi->addListener(listener->create(Catch::ReporterConfig(config, config->defaultStream())));
+            }
+
+            std::size_t reporterIdx = 0;
+            for (auto const& reporterAndFile : config->getReportersAndOutputFiles()) {
+                auto& stream = config->getReporterOutputStream(reporterIdx);
+                multi->addReporter(createReporter(reporterAndFile.reporterName, ReporterConfig(config, stream)));
+                reporterIdx++;
             }
-            multi->addReporter(createReporter(config->getReporterName(), config));
+
             return multi;
         }
 
diff --git a/src/catch2/interfaces/catch_interfaces_config.hpp b/src/catch2/interfaces/catch_interfaces_config.hpp
index b8da0df0..4b2bd365 100644
--- a/src/catch2/interfaces/catch_interfaces_config.hpp
+++ b/src/catch2/interfaces/catch_interfaces_config.hpp
@@ -61,7 +61,7 @@ namespace Catch {
         virtual ~IConfig();
 
         virtual bool allowThrows() const = 0;
-        virtual std::ostream& stream() const = 0;
+        virtual std::ostream& defaultStream() const = 0;
         virtual StringRef name() const = 0;
         virtual bool includeSuccessfulResults() const = 0;
         virtual bool shouldDebugBreak() const = 0;
diff --git a/src/catch2/interfaces/catch_interfaces_reporter.cpp b/src/catch2/interfaces/catch_interfaces_reporter.cpp
index 89a86f59..5439254c 100644
--- a/src/catch2/interfaces/catch_interfaces_reporter.cpp
+++ b/src/catch2/interfaces/catch_interfaces_reporter.cpp
@@ -20,9 +20,6 @@
 
 namespace Catch {
 
-    ReporterConfig::ReporterConfig( IConfig const* _fullConfig )
-    :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
-
     ReporterConfig::ReporterConfig( IConfig const* _fullConfig, std::ostream& _stream )
     :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
 
diff --git a/src/catch2/interfaces/catch_interfaces_reporter.hpp b/src/catch2/interfaces/catch_interfaces_reporter.hpp
index 5d3e85a3..432bc4e5 100644
--- a/src/catch2/interfaces/catch_interfaces_reporter.hpp
+++ b/src/catch2/interfaces/catch_interfaces_reporter.hpp
@@ -32,8 +32,6 @@ namespace Catch {
     struct IConfig;
 
     struct ReporterConfig {
-        explicit ReporterConfig( IConfig const* _fullConfig );
-
         ReporterConfig( IConfig const* _fullConfig, std::ostream& _stream );
 
         std::ostream& stream() const;
diff --git a/src/catch2/interfaces/catch_interfaces_reporter_registry.hpp b/src/catch2/interfaces/catch_interfaces_reporter_registry.hpp
index 57c652e7..582c39b4 100644
--- a/src/catch2/interfaces/catch_interfaces_reporter_registry.hpp
+++ b/src/catch2/interfaces/catch_interfaces_reporter_registry.hpp
@@ -23,13 +23,14 @@ namespace Catch {
     using IStreamingReporterPtr = Detail::unique_ptr<IStreamingReporter>;
     struct IReporterFactory;
     using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
+    struct ReporterConfig;
 
     struct IReporterRegistry {
         using FactoryMap = std::map<std::string, IReporterFactoryPtr, Detail::CaseInsensitiveLess>;
         using Listeners = std::vector<IReporterFactoryPtr>;
 
         virtual ~IReporterRegistry(); // = default
-        virtual IStreamingReporterPtr create( std::string const& name, IConfig const* config ) const = 0;
+        virtual IStreamingReporterPtr create( std::string const& name, ReporterConfig const& config ) const = 0;
         virtual FactoryMap const& getFactories() const = 0;
         virtual Listeners const& getListeners() const = 0;
     };
diff --git a/src/catch2/internal/catch_commandline.cpp b/src/catch2/internal/catch_commandline.cpp
index de27e899..4ce085ca 100644
--- a/src/catch2/internal/catch_commandline.cpp
+++ b/src/catch2/internal/catch_commandline.cpp
@@ -14,6 +14,7 @@
 #include <catch2/interfaces/catch_interfaces_reporter_registry.hpp>
 #include <catch2/interfaces/catch_interfaces_reporter.hpp>
 
+#include <algorithm>
 #include <fstream>
 #include <string>
 
@@ -133,15 +134,56 @@ namespace Catch {
                 return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + '\'' );
             return ParserResult::ok( ParseResultType::Matched );
         };
-        auto const setReporter = [&]( std::string const& reporter ) {
+        auto const setReporter = [&]( std::string const& reporterSpec ) {
             IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
 
-            auto result = factories.find( reporter );
+            // clear the default reporter
+            if (!config._nonDefaultReporterSpecifications) {
+                config.reporterSpecifications.clear();
+                config._nonDefaultReporterSpecifications = true;
+            }
+
+            // Exactly one of the reporters may be specified without an output
+            // file, in which case it defaults to the output specified by "-o"
+            // (or standard output).
+            static constexpr auto separator = "::";
+            static constexpr size_t separatorSize = 2;
+            auto separatorPos = reporterSpec.find( separator );
+            const bool containsFileName = separatorPos != reporterSpec.npos;
+            std::string reporterName;
+            Optional<std::string> outputFileName;
+            if (!containsFileName) {
+                reporterName = reporterSpec;
+            } else {
+                reporterName = reporterSpec.substr( 0, separatorPos );
+                outputFileName = reporterSpec.substr(
+                    separatorPos + separatorSize, reporterSpec.size() );
+            }
+
+            auto result = factories.find( reporterName );
+
+            if( result == factories.end() )
+                return ParserResult::runtimeError( "Unrecognized reporter, '" + reporterName + "'. Check available with --list-reporters" );
+            if( containsFileName && outputFileName->empty() )
+                return ParserResult::runtimeError( "Reporter '" + reporterName + "' has empty filename specified as its output. Supply a filename or remove the colons to use the default output." );
+
+            config.reporterSpecifications.push_back({ std::move(reporterName), std::move(outputFileName) });
+
+            // It would be enough to check this only once at the very end, but there is
+            // not a place where we could call this check, so do it every time it could fail.
+            // For valid inputs, this is still called at most once.
+            if (!containsFileName) {
+                int n_reporters_without_file = 0;
+                for (auto const& spec : config.reporterSpecifications) {
+                    if (spec.outputFileName.none()) {
+                        n_reporters_without_file++;
+                    }
+                }
+                if (n_reporters_without_file > 1) {
+                    return ParserResult::runtimeError( "Only one reporter may have unspecified output file." );
+                }
+            }
 
-            if( factories.end() != result )
-                config.reporterName = reporter;
-            else
-                return ParserResult::runtimeError( "Unrecognized reporter, '" + reporter + "'. Check available with --list-reporters" );
             return ParserResult::ok( ParseResultType::Matched );
         };
         auto const setShardCount = [&]( std::string const& shardCount ) {
@@ -202,10 +244,10 @@ namespace Catch {
             | Opt( config.showInvisibles )
                 ["-i"]["--invisibles"]
                 ( "show invisibles (tabs, newlines)" )
-            | Opt( config.outputFilename, "filename" )
+            | Opt( config.defaultOutputFilename, "filename" )
                 ["-o"]["--out"]
-                ( "output filename" )
-            | Opt( setReporter, "name" )
+                ( "default output filename" )
+            | Opt( accept_many, setReporter, "name[:output-file]" )
                 ["-r"]["--reporter"]
                 ( "reporter to use (defaults to console)" )
             | Opt( config.name, "name" )
diff --git a/src/catch2/internal/catch_console_colour.cpp b/src/catch2/internal/catch_console_colour.cpp
index e524b0ba..069c5fbe 100644
--- a/src/catch2/internal/catch_console_colour.cpp
+++ b/src/catch2/internal/catch_console_colour.cpp
@@ -159,7 +159,7 @@ namespace {
         void setColour( const char* _escapeCode ) {
             // The escape sequence must be flushed to console, otherwise if
             // stdin and stderr are intermixed, we'd get accidentally coloured output.
-            getCurrentContext().getConfig()->stream()
+            getCurrentContext().getConfig()->defaultStream()
                 << '\033' << _escapeCode << std::flush;
         }
     };
diff --git a/src/catch2/internal/catch_reporter_registry.cpp b/src/catch2/internal/catch_reporter_registry.cpp
index 617c550a..26a328f8 100644
--- a/src/catch2/internal/catch_reporter_registry.cpp
+++ b/src/catch2/internal/catch_reporter_registry.cpp
@@ -36,11 +36,11 @@ namespace Catch {
     ReporterRegistry::~ReporterRegistry() = default;
 
 
-    IStreamingReporterPtr ReporterRegistry::create( std::string const& name, IConfig const* config ) const {
+    IStreamingReporterPtr ReporterRegistry::create( std::string const& name, ReporterConfig const& config ) const {
         auto it =  m_factories.find( name );
         if( it == m_factories.end() )
             return nullptr;
-        return it->second->create( ReporterConfig( config ) );
+        return it->second->create( config );
     }
 
     void ReporterRegistry::registerReporter( std::string const& name, IReporterFactoryPtr factory ) {
diff --git a/src/catch2/internal/catch_reporter_registry.hpp b/src/catch2/internal/catch_reporter_registry.hpp
index 62c2023e..a761e7cf 100644
--- a/src/catch2/internal/catch_reporter_registry.hpp
+++ b/src/catch2/internal/catch_reporter_registry.hpp
@@ -21,7 +21,7 @@ namespace Catch {
         ReporterRegistry();
         ~ReporterRegistry() override; // = default, out of line to allow fwd decl
 
-        IStreamingReporterPtr create( std::string const& name, IConfig const* config ) const override;
+        IStreamingReporterPtr create( std::string const& name, ReporterConfig const& config ) const override;
 
         void registerReporter( std::string const& name, IReporterFactoryPtr factory );
         void registerListener( IReporterFactoryPtr factory );
diff --git a/src/catch2/reporters/catch_reporter_listening.cpp b/src/catch2/reporters/catch_reporter_listening.cpp
index 10176055..a08e5d59 100644
--- a/src/catch2/reporters/catch_reporter_listening.cpp
+++ b/src/catch2/reporters/catch_reporter_listening.cpp
@@ -6,170 +6,185 @@
 
 // SPDX-License-Identifier: BSL-1.0
 #include <catch2/reporters/catch_reporter_listening.hpp>
+
+#include <catch2/catch_config.hpp>
 #include <catch2/internal/catch_move_and_forward.hpp>
+#include <catch2/internal/catch_stream.hpp>
 
 #include <cassert>
 
 namespace Catch {
+    void ListeningReporter::updatePreferences(IStreamingReporter const& reporterish) {
+        m_preferences.shouldRedirectStdOut |=
+            reporterish.getPreferences().shouldRedirectStdOut;
+        m_preferences.shouldReportAllAssertions |=
+            reporterish.getPreferences().shouldReportAllAssertions;
+    }
 
     void ListeningReporter::addListener( IStreamingReporterPtr&& listener ) {
-        m_listeners.push_back( CATCH_MOVE( listener ) );
+        updatePreferences(*listener);
+        m_reporterLikes.insert(m_reporterLikes.begin() + m_insertedListeners, CATCH_MOVE(listener) );
+        ++m_insertedListeners;
     }
 
-    void ListeningReporter::addReporter(IStreamingReporterPtr&& reporter) {
-        assert(!m_reporter && "Listening reporter can wrap only 1 real reporter");
-        m_reporter = CATCH_MOVE( reporter );
-        m_preferences.shouldRedirectStdOut = m_reporter->getPreferences().shouldRedirectStdOut;
+    void ListeningReporter::addReporter( IStreamingReporterPtr&& reporter ) {
+        updatePreferences(*reporter);
+
+        // We will need to output the captured stdout if there are reporters
+        // that do not want it captured.
+        // We do not consider listeners, because it is generally assumed that
+        // listeners are output-transparent, even though they can ask for stdout
+        // capture to do something with it.
+        m_haveNoncapturingReporters |= !reporter->getPreferences().shouldRedirectStdOut;
+
+        // Reporters can always be placed to the back without breaking the
+        // reporting order
+        m_reporterLikes.push_back( CATCH_MOVE( reporter ) );
     }
 
     void ListeningReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
-        for ( auto& listener : m_listeners ) {
-            listener->noMatchingTestCases( unmatchedSpec );
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->noMatchingTestCases( unmatchedSpec );
         }
-        m_reporter->noMatchingTestCases( unmatchedSpec );
     }
 
     void ListeningReporter::fatalErrorEncountered( StringRef error ) {
-        for ( auto& listener : m_listeners ) {
-            listener->fatalErrorEncountered( error );
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->fatalErrorEncountered( error );
         }
-        m_reporter->fatalErrorEncountered( error );
     }
 
     void ListeningReporter::reportInvalidTestSpec( StringRef arg ) {
-        for ( auto& listener : m_listeners ) {
-            listener->reportInvalidTestSpec( arg );
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->reportInvalidTestSpec( arg );
         }
-        m_reporter->reportInvalidTestSpec( arg );
     }
 
     void ListeningReporter::benchmarkPreparing( StringRef name ) {
-        for (auto& listener : m_listeners) {
-            listener->benchmarkPreparing(name);
+        for (auto& reporterish : m_reporterLikes) {
+            reporterish->benchmarkPreparing(name);
         }
-        m_reporter->benchmarkPreparing(name);
     }
     void ListeningReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
-        for ( auto& listener : m_listeners ) {
-            listener->benchmarkStarting( benchmarkInfo );
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->benchmarkStarting( benchmarkInfo );
         }
-        m_reporter->benchmarkStarting( benchmarkInfo );
     }
     void ListeningReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
-        for ( auto& listener : m_listeners ) {
-            listener->benchmarkEnded( benchmarkStats );
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->benchmarkEnded( benchmarkStats );
         }
-        m_reporter->benchmarkEnded( benchmarkStats );
     }
 
     void ListeningReporter::benchmarkFailed( StringRef error ) {
-        for (auto& listener : m_listeners) {
-            listener->benchmarkFailed(error);
+        for (auto& reporterish : m_reporterLikes) {
+            reporterish->benchmarkFailed(error);
         }
-        m_reporter->benchmarkFailed(error);
     }
 
     void ListeningReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
-        for ( auto& listener : m_listeners ) {
-            listener->testRunStarting( testRunInfo );
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->testRunStarting( testRunInfo );
         }
-        m_reporter->testRunStarting( testRunInfo );
     }
 
     void ListeningReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
-        for ( auto& listener : m_listeners ) {
-            listener->testCaseStarting( testInfo );
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->testCaseStarting( testInfo );
         }
-        m_reporter->testCaseStarting( testInfo );
     }
 
     void
     ListeningReporter::testCasePartialStarting( TestCaseInfo const& testInfo,
                                                 uint64_t partNumber ) {
-        for ( auto& listener : m_listeners ) {
-            listener->testCasePartialStarting( testInfo, partNumber );
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->testCasePartialStarting( testInfo, partNumber );
         }
-        m_reporter->testCasePartialStarting( testInfo, partNumber );
     }
 
     void ListeningReporter::sectionStarting( SectionInfo const& sectionInfo ) {
-        for ( auto& listener : m_listeners ) {
-            listener->sectionStarting( sectionInfo );
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->sectionStarting( sectionInfo );
         }
-        m_reporter->sectionStarting( sectionInfo );
     }
 
     void ListeningReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
-        for ( auto& listener : m_listeners ) {
-            listener->assertionStarting( assertionInfo );
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->assertionStarting( assertionInfo );
         }
-        m_reporter->assertionStarting( assertionInfo );
     }
 
     // The return value indicates if the messages buffer should be cleared:
     void ListeningReporter::assertionEnded( AssertionStats const& assertionStats ) {
-        for( auto& listener : m_listeners ) {
-            listener->assertionEnded( assertionStats );
+        const bool reportByDefault =
+            assertionStats.assertionResult.getResultType() != ResultWas::Ok ||
+            m_config->includeSuccessfulResults();
+
+        for ( auto & reporterish : m_reporterLikes ) {
+            if ( reportByDefault ||
+                 reporterish->getPreferences().shouldReportAllAssertions ) {
+                    reporterish->assertionEnded( assertionStats );
+            }
         }
-        m_reporter->assertionEnded( assertionStats );
     }
 
     void ListeningReporter::sectionEnded( SectionStats const& sectionStats ) {
-        for ( auto& listener : m_listeners ) {
-            listener->sectionEnded( sectionStats );
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->sectionEnded( sectionStats );
         }
-        m_reporter->sectionEnded( sectionStats );
     }
 
-    void ListeningReporter::testCasePartialEnded( TestCaseStats const& testInfo,
+    void ListeningReporter::testCasePartialEnded( TestCaseStats const& testStats,
                                                   uint64_t partNumber ) {
-        for ( auto& listener : m_listeners ) {
-            listener->testCasePartialEnded( testInfo, partNumber );
+        // TODO: Fix handling of stderr/stdout?
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->testCasePartialEnded( testStats, partNumber );
         }
-        m_reporter->testCasePartialEnded( testInfo, partNumber );
     }
 
     void ListeningReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        for ( auto& listener : m_listeners ) {
-            listener->testCaseEnded( testCaseStats );
+        if ( m_preferences.shouldRedirectStdOut && m_haveNoncapturingReporters ) {
+            if ( !testCaseStats.stdOut.empty() ) {
+                Catch::cout() << testCaseStats.stdOut << std::flush;
+            }
+            if ( !testCaseStats.stdErr.empty() ) {
+                Catch::cerr() << testCaseStats.stdErr << std::flush;
+            }
+        }
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->testCaseEnded( testCaseStats );
         }
-        m_reporter->testCaseEnded( testCaseStats );
     }
 
     void ListeningReporter::testRunEnded( TestRunStats const& testRunStats ) {
-        for ( auto& listener : m_listeners ) {
-            listener->testRunEnded( testRunStats );
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->testRunEnded( testRunStats );
         }
-        m_reporter->testRunEnded( testRunStats );
     }
 
 
     void ListeningReporter::skipTest( TestCaseInfo const& testInfo ) {
-        for ( auto& listener : m_listeners ) {
-            listener->skipTest( testInfo );
+        for ( auto& reporterish : m_reporterLikes ) {
+            reporterish->skipTest( testInfo );
         }
-        m_reporter->skipTest( testInfo );
     }
 
     void ListeningReporter::listReporters(std::vector<ReporterDescription> const& descriptions) {
-        for (auto& listener : m_listeners) {
-            listener->listReporters(descriptions);
+        for (auto& reporterish : m_reporterLikes) {
+            reporterish->listReporters(descriptions);
         }
-        m_reporter->listReporters(descriptions);
     }
 
     void ListeningReporter::listTests(std::vector<TestCaseHandle> const& tests) {
-        for (auto& listener : m_listeners) {
-            listener->listTests(tests);
+        for (auto& reporterish : m_reporterLikes) {
+            reporterish->listTests(tests);
         }
-        m_reporter->listTests(tests);
     }
 
     void ListeningReporter::listTags(std::vector<TagInfo> const& tags) {
-        for (auto& listener : m_listeners) {
-            listener->listTags(tags);
+        for (auto& reporterish : m_reporterLikes) {
+            reporterish->listTags(tags);
         }
-        m_reporter->listTags(tags);
     }
 
 } // end namespace Catch
diff --git a/src/catch2/reporters/catch_reporter_listening.hpp b/src/catch2/reporters/catch_reporter_listening.hpp
index feddabed..f5b3a2ec 100644
--- a/src/catch2/reporters/catch_reporter_listening.hpp
+++ b/src/catch2/reporters/catch_reporter_listening.hpp
@@ -13,9 +13,20 @@
 namespace Catch {
 
     class ListeningReporter final : public IStreamingReporter {
-        using Reporters = std::vector<IStreamingReporterPtr>;
-        Reporters m_listeners;
-        IStreamingReporterPtr m_reporter = nullptr;
+        /*
+         * Stores all added reporters and listeners
+         *
+         * All Listeners are stored before all reporters, and individual
+         * listeners/reporters are stored in order of insertion.
+         */
+        std::vector<IStreamingReporterPtr> m_reporterLikes;
+        bool m_haveNoncapturingReporters = false;
+
+        // Keep track of how many listeners we have already inserted,
+        // so that we can insert them into the main vector at the right place
+        size_t m_insertedListeners = 0;
+
+        void updatePreferences(IStreamingReporter const& reporterish);
 
     public:
         ListeningReporter( IConfig const* config ):
diff --git a/tests/SelfTest/Baselines/automake.sw.multi.approved.txt b/tests/SelfTest/Baselines/automake.sw.multi.approved.txt
new file mode 100644
index 00000000..328fcf50
--- /dev/null
+++ b/tests/SelfTest/Baselines/automake.sw.multi.approved.txt
@@ -0,0 +1,380 @@
+:test-result: PASS # A test name that starts with a #
+:test-result: PASS #1005: Comparing pointer to int and long (NULL can be either on various systems)
+:test-result: PASS #1027: Bitfields can be captured
+:test-result: PASS #1147
+:test-result: PASS #1175 - Hidden Test
+:test-result: PASS #1238
+:test-result: PASS #1245
+:test-result: PASS #1319: Sections can have description (even if it is not saved
+:test-result: PASS #1403
+:test-result: FAIL #1455 - INFO and WARN can start with a linebreak
+:test-result: FAIL #1514: stderr/stdout is not captured in tests aborted by an exception
+:test-result: PASS #1548
+:test-result: PASS #1905 -- test spec parser properly clears internal state between compound tests
+:test-result: PASS #1912 -- test spec parser handles escaping
+:test-result: PASS #1913 - GENERATE inside a for loop should not keep recreating the generator
+:test-result: PASS #1913 - GENERATEs can share a line
+:test-result: PASS #1938 - GENERATE after a section
+:test-result: PASS #1938 - Section followed by flat generate
+:test-result: PASS #1938 - flat generate
+:test-result: PASS #1938 - mixed sections and generates
+:test-result: PASS #1938 - nested generate
+:test-result: PASS #1954 - 7 arg template test case sig compiles - 1, 1, 1, 1, 1, 0, 0
+:test-result: PASS #1954 - 7 arg template test case sig compiles - 5, 1, 1, 1, 1, 0, 0
+:test-result: PASS #1954 - 7 arg template test case sig compiles - 5, 3, 1, 1, 1, 0, 0
+:test-result: PASS #2152 - ULP checks between differently signed values were wrong - double
+:test-result: PASS #2152 - ULP checks between differently signed values were wrong - float
+:test-result: XFAIL #748 - captures with unexpected exceptions
+:test-result: PASS #809
+:test-result: PASS #833
+:test-result: XFAIL #835 -- errno should not be touched by Catch
+:test-result: PASS #872
+:test-result: PASS #961 -- Dynamically created sections should all be reported
+:test-result: FAIL 'Not' checks that should fail
+:test-result: PASS 'Not' checks that should succeed
+:test-result: PASS (unimplemented) static bools can be evaluated
+:test-result: PASS 3x3x3 ints
+:test-result: FAIL A METHOD_AS_TEST_CASE based test run that fails
+:test-result: PASS A METHOD_AS_TEST_CASE based test run that succeeds
+:test-result: FAIL A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<float>
+:test-result: FAIL A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>
+:test-result: FAIL A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>
+:test-result: FAIL A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>
+:test-result: PASS A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<float>
+:test-result: PASS A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<int>
+:test-result: PASS A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<float>
+:test-result: PASS A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<int>
+:test-result: FAIL A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<float, 6>
+:test-result: FAIL A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>
+:test-result: FAIL A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>
+:test-result: FAIL A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>
+:test-result: PASS A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<float,6>
+:test-result: PASS A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<int,2>
+:test-result: PASS A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<float,6>
+:test-result: PASS A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<int,2>
+:test-result: FAIL A TEMPLATE_TEST_CASE_METHOD based test run that fails - double
+:test-result: FAIL A TEMPLATE_TEST_CASE_METHOD based test run that fails - float
+:test-result: FAIL A TEMPLATE_TEST_CASE_METHOD based test run that fails - int
+:test-result: PASS A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double
+:test-result: PASS A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - float
+:test-result: PASS A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - int
+:test-result: FAIL A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1
+:test-result: FAIL A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3
+:test-result: FAIL A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6
+:test-result: PASS A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1
+:test-result: PASS A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 3
+:test-result: PASS A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 6
+:test-result: FAIL A TEST_CASE_METHOD based test run that fails
+:test-result: PASS A TEST_CASE_METHOD based test run that succeeds
+:test-result: PASS A Template product test case - Foo<float>
+:test-result: PASS A Template product test case - Foo<int>
+:test-result: PASS A Template product test case - std::vector<float>
+:test-result: PASS A Template product test case - std::vector<int>
+:test-result: PASS A Template product test case with array signature - Bar<float, 42>
+:test-result: PASS A Template product test case with array signature - Bar<int, 9>
+:test-result: PASS A Template product test case with array signature - std::array<float, 42>
+:test-result: PASS A Template product test case with array signature - std::array<int, 9>
+:test-result: PASS A comparison that uses literals instead of the normal constructor
+:test-result: FAIL A couple of nested sections followed by a failure
+:test-result: FAIL A failing expression with a non streamable type is still captured
+:test-result: PASS Absolute margin
+:test-result: FAIL An empty test with no assertions
+:test-result: PASS An expression with side-effects should only be evaluated once
+:test-result: FAIL An unchecked exception reports the line of the last assertion
+:test-result: PASS Anonymous test case 1
+:test-result: PASS Approx setters validate their arguments
+:test-result: PASS Approx with exactly-representable margin
+:test-result: PASS Approximate PI
+:test-result: PASS Approximate comparisons with different epsilons
+:test-result: PASS Approximate comparisons with floats
+:test-result: PASS Approximate comparisons with ints
+:test-result: PASS Approximate comparisons with mixed numeric types
+:test-result: PASS Arbitrary predicate matcher
+:test-result: PASS Assertion macros support bit operators and bool conversions
+:test-result: PASS Assertions then sections
+:test-result: PASS Basic use of the Contains range matcher
+:test-result: PASS Basic use of the Empty range matcher
+:test-result: PASS CAPTURE can deal with complex expressions
+:test-result: PASS CAPTURE can deal with complex expressions involving commas
+:test-result: PASS CAPTURE parses string and character constants
+:test-result: PASS Capture and info messages
+:test-result: PASS CaseInsensitiveEqualsTo is case insensitive
+:test-result: PASS CaseInsensitiveLess is case insensitive
+:test-result: PASS Character pretty printing
+:test-result: PASS Clara::Arg supports single-arg parse the way Opt does
+:test-result: PASS Clara::Opt supports accept-many lambdas
+:test-result: PASS Combining MatchAllOfGeneric does not nest
+:test-result: PASS Combining MatchAnyOfGeneric does not nest
+:test-result: PASS Combining MatchNotOfGeneric does not nest
+:test-result: PASS Combining concrete matchers does not use templated matchers
+:test-result: PASS Combining only templated matchers
+:test-result: PASS Combining templated and concrete matchers
+:test-result: PASS Combining templated matchers
+:test-result: PASS Commas in various macros are allowed
+:test-result: PASS Comparing function pointers
+:test-result: PASS Comparison ops
+:test-result: PASS Comparison with explicitly convertible types
+:test-result: PASS Comparisons between ints where one side is computed
+:test-result: PASS Comparisons between unsigned ints and negative signed ints match c++ standard behaviour
+:test-result: PASS Comparisons with int literals don't warn when mixing signed/ unsigned
+:test-result: PASS Composed generic matchers shortcircuit
+:test-result: PASS Composed matchers shortcircuit
+:test-result: FAIL Contains string matcher
+:test-result: PASS Copy and then generate a range
+:test-result: FAIL Custom exceptions can be translated when testing for nothrow
+:test-result: FAIL Custom exceptions can be translated when testing for throwing as something else
+:test-result: FAIL Custom std-exceptions can be custom translated
+:test-result: PASS Default scale is invisible to comparison
+:test-result: PASS Directly creating an EnumInfo
+:test-result: PASS Empty tag is not allowed
+:test-result: FAIL EndsWith string matcher
+:test-result: PASS Enums can quickly have stringification enabled using REGISTER_ENUM
+:test-result: PASS Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM
+:test-result: PASS Epsilon only applies to Approx's value
+:test-result: XFAIL Equality checks that should fail
+:test-result: PASS Equality checks that should succeed
+:test-result: PASS Equals
+:test-result: FAIL Equals string matcher
+:test-result: PASS Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified
+:test-result: FAIL Exception matchers that fail
+:test-result: PASS Exception matchers that succeed
+:test-result: PASS Exception messages can be tested for
+:test-result: PASS Exceptions matchers
+:test-result: FAIL Expected exceptions that don't throw or unexpected exceptions fail the test
+:test-result: FAIL FAIL aborts the test
+:test-result: FAIL FAIL does not require an argument
+:test-result: FAIL FAIL_CHECK does not abort the test
+:test-result: PASS Factorials are computed
+:test-result: PASS Floating point matchers: double
+:test-result: PASS Floating point matchers: float
+:test-result: PASS Generators -- adapters
+:test-result: PASS Generators -- simple
+:test-result: PASS Generators internals
+:test-result: PASS Greater-than inequalities with different epsilons
+:test-result: FAIL INFO and WARN do not abort tests
+:test-result: FAIL INFO gets logged on failure
+:test-result: FAIL INFO gets logged on failure, even if captured before successful assertions
+:test-result: FAIL INFO is reset for each loop
+:test-result: XFAIL Inequality checks that should fail
+:test-result: PASS Inequality checks that should succeed
+:test-result: PASS Lambdas in assertions
+:test-result: PASS Less-than inequalities with different epsilons
+:test-result: PASS ManuallyRegistered
+:test-result: PASS Matchers can be (AllOf) composed with the && operator
+:test-result: PASS Matchers can be (AnyOf) composed with the || operator
+:test-result: PASS Matchers can be composed with both && and ||
+:test-result: FAIL Matchers can be composed with both && and || - failing
+:test-result: PASS Matchers can be negated (Not) with the ! operator
+:test-result: FAIL Matchers can be negated (Not) with the ! operator - failing
+:test-result: XFAIL Mayfail test case with nested sections
+:test-result: FAIL Mismatching exception messages failing the test
+:test-result: PASS Nested generators and captured variables
+:test-result: FAIL Nice descriptive name
+:test-result: FAIL Non-std exceptions can be translated
+:test-result: PASS Objects that evaluated in boolean contexts can be checked
+:test-result: PASS Optionally static assertions
+:test-result: FAIL Ordering comparison checks that should fail
+:test-result: PASS Ordering comparison checks that should succeed
+:test-result: PASS Our PCG implementation provides expected results for known seeds
+:test-result: FAIL Output from all sections is reported
+:test-result: PASS Overloaded comma or address-of operators are not used
+:test-result: PASS Parse test names and tags
+:test-result: PASS Parsed tags are matched case insensitive
+:test-result: PASS Parsing sharding-related cli flags
+:test-result: PASS Parsing tags with non-alphabetical characters is pass-through
+:test-result: PASS Parsing warnings
+:test-result: PASS Pointers can be compared to null
+:test-result: PASS Precision of floating point stringification can be set
+:test-result: PASS Predicate matcher can accept const char*
+:test-result: PASS Process can be configured on command line
+:test-result: PASS Product with differing arities - std::tuple<int, double, float>
+:test-result: PASS Product with differing arities - std::tuple<int, double>
+:test-result: PASS Product with differing arities - std::tuple<int>
+:test-result: PASS Random seed generation accepts known methods
+:test-result: PASS Random seed generation reports unknown methods
+:test-result: PASS Range type with sentinel
+:test-result: FAIL Reconstruction should be based on stringification: #914
+:test-result: FAIL Regex string matcher
+:test-result: PASS Regression test #1
+:test-result: PASS Reporter's write listings to provided stream
+:test-result: PASS Reproducer for #2309 - a very long description past 80 chars (default console width) with a late colon : blablabla
+:test-result: PASS SUCCEED counts as a test pass
+:test-result: PASS SUCCEED does not require an argument
+:test-result: PASS Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods
+:test-result: PASS Scenario: Do that thing with the thing
+:test-result: PASS Scenario: This is a really long scenario name to see how the list command deals with wrapping
+:test-result: PASS Scenario: Vector resizing affects size and capacity
+:test-result: FAIL Sends stuff to stdout and stderr
+:test-result: PASS Some simple comparisons between doubles
+:test-result: FAIL Standard output from all sections is reported
+:test-result: FAIL StartsWith string matcher
+:test-result: PASS Static arrays are convertible to string
+:test-result: PASS String matchers
+:test-result: PASS StringRef
+:test-result: PASS StringRef at compilation time
+:test-result: PASS Stringifying char arrays with statically known sizes - char
+:test-result: PASS Stringifying char arrays with statically known sizes - signed char
+:test-result: PASS Stringifying char arrays with statically known sizes - unsigned char
+:test-result: PASS Stringifying std::chrono::duration helpers
+:test-result: PASS Stringifying std::chrono::duration with weird ratios
+:test-result: PASS Stringifying std::chrono::time_point<system_clock>
+:test-result: FAIL Tabs and newlines show in output
+:test-result: PASS Tag alias can be registered against tag patterns
+:test-result: PASS Tags with spaces and non-alphanumerical characters are accepted
+:test-result: PASS Template test case method with test types specified inside std::tuple - MyTypes - 0
+:test-result: PASS Template test case method with test types specified inside std::tuple - MyTypes - 1
+:test-result: PASS Template test case method with test types specified inside std::tuple - MyTypes - 2
+:test-result: PASS Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 0
+:test-result: PASS Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 1
+:test-result: PASS Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 0
+:test-result: PASS Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 1
+:test-result: PASS Template test case with test types specified inside std::tuple - MyTypes - 0
+:test-result: PASS Template test case with test types specified inside std::tuple - MyTypes - 1
+:test-result: PASS Template test case with test types specified inside std::tuple - MyTypes - 2
+:test-result: PASS TemplateTest: vectors can be sized and resized - float
+:test-result: PASS TemplateTest: vectors can be sized and resized - int
+:test-result: PASS TemplateTest: vectors can be sized and resized - std::string
+:test-result: PASS TemplateTest: vectors can be sized and resized - std::tuple<int,float>
+:test-result: PASS TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
+:test-result: PASS TemplateTestSig: vectors can be sized and resized - float,4
+:test-result: PASS TemplateTestSig: vectors can be sized and resized - int,5
+:test-result: PASS TemplateTestSig: vectors can be sized and resized - std::string,15
+:test-result: PASS Test case with identical tags keeps just one
+:test-result: PASS Test case with one argument
+:test-result: PASS Test enum bit values
+:test-result: PASS Test with special, characters "in name
+:test-result: PASS Testing checked-if
+:test-result: XFAIL Testing checked-if 2
+:test-result: XFAIL Testing checked-if 3
+:test-result: FAIL The NO_FAIL macro reports a failure but does not fail the test
+:test-result: PASS The default listing implementation write to provided stream
+:test-result: FAIL This test 'should' fail but doesn't
+:test-result: FAIL Thrown string literals are translated
+:test-result: PASS Tracker
+:test-result: PASS Trim strings
+:test-result: FAIL Unexpected exceptions can be translated
+:test-result: PASS Upcasting special member functions
+:test-result: PASS Usage of AllMatch range matcher
+:test-result: PASS Usage of AnyMatch range matcher
+:test-result: PASS Usage of NoneMatch range matcher
+:test-result: PASS Usage of the SizeIs range matcher
+:test-result: PASS Use a custom approx
+:test-result: PASS Variadic macros
+:test-result: PASS Vector Approx matcher
+:test-result: FAIL Vector Approx matcher -- failing
+:test-result: PASS Vector matchers
+:test-result: FAIL Vector matchers that fail
+:test-result: PASS When checked exceptions are thrown they can be expected or unexpected
+:test-result: FAIL When unchecked exceptions are thrown directly they are always failures
+:test-result: FAIL When unchecked exceptions are thrown during a CHECK the test should continue
+:test-result: FAIL When unchecked exceptions are thrown during a REQUIRE the test should abort fail
+:test-result: FAIL When unchecked exceptions are thrown from functions they are always failures
+:test-result: FAIL When unchecked exceptions are thrown from sections they are always failures
+:test-result: FAIL When unchecked exceptions are thrown, but caught, they do not affect the test
+:test-result: PASS X/level/0/a
+:test-result: PASS X/level/0/b
+:test-result: PASS X/level/1/a
+:test-result: PASS X/level/1/b
+:test-result: PASS XmlEncode
+:test-result: PASS XmlWriter writes boolean attributes as true/false
+:test-result: PASS analyse no analysis
+:test-result: PASS array<int, N> -> toString
+:test-result: PASS benchmark function call
+:test-result: PASS boolean member
+:test-result: PASS checkedElse
+:test-result: FAIL checkedElse, failing
+:test-result: PASS checkedIf
+:test-result: FAIL checkedIf, failing
+:test-result: PASS classify_outliers
+:test-result: PASS comparisons between const int variables
+:test-result: PASS comparisons between int variables
+:test-result: PASS convertToBits
+:test-result: PASS empty tags are not allowed
+:test-result: PASS erfc_inv
+:test-result: PASS estimate_clock_resolution
+:test-result: PASS even more nested SECTION tests
+:test-result: FAIL first tag
+:test-result: FAIL has printf
+:test-result: PASS is_unary_function
+:test-result: FAIL just failure
+:test-result: FAIL just failure after unscoped info
+:test-result: FAIL just info
+:test-result: FAIL just unscoped info
+:test-result: PASS long long
+:test-result: FAIL looped SECTION tests
+:test-result: FAIL looped tests
+:test-result: PASS make_unique reimplementation
+:test-result: PASS mean
+:test-result: PASS measure
+:test-result: FAIL mix info, unscoped info and warning
+:test-result: FAIL more nested SECTION tests
+:test-result: PASS nested SECTION tests
+:test-result: PASS non streamable - with conv. op
+:test-result: PASS non-copyable objects
+:test-result: PASS normal_cdf
+:test-result: PASS normal_quantile
+:test-result: PASS not allowed
+:test-result: FAIL not prints unscoped info from previous failures
+:test-result: PASS null strings
+:test-result: PASS null_ptr
+:test-result: PASS pair<pair<int,const char *,pair<std::string,int> > -> toString
+:test-result: PASS parseEnums
+:test-result: PASS pointer to class
+:test-result: PASS print unscoped info if passing unscoped info is printed
+:test-result: FAIL prints unscoped info on failure
+:test-result: FAIL prints unscoped info only for the first assertion
+:test-result: PASS random SECTION tests
+:test-result: PASS replaceInPlace
+:test-result: PASS resolution
+:test-result: PASS run_for_at_least, chronometer
+:test-result: PASS run_for_at_least, int
+:test-result: FAIL second tag
+:test-result: FAIL send a single char to INFO
+:test-result: FAIL sends information to INFO
+:test-result: PASS shortened hide tags are split apart
+:test-result: PASS splitString
+:test-result: FAIL stacks unscoped info in loops
+:test-result: PASS startsWith
+:test-result: PASS std::map is convertible string
+:test-result: PASS std::pair<int,const std::string> -> toString
+:test-result: PASS std::pair<int,std::string> -> toString
+:test-result: PASS std::set is convertible string
+:test-result: PASS std::vector<std::pair<std::string,int> > -> toString
+:test-result: PASS stringify ranges
+:test-result: PASS stringify( has_maker )
+:test-result: PASS stringify( has_maker_and_operator )
+:test-result: PASS stringify( has_neither )
+:test-result: PASS stringify( has_operator )
+:test-result: PASS stringify( has_template_operator )
+:test-result: PASS stringify( vectors<has_maker> )
+:test-result: PASS stringify( vectors<has_maker_and_operator> )
+:test-result: PASS stringify( vectors<has_operator> )
+:test-result: PASS strlen3
+:test-result: PASS tables
+:test-result: PASS tags with dots in later positions are not parsed as hidden
+:test-result: FAIL thrown std::strings are translated
+:test-result: PASS toString on const wchar_t const pointer returns the string contents
+:test-result: PASS toString on const wchar_t pointer returns the string contents
+:test-result: PASS toString on wchar_t const pointer returns the string contents
+:test-result: PASS toString on wchar_t returns the string contents
+:test-result: PASS toString(enum class w/operator<<)
+:test-result: PASS toString(enum class)
+:test-result: PASS toString(enum w/operator<<)
+:test-result: PASS toString(enum)
+:test-result: PASS tuple<>
+:test-result: PASS tuple<float,int>
+:test-result: PASS tuple<int>
+:test-result: PASS tuple<0,int,const char *>
+:test-result: PASS tuple<string,string>
+:test-result: PASS tuple<tuple<int>,tuple<>,float>
+:test-result: PASS uniform samples
+:test-result: PASS unique_ptr reimplementation: basic functionality
+:test-result: PASS vec<vec<string,alloc>> -> toString
+:test-result: PASS vector<bool> -> toString
+:test-result: PASS vector<int,allocator> -> toString
+:test-result: PASS vector<int> -> toString
+:test-result: PASS vector<string> -> toString
+:test-result: PASS vectors can be sized and resized
+:test-result: PASS warmup
+:test-result: PASS weighted_average_quantile
+:test-result: PASS xmlentitycheck
diff --git a/tests/SelfTest/Baselines/compact.sw.approved.txt b/tests/SelfTest/Baselines/compact.sw.approved.txt
index f7aaa5b3..517b4d93 100644
--- a/tests/SelfTest/Baselines/compact.sw.approved.txt
+++ b/tests/SelfTest/Baselines/compact.sw.approved.txt
@@ -1250,7 +1250,9 @@ CmdLine.tests.cpp:<line number>: passed: config.processName == "test" for: "test
 CmdLine.tests.cpp:<line number>: passed: config.shouldDebugBreak == false for: false == false
 CmdLine.tests.cpp:<line number>: passed: config.abortAfter == -1 for: -1 == -1
 CmdLine.tests.cpp:<line number>: passed: config.noThrow == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: config.reporterName == "console" for: "console" == "console"
+CmdLine.tests.cpp:<line number>: passed: config.reporterSpecifications == std::vector<Catch::ConfigData::ReporterAndFile>{ {"console", {}} } for: { { console, <default-output> } }
+==
+{ { console, <default-output> } }
 CmdLine.tests.cpp:<line number>: passed: !(cfg.hasTestFilters()) for: !false
 CmdLine.tests.cpp:<line number>: passed: result for: {?}
 CmdLine.tests.cpp:<line number>: passed: cfg.hasTestFilters() for: true
@@ -1264,15 +1266,40 @@ CmdLine.tests.cpp:<line number>: passed: result for: {?}
 CmdLine.tests.cpp:<line number>: passed: cfg.hasTestFilters() for: true
 CmdLine.tests.cpp:<line number>: passed: cfg.testSpec().matches(*fakeTestCase("test1")) == false for: false == false
 CmdLine.tests.cpp:<line number>: passed: cfg.testSpec().matches(*fakeTestCase("alwaysIncluded")) for: true
-CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "-r", "console"}) for: {?}
-CmdLine.tests.cpp:<line number>: passed: config.reporterName == "console" for: "console" == "console"
-CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "-r", "xml"}) for: {?}
-CmdLine.tests.cpp:<line number>: passed: config.reporterName == "xml" for: "xml" == "xml"
-CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "--reporter", "junit"}) for: {?}
-CmdLine.tests.cpp:<line number>: passed: config.reporterName == "junit" for: "junit" == "junit"
-CmdLine.tests.cpp:<line number>: passed: !(cli.parse({ "test", "-r", "xml", "-r", "junit" })) for: !{?}
+CmdLine.tests.cpp:<line number>: passed: result for: {?} with 1 message: 'result.errorMessage() := ""'
+CmdLine.tests.cpp:<line number>: passed: config.reporterSpecifications == vec_ReporterAndFile{ {"console", {}} } for: { { console, <default-output> } }
+==
+{ { console, <default-output> } } with 1 message: 'result.errorMessage() := ""'
+CmdLine.tests.cpp:<line number>: passed: result for: {?} with 1 message: 'result.errorMessage() := ""'
+CmdLine.tests.cpp:<line number>: passed: config.reporterSpecifications == vec_ReporterAndFile{ {"xml", {}} } for: { { xml, <default-output> } }
+==
+{ { xml, <default-output> } } with 1 message: 'result.errorMessage() := ""'
+CmdLine.tests.cpp:<line number>: passed: result for: {?} with 1 message: 'result.errorMessage() := ""'
+CmdLine.tests.cpp:<line number>: passed: config.reporterSpecifications == vec_ReporterAndFile{ {"junit", {}} } for: { { junit, <default-output> } }
+==
+{ { junit, <default-output> } } with 1 message: 'result.errorMessage() := ""'
 CmdLine.tests.cpp:<line number>: passed: !result for: true
 CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring("Unrecognized reporter") for: "Unrecognized reporter, 'unsupported'. Check available with --list-reporters" contains: "Unrecognized reporter"
+CmdLine.tests.cpp:<line number>: passed: result for: {?} with 1 message: 'result.errorMessage() := ""'
+CmdLine.tests.cpp:<line number>: passed: config.reporterSpecifications == vec_ReporterAndFile{ {"console", "out.txt"s} } for: { { console, out.txt } }
+==
+{ { console, out.txt } } with 1 message: 'result.errorMessage() := ""'
+CmdLine.tests.cpp:<line number>: passed: result for: {?} with 1 message: 'result.errorMessage() := ""'
+CmdLine.tests.cpp:<line number>: passed: config.reporterSpecifications == vec_ReporterAndFile{ {"console", "C:\\Temp\\out.txt"s} } for: { { console, C:\Temp\out.txt } }
+==
+{ { console, C:\Temp\out.txt } } with 1 message: 'result.errorMessage() := ""'
+CmdLine.tests.cpp:<line number>: passed: !result for: true
+CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring("empty filename") for: "Reporter 'console' has empty filename specified as its output. Supply a filename or remove the colons to use the default output." contains: "empty filename"
+CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "-r", "xml::output.xml", "-r", "junit::output-junit.xml" }) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.reporterSpecifications == vec_ReporterAndFile{ {"xml", "output.xml"s}, {"junit", "output-junit.xml"s} } for: { { xml, output.xml }, { junit, output-junit.xml } }
+==
+{ { xml, output.xml }, { junit, output-junit.xml } }
+CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "-r", "xml::output.xml", "-r", "console" }) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.reporterSpecifications == vec_ReporterAndFile{ {"xml", "output.xml"s}, {"console", {}} } for: { { xml, output.xml }, { console, <default-output> } }
+==
+{ { xml, output.xml }, { console, <default-output> } }
+CmdLine.tests.cpp:<line number>: passed: !result for: true
+CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring("Only one reporter may have unspecified output file.") for: "Only one reporter may have unspecified output file." contains: "Only one reporter may have unspecified output file."
 CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "-b"}) for: {?}
 CmdLine.tests.cpp:<line number>: passed: config.shouldDebugBreak == true for: true == true
 CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "--break"}) for: {?}
@@ -1298,9 +1325,9 @@ CmdLine.tests.cpp:<line number>: passed: config.noThrow for: true
 CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "--nothrow"}) for: {?}
 CmdLine.tests.cpp:<line number>: passed: config.noThrow for: true
 CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "-o", "filename.ext"}) for: {?}
-CmdLine.tests.cpp:<line number>: passed: config.outputFilename == "filename.ext" for: "filename.ext" == "filename.ext"
+CmdLine.tests.cpp:<line number>: passed: config.defaultOutputFilename == "filename.ext" for: "filename.ext" == "filename.ext"
 CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "--out", "filename.ext"}) for: {?}
-CmdLine.tests.cpp:<line number>: passed: config.outputFilename == "filename.ext" for: "filename.ext" == "filename.ext"
+CmdLine.tests.cpp:<line number>: passed: config.defaultOutputFilename == "filename.ext" for: "filename.ext" == "filename.ext"
 CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "-abe"}) for: {?}
 CmdLine.tests.cpp:<line number>: passed: config.abortAfter == 1 for: 1 == 1
 CmdLine.tests.cpp:<line number>: passed: config.shouldDebugBreak for: true
diff --git a/tests/SelfTest/Baselines/compact.sw.multi.approved.txt b/tests/SelfTest/Baselines/compact.sw.multi.approved.txt
new file mode 100644
index 00000000..7196e831
--- /dev/null
+++ b/tests/SelfTest/Baselines/compact.sw.multi.approved.txt
@@ -0,0 +1,2480 @@
+Misc.tests.cpp:<line number>: passed: with 1 message: 'yay'
+Decomposition.tests.cpp:<line number>: passed: fptr == 0 for: 0 == 0
+Decomposition.tests.cpp:<line number>: passed: fptr == 0l for: 0 == 0
+Compilation.tests.cpp:<line number>: passed: y.v == 0 for: 0 == 0
+Compilation.tests.cpp:<line number>: passed: 0 == y.v for: 0 == 0
+Compilation.tests.cpp:<line number>: passed: t1 == t2 for: {?} == {?}
+Compilation.tests.cpp:<line number>: passed: t1 != t2 for: {?} != {?}
+Compilation.tests.cpp:<line number>: passed: t1 < t2 for: {?} < {?}
+Compilation.tests.cpp:<line number>: passed: t1 > t2 for: {?} > {?}
+Compilation.tests.cpp:<line number>: passed: t1 <= t2 for: {?} <= {?}
+Compilation.tests.cpp:<line number>: passed: t1 >= t2 for: {?} >= {?}
+Misc.tests.cpp:<line number>: passed:
+Compilation.tests.cpp:<line number>: passed: std::memcmp(uarr, "123", sizeof(uarr)) == 0 for: 0 == 0 with 2 messages: 'uarr := "123"' and 'sarr := "456"'
+Compilation.tests.cpp:<line number>: passed: std::memcmp(sarr, "456", sizeof(sarr)) == 0 for: 0 == 0 with 2 messages: 'uarr := "123"' and 'sarr := "456"'
+Compilation.tests.cpp:<line number>: passed:
+Compilation.tests.cpp:<line number>: passed:
+Compilation.tests.cpp:<line number>: passed: h1 == h2 for: [1403 helper] == [1403 helper]
+Message.tests.cpp:<line number>: warning: '
+This info message starts with a linebreak' with 1 message: '
+This warning message starts with a linebreak'
+Tricky.tests.cpp:<line number>: failed: explicitly with 1 message: '1514'
+Compilation.tests.cpp:<line number>: passed: std::is_same<TypeList<int>, TypeList<int>>::value for: true
+CmdLine.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase("spec . char")) for: true
+CmdLine.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase("spec , char")) for: true
+CmdLine.tests.cpp:<line number>: passed: !(spec.matches(*fakeTestCase(R"(spec \, char)"))) for: !false
+CmdLine.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase(R"(spec {a} char)")) for: true
+CmdLine.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase(R"(spec [a] char)")) for: true
+CmdLine.tests.cpp:<line number>: passed: !(spec.matches(*fakeTestCase("differs but has similar tag", "[a]"))) for: !false
+CmdLine.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase(R"(spec \ char)")) for: true
+Generators.tests.cpp:<line number>: passed: counter < 7 for: 3 < 7
+Generators.tests.cpp:<line number>: passed: counter < 7 for: 6 < 7
+Generators.tests.cpp:<line number>: passed: i != j for: 1 != 3
+Generators.tests.cpp:<line number>: passed: i != j for: 1 != 4
+Generators.tests.cpp:<line number>: passed: i != j for: 2 != 3
+Generators.tests.cpp:<line number>: passed: i != j for: 2 != 4
+PartTracker.tests.cpp:<line number>: passed: with 1 message: 'A'
+PartTracker.tests.cpp:<line number>: passed: m for: 1
+PartTracker.tests.cpp:<line number>: passed: m for: 2
+PartTracker.tests.cpp:<line number>: passed: m for: 3
+PartTracker.tests.cpp:<line number>: passed: 1
+PartTracker.tests.cpp:<line number>: passed: m for: 2
+PartTracker.tests.cpp:<line number>: passed: m for: 3
+PartTracker.tests.cpp:<line number>: passed: m for: 1
+PartTracker.tests.cpp:<line number>: passed: m for: 2
+PartTracker.tests.cpp:<line number>: passed: m for: 3
+PartTracker.tests.cpp:<line number>: passed: with 1 message: 'A'
+PartTracker.tests.cpp:<line number>: passed: with 3 messages: 'i := 1' and 'j := 3' and 'k := 5'
+PartTracker.tests.cpp:<line number>: passed: with 1 message: 'B'
+PartTracker.tests.cpp:<line number>: passed: with 3 messages: 'i := 1' and 'j := 3' and 'k := 6'
+PartTracker.tests.cpp:<line number>: passed: with 1 message: 'B'
+PartTracker.tests.cpp:<line number>: passed: with 3 messages: 'i := 1' and 'j := 4' and 'k := 5'
+PartTracker.tests.cpp:<line number>: passed: with 3 messages: 'i := 1' and 'j := 4' and 'k := 6'
+PartTracker.tests.cpp:<line number>: passed: with 1 message: 'A'
+PartTracker.tests.cpp:<line number>: passed: with 3 messages: 'i := 2' and 'j := 3' and 'k := 5'
+PartTracker.tests.cpp:<line number>: passed: with 1 message: 'B'
+PartTracker.tests.cpp:<line number>: passed: with 3 messages: 'i := 2' and 'j := 3' and 'k := 6'
+PartTracker.tests.cpp:<line number>: passed: with 1 message: 'B'
+PartTracker.tests.cpp:<line number>: passed: with 3 messages: 'i := 2' and 'j := 4' and 'k := 5'
+PartTracker.tests.cpp:<line number>: passed: with 3 messages: 'i := 2' and 'j := 4' and 'k := 6'
+PartTracker.tests.cpp:<line number>: passed: m for: 1
+PartTracker.tests.cpp:<line number>: passed: n for: 1
+PartTracker.tests.cpp:<line number>: passed: m for: 1
+PartTracker.tests.cpp:<line number>: passed: n for: 2
+PartTracker.tests.cpp:<line number>: passed: m for: 1
+PartTracker.tests.cpp:<line number>: passed: n for: 3
+PartTracker.tests.cpp:<line number>: passed: m for: 2
+PartTracker.tests.cpp:<line number>: passed: n for: 1
+PartTracker.tests.cpp:<line number>: passed: m for: 2
+PartTracker.tests.cpp:<line number>: passed: n for: 2
+PartTracker.tests.cpp:<line number>: passed: m for: 2
+PartTracker.tests.cpp:<line number>: passed: n for: 3
+PartTracker.tests.cpp:<line number>: passed: m for: 3
+PartTracker.tests.cpp:<line number>: passed: n for: 1
+PartTracker.tests.cpp:<line number>: passed: m for: 3
+PartTracker.tests.cpp:<line number>: passed: n for: 2
+PartTracker.tests.cpp:<line number>: passed: m for: 3
+PartTracker.tests.cpp:<line number>: passed: n for: 3
+Misc.tests.cpp:<line number>: passed:
+Misc.tests.cpp:<line number>: passed:
+Misc.tests.cpp:<line number>: passed:
+Matchers.tests.cpp:<line number>: passed: smallest_non_zero, WithinULP( -smallest_non_zero, 2 ) for: 0.0 is within 2 ULPs of -4.9406564584124654e-324 ([-1.4821969375237396e-323, 4.9406564584124654e-324])
+Matchers.tests.cpp:<line number>: passed: smallest_non_zero, !WithinULP( -smallest_non_zero, 1 ) for: 0.0 not is within 1 ULPs of -4.9406564584124654e-324 ([-9.8813129168249309e-324, -0.0000000000000000e+00])
+Matchers.tests.cpp:<line number>: passed: smallest_non_zero, WithinULP( -smallest_non_zero, 2 ) for: 0.0f is within 2 ULPs of -1.40129846e-45f ([-4.20389539e-45, 1.40129846e-45])
+Matchers.tests.cpp:<line number>: passed: smallest_non_zero, !WithinULP( -smallest_non_zero, 1 ) for: 0.0f not is within 1 ULPs of -1.40129846e-45f ([-2.80259693e-45, -0.00000000e+00])
+Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'answer := 42' with 1 message: 'expected exception'
+Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'answer := 42'; expression was: thisThrows() with 1 message: 'expected exception'
+Exception.tests.cpp:<line number>: passed: thisThrows() with 1 message: 'answer := 42'
+Compilation.tests.cpp:<line number>: passed: 42 == f for: 42 == {?}
+Compilation.tests.cpp:<line number>: passed: a == t for: 3 == 3
+Compilation.tests.cpp:<line number>: passed: a == t for: 3 == 3
+Compilation.tests.cpp:<line number>: passed: throws_int(true)
+Compilation.tests.cpp:<line number>: passed: throws_int(true), int
+Compilation.tests.cpp:<line number>: passed: throws_int(false)
+Compilation.tests.cpp:<line number>: passed: "aaa", Catch::Matchers::EndsWith("aaa") for: "aaa" ends with: "aaa"
+Compilation.tests.cpp:<line number>: passed: templated_tests<int>(3) for: true
+Misc.tests.cpp:<line number>: failed: f() == 0 for: 1 == 0
+Misc.tests.cpp:<line number>: passed: errno == 1 for: 1 == 1
+Compilation.tests.cpp:<line number>: passed: x == 4 for: {?} == 4 with 1 message: 'dummy := 0'
+Misc.tests.cpp:<line number>: passed: with 1 message: 'Everything is OK'
+Misc.tests.cpp:<line number>: passed: with 1 message: 'Everything is OK'
+Misc.tests.cpp:<line number>: passed: with 1 message: 'Everything is OK'
+Misc.tests.cpp:<line number>: passed: with 1 message: 'Everything is OK'
+Misc.tests.cpp:<line number>: passed: with 1 message: 'Everything is OK'
+Condition.tests.cpp:<line number>: failed: false != false
+Condition.tests.cpp:<line number>: failed: true != true
+Condition.tests.cpp:<line number>: failed: !true for: false
+Condition.tests.cpp:<line number>: failed: !(true) for: !true
+Condition.tests.cpp:<line number>: failed: !trueValue for: false
+Condition.tests.cpp:<line number>: failed: !(trueValue) for: !true
+Condition.tests.cpp:<line number>: failed: !(1 == 1) for: false
+Condition.tests.cpp:<line number>: failed: !(1 == 1)
+Condition.tests.cpp:<line number>: passed: false == false
+Condition.tests.cpp:<line number>: passed: true == true
+Condition.tests.cpp:<line number>: passed: !false for: true
+Condition.tests.cpp:<line number>: passed: !(false) for: !false
+Condition.tests.cpp:<line number>: passed: !falseValue for: true
+Condition.tests.cpp:<line number>: passed: !(falseValue) for: !false
+Condition.tests.cpp:<line number>: passed: !(1 == 2) for: true
+Condition.tests.cpp:<line number>: passed: !(1 == 2)
+Tricky.tests.cpp:<line number>: passed: is_true<true>::value == true for: true == true
+Tricky.tests.cpp:<line number>: passed: true == is_true<true>::value for: true == true
+Tricky.tests.cpp:<line number>: passed: is_true<false>::value == false for: false == false
+Tricky.tests.cpp:<line number>: passed: false == is_true<false>::value for: false == false
+Tricky.tests.cpp:<line number>: passed: !is_true<false>::value for: true
+Tricky.tests.cpp:<line number>: passed: !!is_true<true>::value for: true
+Tricky.tests.cpp:<line number>: passed: is_true<true>::value for: true
+Tricky.tests.cpp:<line number>: passed: !(is_true<false>::value) for: !false
+Generators.tests.cpp:<line number>: passed: x < y for: 1 < 4
+Generators.tests.cpp:<line number>: passed: y < z for: 4 < 7
+Generators.tests.cpp:<line number>: passed: x < z for: 1 < 7
+Generators.tests.cpp:<line number>: passed: x < y for: 1 < 4
+Generators.tests.cpp:<line number>: passed: y < z for: 4 < 8
+Generators.tests.cpp:<line number>: passed: x < z for: 1 < 8
+Generators.tests.cpp:<line number>: passed: x < y for: 1 < 4
+Generators.tests.cpp:<line number>: passed: y < z for: 4 < 9
+Generators.tests.cpp:<line number>: passed: x < z for: 1 < 9
+Generators.tests.cpp:<line number>: passed: x < y for: 1 < 5
+Generators.tests.cpp:<line number>: passed: y < z for: 5 < 7
+Generators.tests.cpp:<line number>: passed: x < z for: 1 < 7
+Generators.tests.cpp:<line number>: passed: x < y for: 1 < 5
+Generators.tests.cpp:<line number>: passed: y < z for: 5 < 8
+Generators.tests.cpp:<line number>: passed: x < z for: 1 < 8
+Generators.tests.cpp:<line number>: passed: x < y for: 1 < 5
+Generators.tests.cpp:<line number>: passed: y < z for: 5 < 9
+Generators.tests.cpp:<line number>: passed: x < z for: 1 < 9
+Generators.tests.cpp:<line number>: passed: x < y for: 1 < 6
+Generators.tests.cpp:<line number>: passed: y < z for: 6 < 7
+Generators.tests.cpp:<line number>: passed: x < z for: 1 < 7
+Generators.tests.cpp:<line number>: passed: x < y for: 1 < 6
+Generators.tests.cpp:<line number>: passed: y < z for: 6 < 8
+Generators.tests.cpp:<line number>: passed: x < z for: 1 < 8
+Generators.tests.cpp:<line number>: passed: x < y for: 1 < 6
+Generators.tests.cpp:<line number>: passed: y < z for: 6 < 9
+Generators.tests.cpp:<line number>: passed: x < z for: 1 < 9
+Generators.tests.cpp:<line number>: passed: x < y for: 2 < 4
+Generators.tests.cpp:<line number>: passed: y < z for: 4 < 7
+Generators.tests.cpp:<line number>: passed: x < z for: 2 < 7
+Generators.tests.cpp:<line number>: passed: x < y for: 2 < 4
+Generators.tests.cpp:<line number>: passed: y < z for: 4 < 8
+Generators.tests.cpp:<line number>: passed: x < z for: 2 < 8
+Generators.tests.cpp:<line number>: passed: x < y for: 2 < 4
+Generators.tests.cpp:<line number>: passed: y < z for: 4 < 9
+Generators.tests.cpp:<line number>: passed: x < z for: 2 < 9
+Generators.tests.cpp:<line number>: passed: x < y for: 2 < 5
+Generators.tests.cpp:<line number>: passed: y < z for: 5 < 7
+Generators.tests.cpp:<line number>: passed: x < z for: 2 < 7
+Generators.tests.cpp:<line number>: passed: x < y for: 2 < 5
+Generators.tests.cpp:<line number>: passed: y < z for: 5 < 8
+Generators.tests.cpp:<line number>: passed: x < z for: 2 < 8
+Generators.tests.cpp:<line number>: passed: x < y for: 2 < 5
+Generators.tests.cpp:<line number>: passed: y < z for: 5 < 9
+Generators.tests.cpp:<line number>: passed: x < z for: 2 < 9
+Generators.tests.cpp:<line number>: passed: x < y for: 2 < 6
+Generators.tests.cpp:<line number>: passed: y < z for: 6 < 7
+Generators.tests.cpp:<line number>: passed: x < z for: 2 < 7
+Generators.tests.cpp:<line number>: passed: x < y for: 2 < 6
+Generators.tests.cpp:<line number>: passed: y < z for: 6 < 8
+Generators.tests.cpp:<line number>: passed: x < z for: 2 < 8
+Generators.tests.cpp:<line number>: passed: x < y for: 2 < 6
+Generators.tests.cpp:<line number>: passed: y < z for: 6 < 9
+Generators.tests.cpp:<line number>: passed: x < z for: 2 < 9
+Generators.tests.cpp:<line number>: passed: x < y for: 3 < 4
+Generators.tests.cpp:<line number>: passed: y < z for: 4 < 7
+Generators.tests.cpp:<line number>: passed: x < z for: 3 < 7
+Generators.tests.cpp:<line number>: passed: x < y for: 3 < 4
+Generators.tests.cpp:<line number>: passed: y < z for: 4 < 8
+Generators.tests.cpp:<line number>: passed: x < z for: 3 < 8
+Generators.tests.cpp:<line number>: passed: x < y for: 3 < 4
+Generators.tests.cpp:<line number>: passed: y < z for: 4 < 9
+Generators.tests.cpp:<line number>: passed: x < z for: 3 < 9
+Generators.tests.cpp:<line number>: passed: x < y for: 3 < 5
+Generators.tests.cpp:<line number>: passed: y < z for: 5 < 7
+Generators.tests.cpp:<line number>: passed: x < z for: 3 < 7
+Generators.tests.cpp:<line number>: passed: x < y for: 3 < 5
+Generators.tests.cpp:<line number>: passed: y < z for: 5 < 8
+Generators.tests.cpp:<line number>: passed: x < z for: 3 < 8
+Generators.tests.cpp:<line number>: passed: x < y for: 3 < 5
+Generators.tests.cpp:<line number>: passed: y < z for: 5 < 9
+Generators.tests.cpp:<line number>: passed: x < z for: 3 < 9
+Generators.tests.cpp:<line number>: passed: x < y for: 3 < 6
+Generators.tests.cpp:<line number>: passed: y < z for: 6 < 7
+Generators.tests.cpp:<line number>: passed: x < z for: 3 < 7
+Generators.tests.cpp:<line number>: passed: x < y for: 3 < 6
+Generators.tests.cpp:<line number>: passed: y < z for: 6 < 8
+Generators.tests.cpp:<line number>: passed: x < z for: 3 < 8
+Generators.tests.cpp:<line number>: passed: x < y for: 3 < 6
+Generators.tests.cpp:<line number>: passed: y < z for: 6 < 9
+Generators.tests.cpp:<line number>: passed: x < z for: 3 < 9
+Class.tests.cpp:<line number>: failed: s == "world" for: "hello" == "world"
+Class.tests.cpp:<line number>: passed: s == "hello" for: "hello" == "hello"
+Class.tests.cpp:<line number>: failed: Template_Fixture_2<TestType>::m_a.size() == 1 for: 0 == 1
+Class.tests.cpp:<line number>: failed: Template_Fixture_2<TestType>::m_a.size() == 1 for: 0 == 1
+Class.tests.cpp:<line number>: failed: Template_Fixture_2<TestType>::m_a.size() == 1 for: 0 == 1
+Class.tests.cpp:<line number>: failed: Template_Fixture_2<TestType>::m_a.size() == 1 for: 0 == 1
+Class.tests.cpp:<line number>: passed: Template_Fixture_2<TestType>::m_a.size() == 0 for: 0 == 0
+Class.tests.cpp:<line number>: passed: Template_Fixture_2<TestType>::m_a.size() == 0 for: 0 == 0
+Class.tests.cpp:<line number>: passed: Template_Fixture_2<TestType>::m_a.size() == 0 for: 0 == 0
+Class.tests.cpp:<line number>: passed: Template_Fixture_2<TestType>::m_a.size() == 0 for: 0 == 0
+Class.tests.cpp:<line number>: failed: Template_Fixture_2<TestType>{}.m_a.size() < 2 for: 6 < 2
+Class.tests.cpp:<line number>: failed: Template_Fixture_2<TestType>{}.m_a.size() < 2 for: 2 < 2
+Class.tests.cpp:<line number>: failed: Template_Fixture_2<TestType>{}.m_a.size() < 2 for: 6 < 2
+Class.tests.cpp:<line number>: failed: Template_Fixture_2<TestType>{}.m_a.size() < 2 for: 2 < 2
+Class.tests.cpp:<line number>: passed: Template_Fixture_2<TestType>{}.m_a.size() >= 2 for: 6 >= 2
+Class.tests.cpp:<line number>: passed: Template_Fixture_2<TestType>{}.m_a.size() >= 2 for: 2 >= 2
+Class.tests.cpp:<line number>: passed: Template_Fixture_2<TestType>{}.m_a.size() >= 2 for: 6 >= 2
+Class.tests.cpp:<line number>: passed: Template_Fixture_2<TestType>{}.m_a.size() >= 2 for: 2 >= 2
+Class.tests.cpp:<line number>: failed: Template_Fixture<TestType>::m_a == 2 for: 1.0 == 2
+Class.tests.cpp:<line number>: failed: Template_Fixture<TestType>::m_a == 2 for: 1.0f == 2
+Class.tests.cpp:<line number>: failed: Template_Fixture<TestType>::m_a == 2 for: 1 == 2
+Class.tests.cpp:<line number>: passed: Template_Fixture<TestType>::m_a == 1 for: 1.0 == 1
+Class.tests.cpp:<line number>: passed: Template_Fixture<TestType>::m_a == 1 for: 1.0f == 1
+Class.tests.cpp:<line number>: passed: Template_Fixture<TestType>::m_a == 1 for: 1 == 1
+Class.tests.cpp:<line number>: failed: Nttp_Fixture<V>::value == 0 for: 1 == 0
+Class.tests.cpp:<line number>: failed: Nttp_Fixture<V>::value == 0 for: 3 == 0
+Class.tests.cpp:<line number>: failed: Nttp_Fixture<V>::value == 0 for: 6 == 0
+Class.tests.cpp:<line number>: passed: Nttp_Fixture<V>::value > 0 for: 1 > 0
+Class.tests.cpp:<line number>: passed: Nttp_Fixture<V>::value > 0 for: 3 > 0
+Class.tests.cpp:<line number>: passed: Nttp_Fixture<V>::value > 0 for: 6 > 0
+Class.tests.cpp:<line number>: failed: m_a == 2 for: 1 == 2
+Class.tests.cpp:<line number>: passed: m_a == 1 for: 1 == 1
+Misc.tests.cpp:<line number>: passed: x.size() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: x.size() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: x.size() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: x.size() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: x.size() > 0 for: 42 > 0
+Misc.tests.cpp:<line number>: passed: x.size() > 0 for: 9 > 0
+Misc.tests.cpp:<line number>: passed: x.size() > 0 for: 42 > 0
+Misc.tests.cpp:<line number>: passed: x.size() > 0 for: 9 > 0
+Approx.tests.cpp:<line number>: passed: d == 1.23_a for: 1.23 == Approx( 1.23 )
+Approx.tests.cpp:<line number>: passed: d != 1.22_a for: 1.23 != Approx( 1.22 )
+Approx.tests.cpp:<line number>: passed: -d == -1.23_a for: -1.23 == Approx( -1.23 )
+Approx.tests.cpp:<line number>: passed: d == 1.2_a .epsilon(.1) for: 1.23 == Approx( 1.2 )
+Approx.tests.cpp:<line number>: passed: d != 1.2_a .epsilon(.001) for: 1.23 != Approx( 1.2 )
+Approx.tests.cpp:<line number>: passed: d == 1_a .epsilon(.3) for: 1.23 == Approx( 1.0 )
+Misc.tests.cpp:<line number>: passed: with 1 message: 'that's not flying - that's failing in style'
+Misc.tests.cpp:<line number>: failed: explicitly with 1 message: 'to infinity and beyond'
+Tricky.tests.cpp:<line number>: failed: &o1 == &o2 for: 0x<hex digits> == 0x<hex digits>
+Tricky.tests.cpp:<line number>: failed: o1 == o2 for: {?} == {?}
+Approx.tests.cpp:<line number>: passed: 104.0 != Approx(100.0) for: 104.0 != Approx( 100.0 )
+Approx.tests.cpp:<line number>: passed: 104.0 == Approx(100.0).margin(5) for: 104.0 == Approx( 100.0 )
+Approx.tests.cpp:<line number>: passed: 104.0 == Approx(100.0).margin(4) for: 104.0 == Approx( 100.0 )
+Approx.tests.cpp:<line number>: passed: 104.0 != Approx(100.0).margin(3) for: 104.0 != Approx( 100.0 )
+Approx.tests.cpp:<line number>: passed: 100.3 != Approx(100.0) for: 100.3 != Approx( 100.0 )
+Approx.tests.cpp:<line number>: passed: 100.3 == Approx(100.0).margin(0.5) for: 100.3 == Approx( 100.0 )
+Tricky.tests.cpp:<line number>: passed: i++ == 7 for: 7 == 7
+Tricky.tests.cpp:<line number>: passed: i++ == 8 for: 8 == 8
+Exception.tests.cpp:<line number>: passed: 1 == 1
+Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'unexpected exception'; expression was: {Unknown expression after the reported line}
+VariadicMacros.tests.cpp:<line number>: passed: with 1 message: 'anonymous test case'
+Approx.tests.cpp:<line number>: passed: Approx(0).margin(0)
+Approx.tests.cpp:<line number>: passed: Approx(0).margin(1234656)
+Approx.tests.cpp:<line number>: passed: Approx(0).margin(-2), std::domain_error
+Approx.tests.cpp:<line number>: passed: Approx(0).epsilon(0)
+Approx.tests.cpp:<line number>: passed: Approx(0).epsilon(1)
+Approx.tests.cpp:<line number>: passed: Approx(0).epsilon(-0.001), std::domain_error
+Approx.tests.cpp:<line number>: passed: Approx(0).epsilon(1.0001), std::domain_error
+Approx.tests.cpp:<line number>: passed: 0.25f == Approx(0.0f).margin(0.25f) for: 0.25f == Approx( 0.0 )
+Approx.tests.cpp:<line number>: passed: 0.0f == Approx(0.25f).margin(0.25f) for: 0.0f == Approx( 0.25 )
+Approx.tests.cpp:<line number>: passed: 0.5f == Approx(0.25f).margin(0.25f) for: 0.5f == Approx( 0.25 )
+Approx.tests.cpp:<line number>: passed: 245.0f == Approx(245.25f).margin(0.25f) for: 245.0f == Approx( 245.25 )
+Approx.tests.cpp:<line number>: passed: 245.5f == Approx(245.25f).margin(0.25f) for: 245.5f == Approx( 245.25 )
+Approx.tests.cpp:<line number>: passed: divide( 22, 7 ) == Approx( 3.141 ).epsilon( 0.001 ) for: 3.1428571429 == Approx( 3.141 )
+Approx.tests.cpp:<line number>: passed: divide( 22, 7 ) != Approx( 3.141 ).epsilon( 0.0001 ) for: 3.1428571429 != Approx( 3.141 )
+Approx.tests.cpp:<line number>: passed: d != Approx( 1.231 ) for: 1.23 != Approx( 1.231 )
+Approx.tests.cpp:<line number>: passed: d == Approx( 1.231 ).epsilon( 0.1 ) for: 1.23 == Approx( 1.231 )
+Approx.tests.cpp:<line number>: passed: 1.23f == Approx( 1.23f ) for: 1.23f == Approx( 1.2300000191 )
+Approx.tests.cpp:<line number>: passed: 0.0f == Approx( 0.0f ) for: 0.0f == Approx( 0.0 )
+Approx.tests.cpp:<line number>: passed: 1 == Approx( 1 ) for: 1 == Approx( 1.0 )
+Approx.tests.cpp:<line number>: passed: 0 == Approx( 0 ) for: 0 == Approx( 0.0 )
+Approx.tests.cpp:<line number>: passed: 1.0f == Approx( 1 ) for: 1.0f == Approx( 1.0 )
+Approx.tests.cpp:<line number>: passed: 0 == Approx( dZero) for: 0 == Approx( 0.0 )
+Approx.tests.cpp:<line number>: passed: 0 == Approx( dSmall ).margin( 0.001 ) for: 0 == Approx( 0.00001 )
+Approx.tests.cpp:<line number>: passed: 1.234f == Approx( dMedium ) for: 1.234f == Approx( 1.234 )
+Approx.tests.cpp:<line number>: passed: dMedium == Approx( 1.234f ) for: 1.234 == Approx( 1.2339999676 )
+Matchers.tests.cpp:<line number>: passed: 1, Predicate<int>( alwaysTrue, "always true" ) for: 1 matches predicate: "always true"
+Matchers.tests.cpp:<line number>: passed: 1, !Predicate<int>( alwaysFalse, "always false" ) for: 1 not matches predicate: "always false"
+Matchers.tests.cpp:<line number>: passed: "Hello olleH", Predicate<std::string>( []( std::string const& str ) -> bool { return str.front() == str.back(); }, "First and last character should be equal" ) for: "Hello olleH" matches predicate: "First and last character should be equal"
+Matchers.tests.cpp:<line number>: passed: "This wouldn't pass", !Predicate<std::string>( []( std::string const& str ) -> bool { return str.front() == str.back(); } ) for: "This wouldn't pass" not matches undescribed predicate
+Compilation.tests.cpp:<line number>: passed: lhs | rhs for: Val: 1 | Val: 2
+Compilation.tests.cpp:<line number>: passed: !(lhs & rhs) for: !(Val: 1 & Val: 2)
+Compilation.tests.cpp:<line number>: passed: HasBitOperators{ 1 } & HasBitOperators{ 1 } for: Val: 1 & Val: 1
+Compilation.tests.cpp:<line number>: passed: lhs ^ rhs for: Val: 1 ^ Val: 2
+Compilation.tests.cpp:<line number>: passed: !(lhs ^ lhs) for: !(Val: 1 ^ Val: 1)
+Tricky.tests.cpp:<line number>: passed: true
+Tricky.tests.cpp:<line number>: passed: true
+Tricky.tests.cpp:<line number>: passed: true
+Tricky.tests.cpp:<line number>: passed: true
+Tricky.tests.cpp:<line number>: passed: true
+Tricky.tests.cpp:<line number>: passed: true
+MatchersRanges.tests.cpp:<line number>: passed: a, Contains(1) for: { 1, 2, 3 } contains element 1
+MatchersRanges.tests.cpp:<line number>: passed: b, Contains(1) for: { 0, 1, 2 } contains element 1
+MatchersRanges.tests.cpp:<line number>: passed: c, !Contains(1) for: { 4, 5, 6 } not contains element 1
+MatchersRanges.tests.cpp:<line number>: passed: a, Contains(0, close_enough) for: { 1, 2, 3 } contains element 0
+MatchersRanges.tests.cpp:<line number>: passed: b, Contains(0, close_enough) for: { 0, 1, 2 } contains element 0
+MatchersRanges.tests.cpp:<line number>: passed: c, !Contains(0, close_enough) for: { 4, 5, 6 } not contains element 0
+MatchersRanges.tests.cpp:<line number>: passed: a, Contains(4, [](auto&& lhs, size_t sz) { return lhs.size() == sz; }) for: { "abc", "abcd", "abcde" } contains element 4
+MatchersRanges.tests.cpp:<line number>: passed: in, Contains(1) for: { 1, 2, 3, 4, 5 } contains element 1
+MatchersRanges.tests.cpp:<line number>: passed: in, !Contains(8) for: { 1, 2, 3, 4, 5 } not contains element 8
+MatchersRanges.tests.cpp:<line number>: passed: in, Contains(MoveOnlyTestElement{ 2 }) for: { 1, 2, 3 } contains element 2
+MatchersRanges.tests.cpp:<line number>: passed: in, !Contains(MoveOnlyTestElement{ 9 }) for: { 1, 2, 3 } not contains element 9
+MatchersRanges.tests.cpp:<line number>: passed: in, Contains(Catch::Matchers::WithinAbs(0.5, 0.5)) for: { 1.0, 2.0, 3.0, 0.0 } contains element matching is within 0.5 of 0.5
+MatchersRanges.tests.cpp:<line number>: passed: empty_array, IsEmpty() for: {  } is empty
+MatchersRanges.tests.cpp:<line number>: passed: non_empty_array, !IsEmpty() for: { 0.0 } not is empty
+MatchersRanges.tests.cpp:<line number>: passed: empty_vec, IsEmpty() for: {  } is empty
+MatchersRanges.tests.cpp:<line number>: passed: non_empty_vec, !IsEmpty() for: { 'a', 'b', 'c' } not is empty
+MatchersRanges.tests.cpp:<line number>: passed: inner_lists_are_empty, !IsEmpty() for: { {  } } not is empty
+MatchersRanges.tests.cpp:<line number>: passed: inner_lists_are_empty.front(), IsEmpty() for: {  } is empty
+MatchersRanges.tests.cpp:<line number>: passed: has_empty{}, !IsEmpty() for: {?} not is empty
+MatchersRanges.tests.cpp:<line number>: passed: unrelated::ADL_empty{}, IsEmpty() for: {?} is empty
+Message.tests.cpp:<line number>: passed: with 7 messages: 'a := 1' and 'b := 2' and 'c := 3' and 'a + b := 3' and 'a+b := 3' and 'c > b := true' and 'a == 1 := true'
+Message.tests.cpp:<line number>: passed: with 7 messages: 'std::vector<int>{1, 2, 3}[0, 1, 2] := 3' and 'std::vector<int>{1, 2, 3}[(0, 1)] := 2' and 'std::vector<int>{1, 2, 3}[0] := 1' and '(helper_1436<int, int>{12, -12}) := { 12, -12 }' and '(helper_1436<int, int>(-12, 12)) := { -12, 12 }' and '(1, 2) := 2' and '(2, 3) := 3'
+Message.tests.cpp:<line number>: passed: with 11 messages: '("comma, in string", "escaped, \", ") := "escaped, ", "' and '"single quote in string,'," := "single quote in string,',"' and '"some escapes, \\,\\\\" := "some escapes, \,\\"' and '"some, ), unmatched, } prenheses {[<" := "some, ), unmatched, } prenheses {[<"' and ''"' := '"'' and ''\'' := '''' and '',' := ','' and ''}' := '}'' and '')' := ')'' and ''(' := '('' and ''{' := '{''
+ToStringGeneral.tests.cpp:<line number>: passed: true with 1 message: 'i := 2'
+ToStringGeneral.tests.cpp:<line number>: passed: true with 1 message: '3'
+Details.tests.cpp:<line number>: passed: eq( "", "" ) for: true
+Details.tests.cpp:<line number>: passed: !(eq( "", "a" )) for: !false
+Details.tests.cpp:<line number>: passed: eq( "a", "a" ) for: true
+Details.tests.cpp:<line number>: passed: eq( "a", "A" ) for: true
+Details.tests.cpp:<line number>: passed: eq( "A", "a" ) for: true
+Details.tests.cpp:<line number>: passed: eq( "A", "A" ) for: true
+Details.tests.cpp:<line number>: passed: !(eq( "a", "b" )) for: !false
+Details.tests.cpp:<line number>: passed: !(eq( "a", "B" )) for: !false
+Details.tests.cpp:<line number>: passed: lt( "", "a" ) for: true
+Details.tests.cpp:<line number>: passed: !(lt( "a", "a" )) for: !false
+Details.tests.cpp:<line number>: passed: !(lt( "", "" )) for: !false
+Details.tests.cpp:<line number>: passed: lt( "a", "b" ) for: true
+Details.tests.cpp:<line number>: passed: lt( "a", "B" ) for: true
+Details.tests.cpp:<line number>: passed: lt( "A", "b" ) for: true
+Details.tests.cpp:<line number>: passed: lt( "A", "B" ) for: true
+ToStringGeneral.tests.cpp:<line number>: passed: tab == '\t' for: '\t' == '\t'
+ToStringGeneral.tests.cpp:<line number>: passed: newline == '\n' for: '\n' == '\n'
+ToStringGeneral.tests.cpp:<line number>: passed: carr_return == '\r' for: '\r' == '\r'
+ToStringGeneral.tests.cpp:<line number>: passed: form_feed == '\f' for: '\f' == '\f'
+ToStringGeneral.tests.cpp:<line number>: passed: space == ' ' for: ' ' == ' '
+ToStringGeneral.tests.cpp:<line number>: passed: c == chars[i] for: 'a' == 'a'
+ToStringGeneral.tests.cpp:<line number>: passed: c == chars[i] for: 'z' == 'z'
+ToStringGeneral.tests.cpp:<line number>: passed: c == chars[i] for: 'A' == 'A'
+ToStringGeneral.tests.cpp:<line number>: passed: c == chars[i] for: 'Z' == 'Z'
+ToStringGeneral.tests.cpp:<line number>: passed: null_terminator == '\0' for: 0 == 0
+ToStringGeneral.tests.cpp:<line number>: passed: c == i for: 2 == 2
+ToStringGeneral.tests.cpp:<line number>: passed: c == i for: 3 == 3
+ToStringGeneral.tests.cpp:<line number>: passed: c == i for: 4 == 4
+ToStringGeneral.tests.cpp:<line number>: passed: c == i for: 5 == 5
+Clara.tests.cpp:<line number>: passed: name.empty() for: true
+Clara.tests.cpp:<line number>: passed: name == "foo" for: "foo" == "foo"
+Clara.tests.cpp:<line number>: passed: !(parse_result) for: !{?}
+Clara.tests.cpp:<line number>: passed: parse_result for: {?}
+Clara.tests.cpp:<line number>: passed: res == std::vector<std::string>{ "aaa", "bbb" } for: { "aaa", "bbb" } == { "aaa", "bbb" }
+Matchers.tests.cpp:<line number>: passed: with 1 message: 'std::is_same< decltype( ( MatcherA() && MatcherB() ) && MatcherC() ), Catch::Matchers::Detail:: MatchAllOfGeneric<MatcherA, MatcherB, MatcherC>>::value'
+Matchers.tests.cpp:<line number>: passed: 1, ( MatcherA() && MatcherB() ) && MatcherC() for: 1 ( equals: (int) 1 or (float) 1.0f and equals: (long long) 1 and equals: (T) 1 )
+Matchers.tests.cpp:<line number>: passed: with 1 message: 'std::is_same< decltype( MatcherA() && ( MatcherB() && MatcherC() ) ), Catch::Matchers::Detail:: MatchAllOfGeneric<MatcherA, MatcherB, MatcherC>>::value'
+Matchers.tests.cpp:<line number>: passed: 1, MatcherA() && ( MatcherB() && MatcherC() ) for: 1 ( equals: (int) 1 or (float) 1.0f and equals: (long long) 1 and equals: (T) 1 )
+Matchers.tests.cpp:<line number>: passed: with 1 message: 'std::is_same< decltype( ( MatcherA() && MatcherB() ) && ( MatcherC() && MatcherD() ) ), Catch::Matchers::Detail:: MatchAllOfGeneric<MatcherA, MatcherB, MatcherC, MatcherD>>:: value'
+Matchers.tests.cpp:<line number>: passed: 1, ( MatcherA() && MatcherB() ) && ( MatcherC() && MatcherD() ) for: 1 ( equals: (int) 1 or (float) 1.0f and equals: (long long) 1 and equals: (T) 1 and equals: true )
+Matchers.tests.cpp:<line number>: passed: with 1 message: 'std::is_same< decltype( ( MatcherA() || MatcherB() ) || MatcherC() ), Catch::Matchers::Detail:: MatchAnyOfGeneric<MatcherA, MatcherB, MatcherC>>::value'
+Matchers.tests.cpp:<line number>: passed: 1, ( MatcherA() || MatcherB() ) || MatcherC() for: 1 ( equals: (int) 1 or (float) 1.0f or equals: (long long) 1 or equals: (T) 1 )
+Matchers.tests.cpp:<line number>: passed: with 1 message: 'std::is_same< decltype( MatcherA() || ( MatcherB() || MatcherC() ) ), Catch::Matchers::Detail:: MatchAnyOfGeneric<MatcherA, MatcherB, MatcherC>>::value'
+Matchers.tests.cpp:<line number>: passed: 1, MatcherA() || ( MatcherB() || MatcherC() ) for: 1 ( equals: (int) 1 or (float) 1.0f or equals: (long long) 1 or equals: (T) 1 )
+Matchers.tests.cpp:<line number>: passed: with 1 message: 'std::is_same< decltype( ( MatcherA() || MatcherB() ) || ( MatcherC() || MatcherD() ) ), Catch::Matchers::Detail:: MatchAnyOfGeneric<MatcherA, MatcherB, MatcherC, MatcherD>>:: value'
+Matchers.tests.cpp:<line number>: passed: 1, ( MatcherA() || MatcherB() ) || ( MatcherC() || MatcherD() ) for: 1 ( equals: (int) 1 or (float) 1.0f or equals: (long long) 1 or equals: (T) 1 or equals: true )
+Matchers.tests.cpp:<line number>: passed: with 1 message: 'std::is_same< decltype( !MatcherA() ), Catch::Matchers::Detail::MatchNotOfGeneric<MatcherA>>::value'
+Matchers.tests.cpp:<line number>: passed: 0, !MatcherA() for: 0 not equals: (int) 1 or (float) 1.0f
+Matchers.tests.cpp:<line number>: passed: with 1 message: 'std::is_same<decltype( !!MatcherA() ), MatcherA const&>::value'
+Matchers.tests.cpp:<line number>: passed: 1, !!MatcherA() for: 1 equals: (int) 1 or (float) 1.0f
+Matchers.tests.cpp:<line number>: passed: with 1 message: 'std::is_same< decltype( !!!MatcherA() ), Catch::Matchers::Detail::MatchNotOfGeneric<MatcherA>>::value'
+Matchers.tests.cpp:<line number>: passed: 0, !!!MatcherA() for: 0 not equals: (int) 1 or (float) 1.0f
+Matchers.tests.cpp:<line number>: passed: with 1 message: 'std::is_same<decltype( !!!!MatcherA() ), MatcherA const&>::value'
+Matchers.tests.cpp:<line number>: passed: 1, !!!!MatcherA() for: 1 equals: (int) 1 or (float) 1.0f
+Matchers.tests.cpp:<line number>: passed: with 1 message: 'std::is_same<decltype( StartsWith( "foo" ) || ( StartsWith( "bar" ) && EndsWith( "bar" ) && !EndsWith( "foo" ) ) ), Catch::Matchers::Detail::MatchAnyOf<std::string>>::value'
+Matchers.tests.cpp:<line number>: passed: with 1 message: 'std::is_same<decltype( MatcherA() || MatcherB() ), Catch::Matchers::Detail:: MatchAnyOfGeneric<MatcherA, MatcherB>>::value'
+Matchers.tests.cpp:<line number>: passed: 1, MatcherA() || MatcherB() for: 1 ( equals: (int) 1 or (float) 1.0f or equals: (long long) 1 )
+Matchers.tests.cpp:<line number>: passed: with 1 message: 'std::is_same<decltype( MatcherA() && MatcherB() ), Catch::Matchers::Detail:: MatchAllOfGeneric<MatcherA, MatcherB>>::value'
+Matchers.tests.cpp:<line number>: passed: 1, MatcherA() && MatcherB() for: 1 ( equals: (int) 1 or (float) 1.0f and equals: (long long) 1 )
+Matchers.tests.cpp:<line number>: passed: with 1 message: 'std::is_same< decltype( MatcherA() || !MatcherB() ), Catch::Matchers::Detail::MatchAnyOfGeneric< MatcherA, Catch::Matchers::Detail::MatchNotOfGeneric<MatcherB>>>::value'
+Matchers.tests.cpp:<line number>: passed: 1, MatcherA() || !MatcherB() for: 1 ( equals: (int) 1 or (float) 1.0f or not equals: (long long) 1 )
+Matchers.tests.cpp:<line number>: passed: vec, Predicate<std::vector<int>>( []( auto const& v ) { return std::all_of( v.begin(), v.end(), []( int elem ) { return elem % 2 == 1; } ); }, "All elements are odd" ) && !EqualsRange( a ) for: { 1, 3, 5 } ( matches predicate: "All elements are odd" and not Equals: { 5, 3, 1 } )
+Matchers.tests.cpp:<line number>: passed: str, StartsWith( "foo" ) && EqualsRange( arr ) && EndsWith( "bar" ) for: "foobar" ( starts with: "foo" and Equals: { 'f', 'o', 'o', 'b', 'a', 'r' } and ends with: "bar" )
+Matchers.tests.cpp:<line number>: passed: str, StartsWith( "foo" ) && !EqualsRange( bad_arr ) && EndsWith( "bar" ) for: "foobar" ( starts with: "foo" and not Equals: { 'o', 'o', 'f', 'b', 'a', 'r' } and ends with: "bar" )
+Matchers.tests.cpp:<line number>: passed: str, EqualsRange( arr ) && StartsWith( "foo" ) && EndsWith( "bar" ) for: "foobar" ( Equals: { 'f', 'o', 'o', 'b', 'a', 'r' } and starts with: "foo" and ends with: "bar" )
+Matchers.tests.cpp:<line number>: passed: str, !EqualsRange( bad_arr ) && StartsWith( "foo" ) && EndsWith( "bar" ) for: "foobar" ( not Equals: { 'o', 'o', 'f', 'b', 'a', 'r' } and starts with: "foo" and ends with: "bar" )
+Matchers.tests.cpp:<line number>: passed: str, EqualsRange( bad_arr ) || ( StartsWith( "foo" ) && EndsWith( "bar" ) ) for: "foobar" ( Equals: { 'o', 'o', 'f', 'b', 'a', 'r' } or ( starts with: "foo" and ends with: "bar" ) )
+Matchers.tests.cpp:<line number>: passed: str, ( StartsWith( "foo" ) && EndsWith( "bar" ) ) || EqualsRange( bad_arr ) for: "foobar" ( ( starts with: "foo" and ends with: "bar" ) or Equals: { 'o', 'o', 'f', 'b', 'a', 'r' } )
+Matchers.tests.cpp:<line number>: passed: container, EqualsRange( a ) || EqualsRange( b ) || EqualsRange( c ) for: { 1, 2, 3 } ( Equals: { 1, 2, 3 } or Equals: { 0, 1, 2 } or Equals: { 4, 5, 6 } )
+Tricky.tests.cpp:<line number>: passed: std::vector<constructor_throws>{constructor_throws{}, constructor_throws{}}
+Tricky.tests.cpp:<line number>: passed: std::vector<constructor_throws>{constructor_throws{}, constructor_throws{}}
+Tricky.tests.cpp:<line number>: passed: std::vector<int>{1, 2, 3} == std::vector<int>{1, 2, 3}
+Tricky.tests.cpp:<line number>: passed: std::vector<int>{1, 2, 3} == std::vector<int>{1, 2, 3}
+Tricky.tests.cpp:<line number>: passed: std::vector<int>{1, 2} == std::vector<int>{1, 2} for: { 1, 2 } == { 1, 2 }
+Tricky.tests.cpp:<line number>: passed: std::vector<int>{1, 2} == std::vector<int>{1, 2} for: { 1, 2 } == { 1, 2 }
+Tricky.tests.cpp:<line number>: passed: !(std::vector<int>{1, 2} == std::vector<int>{1, 2, 3}) for: !({ 1, 2 } == { 1, 2, 3 })
+Tricky.tests.cpp:<line number>: passed: !(std::vector<int>{1, 2} == std::vector<int>{1, 2, 3}) for: !({ 1, 2 } == { 1, 2, 3 })
+Tricky.tests.cpp:<line number>: passed: std::vector<int>{1, 2} == std::vector<int>{1, 2} for: { 1, 2 } == { 1, 2 }
+Tricky.tests.cpp:<line number>: passed: std::vector<int>{1, 2} == std::vector<int>{1, 2} for: { 1, 2 } == { 1, 2 }
+Tricky.tests.cpp:<line number>: passed: true
+Tricky.tests.cpp:<line number>: passed: std::vector<int>{1, 2} == std::vector<int>{1, 2} for: { 1, 2 } == { 1, 2 }
+Tricky.tests.cpp:<line number>: passed: a for: 0x<hex digits>
+Tricky.tests.cpp:<line number>: passed: a == &foo for: 0x<hex digits> == 0x<hex digits>
+RandomNumberGeneration.tests.cpp:<line number>: passed: SimplePcg32{} == SimplePcg32{} for: {?} == {?}
+RandomNumberGeneration.tests.cpp:<line number>: passed: SimplePcg32{ 0 } != SimplePcg32{} for: {?} != {?}
+RandomNumberGeneration.tests.cpp:<line number>: passed: !(SimplePcg32{ 1 } == SimplePcg32{ 2 }) for: !({?} == {?})
+RandomNumberGeneration.tests.cpp:<line number>: passed: !(SimplePcg32{ 1 } != SimplePcg32{ 1 }) for: !({?} != {?})
+Approx.tests.cpp:<line number>: passed: td == Approx(10.0) for: StrongDoubleTypedef(10) == Approx( 10.0 )
+Approx.tests.cpp:<line number>: passed: Approx(10.0) == td for: Approx( 10.0 ) == StrongDoubleTypedef(10)
+Approx.tests.cpp:<line number>: passed: td != Approx(11.0) for: StrongDoubleTypedef(10) != Approx( 11.0 )
+Approx.tests.cpp:<line number>: passed: Approx(11.0) != td for: Approx( 11.0 ) != StrongDoubleTypedef(10)
+Approx.tests.cpp:<line number>: passed: td <= Approx(10.0) for: StrongDoubleTypedef(10) <= Approx( 10.0 )
+Approx.tests.cpp:<line number>: passed: td <= Approx(11.0) for: StrongDoubleTypedef(10) <= Approx( 11.0 )
+Approx.tests.cpp:<line number>: passed: Approx(10.0) <= td for: Approx( 10.0 ) <= StrongDoubleTypedef(10)
+Approx.tests.cpp:<line number>: passed: Approx(9.0) <= td for: Approx( 9.0 ) <= StrongDoubleTypedef(10)
+Approx.tests.cpp:<line number>: passed: td >= Approx(9.0) for: StrongDoubleTypedef(10) >= Approx( 9.0 )
+Approx.tests.cpp:<line number>: passed: td >= Approx(td) for: StrongDoubleTypedef(10) >= Approx( 10.0 )
+Approx.tests.cpp:<line number>: passed: Approx(td) >= td for: Approx( 10.0 ) >= StrongDoubleTypedef(10)
+Approx.tests.cpp:<line number>: passed: Approx(11.0) >= td for: Approx( 11.0 ) >= StrongDoubleTypedef(10)
+Condition.tests.cpp:<line number>: passed: 54 == 6*9 for: 54 == 54
+Condition.tests.cpp:<line number>: passed: ( -1 > 2u ) for: true
+Condition.tests.cpp:<line number>: passed: -1 > 2u for: -1 > 2
+Condition.tests.cpp:<line number>: passed: ( 2u < -1 ) for: true
+Condition.tests.cpp:<line number>: passed: 2u < -1 for: 2 < -1
+Condition.tests.cpp:<line number>: passed: ( minInt > 2u ) for: true
+Condition.tests.cpp:<line number>: passed: minInt > 2u for: -2147483648 > 2
+Condition.tests.cpp:<line number>: passed: i == 1 for: 1 == 1
+Condition.tests.cpp:<line number>: passed: ui == 2 for: 2 == 2
+Condition.tests.cpp:<line number>: passed: l == 3 for: 3 == 3
+Condition.tests.cpp:<line number>: passed: ul == 4 for: 4 == 4
+Condition.tests.cpp:<line number>: passed: c == 5 for: 5 == 5
+Condition.tests.cpp:<line number>: passed: uc == 6 for: 6 == 6
+Condition.tests.cpp:<line number>: passed: 1 == i for: 1 == 1
+Condition.tests.cpp:<line number>: passed: 2 == ui for: 2 == 2
+Condition.tests.cpp:<line number>: passed: 3 == l for: 3 == 3
+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: !(matcher.match( 1 )) for: !false
+Matchers.tests.cpp:<line number>: passed: first.matchCalled for: true
+Matchers.tests.cpp:<line number>: passed: !second.matchCalled for: true
+Matchers.tests.cpp:<line number>: passed: matcher.match( 1 ) for: true
+Matchers.tests.cpp:<line number>: passed: first.matchCalled for: true
+Matchers.tests.cpp:<line number>: passed: !second.matchCalled for: true
+Matchers.tests.cpp:<line number>: passed: !(matcher.match( 1 )) for: !false
+Matchers.tests.cpp:<line number>: passed: first.matchCalled for: true
+Matchers.tests.cpp:<line number>: passed: !second.matchCalled for: true
+Matchers.tests.cpp:<line number>: passed: matcher.match( 1 ) for: true
+Matchers.tests.cpp:<line number>: passed: first.matchCalled for: true
+Matchers.tests.cpp:<line number>: passed: !second.matchCalled for: true
+Matchers.tests.cpp:<line number>: failed: testStringForMatching(), ContainsSubstring( "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(), ContainsSubstring( "STRING" ) for: "this string contains 'abc' as a substring" contains: "STRING"
+Generators.tests.cpp:<line number>: passed: elem % 2 == 1 for: 1 == 1
+Generators.tests.cpp:<line number>: passed: elem % 2 == 1 for: 1 == 1
+Generators.tests.cpp:<line number>: passed: elem % 2 == 1 for: 1 == 1
+Generators.tests.cpp:<line number>: passed: elem % 2 == 1 for: 1 == 1
+Generators.tests.cpp:<line number>: passed: elem % 2 == 1 for: 1 == 1
+Generators.tests.cpp:<line number>: passed: elem % 2 == 1 for: 1 == 1
+Generators.tests.cpp:<line number>: passed: elem % 2 == 1 for: 1 == 1
+Generators.tests.cpp:<line number>: passed: elem % 2 == 1 for: 1 == 1
+Generators.tests.cpp:<line number>: passed: elem % 2 == 1 for: 1 == 1
+Generators.tests.cpp:<line number>: passed: elem % 2 == 1 for: 1 == 1
+Generators.tests.cpp:<line number>: passed: elem % 2 == 1 for: 1 == 1
+Generators.tests.cpp:<line number>: passed: elem % 2 == 1 for: 1 == 1
+Generators.tests.cpp:<line number>: passed: call_count == 1 for: 1 == 1
+Generators.tests.cpp:<line number>: passed: make_data().size() == test_count for: 6 == 6
+Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'custom exception - not std'; expression was: throwCustom()
+Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'custom exception - not std'; expression was: throwCustom(), std::exception
+Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'custom std exception'
+Approx.tests.cpp:<line number>: passed: 101.000001 != Approx(100).epsilon(0.01) for: 101.000001 != Approx( 100.0 )
+Approx.tests.cpp:<line number>: passed: std::pow(10, -5) != Approx(std::pow(10, -7)) for: 0.00001 != Approx( 0.0000001 )
+ToString.tests.cpp:<line number>: passed: enumInfo->lookup(0) == "Value1" for: Value1 == "Value1"
+ToString.tests.cpp:<line number>: passed: enumInfo->lookup(1) == "Value2" for: Value2 == "Value2"
+ToString.tests.cpp:<line number>: passed: enumInfo->lookup(3) == "{** unexpected enum value **}" for: {** unexpected enum value **}
+==
+"{** unexpected enum value **}"
+Tag.tests.cpp:<line number>: passed: Catch::TestCaseInfo( "", { "fake test name", "[]" }, dummySourceLineInfo )
+Matchers.tests.cpp:<line number>: failed: testStringForMatching(), EndsWith( "Substring" ) for: "this string contains 'abc' as a substring" ends with: "Substring"
+Matchers.tests.cpp:<line number>: failed: testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" ends with: "this" (case insensitive)
+EnumToString.tests.cpp:<line number>: passed: stringify( EnumClass3::Value1 ) == "Value1" for: "Value1" == "Value1"
+EnumToString.tests.cpp:<line number>: passed: stringify( EnumClass3::Value2 ) == "Value2" for: "Value2" == "Value2"
+EnumToString.tests.cpp:<line number>: passed: stringify( EnumClass3::Value3 ) == "Value3" for: "Value3" == "Value3"
+EnumToString.tests.cpp:<line number>: passed: stringify( EnumClass3::Value4 ) == "{** unexpected enum value **}" for: "{** unexpected enum value **}"
+==
+"{** unexpected enum value **}"
+EnumToString.tests.cpp:<line number>: passed: stringify( ec3 ) == "Value2" for: "Value2" == "Value2"
+EnumToString.tests.cpp:<line number>: passed: stringify( Bikeshed::Colours::Red ) == "Red" for: "Red" == "Red"
+EnumToString.tests.cpp:<line number>: passed: stringify( Bikeshed::Colours::Blue ) == "Blue" for: "Blue" == "Blue"
+Approx.tests.cpp:<line number>: passed: 101.01 != Approx(100).epsilon(0.01) for: 101.01 != Approx( 100.0 )
+Condition.tests.cpp:<line number>: failed: data.int_seven == 6 for: 7 == 6
+Condition.tests.cpp:<line number>: failed: data.int_seven == 8 for: 7 == 8
+Condition.tests.cpp:<line number>: failed: data.int_seven == 0 for: 7 == 0
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one == Approx( 9.11f ) for: 9.1f == Approx( 9.1099996567 )
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one == Approx( 9.0f ) for: 9.1f == Approx( 9.0 )
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one == Approx( 1 ) for: 9.1f == Approx( 1.0 )
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one == Approx( 0 ) for: 9.1f == Approx( 0.0 )
+Condition.tests.cpp:<line number>: failed: data.double_pi == Approx( 3.1415 ) for: 3.1415926535 == Approx( 3.1415 )
+Condition.tests.cpp:<line number>: failed: data.str_hello == "goodbye" for: "hello" == "goodbye"
+Condition.tests.cpp:<line number>: failed: data.str_hello == "hell" for: "hello" == "hell"
+Condition.tests.cpp:<line number>: failed: data.str_hello == "hello1" for: "hello" == "hello1"
+Condition.tests.cpp:<line number>: failed: data.str_hello.size() == 6 for: 5 == 6
+Condition.tests.cpp:<line number>: failed: x == Approx( 1.301 ) for: 1.3 == Approx( 1.301 )
+Condition.tests.cpp:<line number>: passed: data.int_seven == 7 for: 7 == 7
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one == Approx( 9.1f ) for: 9.1f == Approx( 9.1000003815 )
+Condition.tests.cpp:<line number>: passed: data.double_pi == Approx( 3.1415926535 ) for: 3.1415926535 == Approx( 3.1415926535 )
+Condition.tests.cpp:<line number>: passed: data.str_hello == "hello" for: "hello" == "hello"
+Condition.tests.cpp:<line number>: passed: "hello" == data.str_hello for: "hello" == "hello"
+Condition.tests.cpp:<line number>: passed: data.str_hello.size() == 5 for: 5 == 5
+Condition.tests.cpp:<line number>: passed: x == Approx( 1.3 ) for: 1.3 == Approx( 1.3 )
+Matchers.tests.cpp:<line number>: passed: testStringForMatching(), Equals( "this string contains 'abc' as a substring" ) for: "this string contains 'abc' as a substring" equals: "this string contains 'abc' as a substring"
+Matchers.tests.cpp:<line number>: passed: testStringForMatching(), Equals( "this string contains 'ABC' as a substring", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" equals: "this string contains 'abc' as a substring" (case insensitive)
+Matchers.tests.cpp:<line number>: failed: testStringForMatching(), Equals( "this string contains 'ABC' as a substring" ) for: "this string contains 'abc' as a substring" equals: "this string contains 'ABC' as a substring"
+Matchers.tests.cpp:<line number>: failed: testStringForMatching(), Equals( "something else", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" equals: "something else" (case insensitive)
+ToStringGeneral.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(WhatException{}) == "This exception has overridden what() method" for: "This exception has overridden what() method"
+==
+"This exception has overridden what() method"
+ToStringGeneral.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(OperatorException{}) == "OperatorException" for: "OperatorException" == "OperatorException"
+ToStringGeneral.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(StringMakerException{}) == "StringMakerException" for: "StringMakerException"
+==
+"StringMakerException"
+Matchers.tests.cpp:<line number>: failed: expected exception, got none; expression was: doesNotThrow(), SpecialException, ExceptionMatcher{ 1 }
+Matchers.tests.cpp:<line number>: failed: expected exception, got none; expression was: doesNotThrow(), SpecialException, ExceptionMatcher{ 1 }
+Matchers.tests.cpp:<line number>: failed: unexpected exception with message: 'Unknown exception'; expression was: throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 }
+Matchers.tests.cpp:<line number>: failed: unexpected exception with message: 'Unknown exception'; expression was: throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 }
+Matchers.tests.cpp:<line number>: failed: throwsSpecialException( 3 ), SpecialException, ExceptionMatcher{ 1 } for: SpecialException::what special exception has value of 1
+Matchers.tests.cpp:<line number>: failed: throwsSpecialException( 4 ), SpecialException, ExceptionMatcher{ 1 } for: SpecialException::what special exception has value of 1
+Matchers.tests.cpp:<line number>: passed: throwsSpecialException( 1 ), SpecialException, ExceptionMatcher{ 1 } for: SpecialException::what special exception has value of 1
+Matchers.tests.cpp:<line number>: passed: throwsSpecialException( 2 ), SpecialException, ExceptionMatcher{ 2 } for: SpecialException::what special exception has value of 2
+Exception.tests.cpp:<line number>: passed: thisThrows(), "expected exception" for: "expected exception" equals: "expected exception"
+Exception.tests.cpp:<line number>: passed: thisThrows(), Equals( "expecteD Exception", Catch::CaseSensitive::No ) for: "expected exception" equals: "expected exception" (case insensitive)
+Exception.tests.cpp:<line number>: passed: thisThrows(), StartsWith( "expected" ) for: "expected exception" starts with: "expected"
+Exception.tests.cpp:<line number>: passed: thisThrows(), EndsWith( "exception" ) for: "expected exception" ends with: "exception"
+Exception.tests.cpp:<line number>: passed: thisThrows(), ContainsSubstring( "except" ) for: "expected exception" contains: "except"
+Exception.tests.cpp:<line number>: passed: thisThrows(), ContainsSubstring( "exCept", Catch::CaseSensitive::No ) for: "expected exception" contains: "except" (case insensitive)
+Matchers.tests.cpp:<line number>: passed: throwsDerivedException(), DerivedException, Message( "DerivedException::what" ) for: DerivedException::what exception message matches "DerivedException::what"
+Matchers.tests.cpp:<line number>: passed: throwsDerivedException(), DerivedException, !Message( "derivedexception::what" ) for: DerivedException::what not exception message matches "derivedexception::what"
+Matchers.tests.cpp:<line number>: passed: throwsSpecialException( 2 ), SpecialException, !Message( "DerivedException::what" ) for: SpecialException::what not exception message matches "DerivedException::what"
+Matchers.tests.cpp:<line number>: passed: throwsSpecialException( 2 ), SpecialException, Message( "SpecialException::what" ) for: SpecialException::what exception message matches "SpecialException::what"
+Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'expected exception'; expression was: thisThrows(), std::string
+Exception.tests.cpp:<line number>: failed: expected exception, got none; expression was: thisDoesntThrow(), std::domain_error
+Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'expected exception'; expression was: thisThrows()
+Message.tests.cpp:<line number>: failed: explicitly with 1 message: 'This is a failure'
+Message.tests.cpp:<line number>: failed: explicitly
+Message.tests.cpp:<line number>: failed: explicitly with 1 message: 'This is a failure'
+Message.tests.cpp:<line number>: warning: 'This message appears in the output'
+Misc.tests.cpp:<line number>: passed: Factorial(0) == 1 for: 1 == 1
+Misc.tests.cpp:<line number>: passed: Factorial(1) == 1 for: 1 == 1
+Misc.tests.cpp:<line number>: passed: Factorial(2) == 2 for: 2 == 2
+Misc.tests.cpp:<line number>: passed: Factorial(3) == 6 for: 6 == 6
+Misc.tests.cpp:<line number>: passed: Factorial(10) == 3628800 for: 3628800 (0x<hex digits>) == 3628800 (0x<hex digits>)
+Matchers.tests.cpp:<line number>: passed: 10., WithinRel( 11.1, 0.1 ) for: 10.0 and 11.1 are within 10% of each other
+Matchers.tests.cpp:<line number>: passed: 10., !WithinRel( 11.2, 0.1 ) for: 10.0 not and 11.2 are within 10% of each other
+Matchers.tests.cpp:<line number>: passed: 1., !WithinRel( 0., 0.99 ) for: 1.0 not and 0 are within 99% of each other
+Matchers.tests.cpp:<line number>: passed: -0., WithinRel( 0. ) for: -0.0 and 0 are within 2.22045e-12% of each other
+Matchers.tests.cpp:<line number>: passed: v1, WithinRel( v2 ) for: 0.0 and 2.22507e-308 are within 2.22045e-12% of each other
+Matchers.tests.cpp:<line number>: passed: 1., WithinAbs( 1., 0 ) for: 1.0 is within 0.0 of 1.0
+Matchers.tests.cpp:<line number>: passed: 0., WithinAbs( 1., 1 ) for: 0.0 is within 1.0 of 1.0
+Matchers.tests.cpp:<line number>: passed: 0., !WithinAbs( 1., 0.99 ) for: 0.0 not is within 0.99 of 1.0
+Matchers.tests.cpp:<line number>: passed: 0., !WithinAbs( 1., 0.99 ) for: 0.0 not is within 0.99 of 1.0
+Matchers.tests.cpp:<line number>: passed: 11., !WithinAbs( 10., 0.5 ) for: 11.0 not is within 0.5 of 10.0
+Matchers.tests.cpp:<line number>: passed: 10., !WithinAbs( 11., 0.5 ) for: 10.0 not is within 0.5 of 11.0
+Matchers.tests.cpp:<line number>: passed: -10., WithinAbs( -10., 0.5 ) for: -10.0 is within 0.5 of -10.0
+Matchers.tests.cpp:<line number>: passed: -10., WithinAbs( -9.6, 0.5 ) for: -10.0 is within 0.5 of -9.6
+Matchers.tests.cpp:<line number>: passed: 1., WithinULP( 1., 0 ) for: 1.0 is within 0 ULPs of 1.0000000000000000e+00 ([1.0000000000000000e+00, 1.0000000000000000e+00])
+Matchers.tests.cpp:<line number>: passed: nextafter( 1., 2. ), WithinULP( 1., 1 ) for: 1.0 is within 1 ULPs of 1.0000000000000000e+00 ([9.9999999999999989e-01, 1.0000000000000002e+00])
+Matchers.tests.cpp:<line number>: passed: 0., WithinULP( nextafter( 0., 1. ), 1 ) for: 0.0 is within 1 ULPs of 4.9406564584124654e-324 ([0.0000000000000000e+00, 9.8813129168249309e-324])
+Matchers.tests.cpp:<line number>: passed: 1., WithinULP( nextafter( 1., 0. ), 1 ) for: 1.0 is within 1 ULPs of 9.9999999999999989e-01 ([9.9999999999999978e-01, 1.0000000000000000e+00])
+Matchers.tests.cpp:<line number>: passed: 1., !WithinULP( nextafter( 1., 2. ), 0 ) for: 1.0 not is within 0 ULPs of 1.0000000000000002e+00 ([1.0000000000000002e+00, 1.0000000000000002e+00])
+Matchers.tests.cpp:<line number>: passed: 1., WithinULP( 1., 0 ) for: 1.0 is within 0 ULPs of 1.0000000000000000e+00 ([1.0000000000000000e+00, 1.0000000000000000e+00])
+Matchers.tests.cpp:<line number>: passed: -0., WithinULP( 0., 0 ) for: -0.0 is within 0 ULPs of 0.0000000000000000e+00 ([0.0000000000000000e+00, 0.0000000000000000e+00])
+Matchers.tests.cpp:<line number>: passed: 1., WithinAbs( 1., 0.5 ) || WithinULP( 2., 1 ) for: 1.0 ( is within 0.5 of 1.0 or is within 1 ULPs of 2.0000000000000000e+00 ([1.9999999999999998e+00, 2.0000000000000004e+00]) )
+Matchers.tests.cpp:<line number>: passed: 1., WithinAbs( 2., 0.5 ) || WithinULP( 1., 0 ) for: 1.0 ( is within 0.5 of 2.0 or is within 0 ULPs of 1.0000000000000000e+00 ([1.0000000000000000e+00, 1.0000000000000000e+00]) )
+Matchers.tests.cpp:<line number>: passed: 0.0001, WithinAbs( 0., 0.001 ) || WithinRel( 0., 0.1 ) for: 0.0001 ( is within 0.001 of 0.0 or and 0 are within 10% of each other )
+Matchers.tests.cpp:<line number>: passed: WithinAbs( 1., 0. )
+Matchers.tests.cpp:<line number>: passed: WithinAbs( 1., -1. ), std::domain_error
+Matchers.tests.cpp:<line number>: passed: WithinULP( 1., 0 )
+Matchers.tests.cpp:<line number>: passed: WithinRel( 1., 0. )
+Matchers.tests.cpp:<line number>: passed: WithinRel( 1., -0.2 ), std::domain_error
+Matchers.tests.cpp:<line number>: passed: WithinRel( 1., 1. ), std::domain_error
+Matchers.tests.cpp:<line number>: passed: 10.f, WithinRel( 11.1f, 0.1f ) for: 10.0f and 11.1 are within 10% of each other
+Matchers.tests.cpp:<line number>: passed: 10.f, !WithinRel( 11.2f, 0.1f ) for: 10.0f not and 11.2 are within 10% of each other
+Matchers.tests.cpp:<line number>: passed: 1.f, !WithinRel( 0.f, 0.99f ) for: 1.0f not and 0 are within 99% of each other
+Matchers.tests.cpp:<line number>: passed: -0.f, WithinRel( 0.f ) for: -0.0f and 0 are within 0.00119209% of each other
+Matchers.tests.cpp:<line number>: passed: v1, WithinRel( v2 ) for: 0.0f and 1.17549e-38 are within 0.00119209% of each other
+Matchers.tests.cpp:<line number>: passed: 1.f, WithinAbs( 1.f, 0 ) for: 1.0f is within 0.0 of 1.0
+Matchers.tests.cpp:<line number>: passed: 0.f, WithinAbs( 1.f, 1 ) for: 0.0f is within 1.0 of 1.0
+Matchers.tests.cpp:<line number>: passed: 0.f, !WithinAbs( 1.f, 0.99f ) for: 0.0f not is within 0.9900000095 of 1.0
+Matchers.tests.cpp:<line number>: passed: 0.f, !WithinAbs( 1.f, 0.99f ) for: 0.0f not is within 0.9900000095 of 1.0
+Matchers.tests.cpp:<line number>: passed: 0.f, WithinAbs( -0.f, 0 ) for: 0.0f is within 0.0 of -0.0
+Matchers.tests.cpp:<line number>: passed: 11.f, !WithinAbs( 10.f, 0.5f ) for: 11.0f not is within 0.5 of 10.0
+Matchers.tests.cpp:<line number>: passed: 10.f, !WithinAbs( 11.f, 0.5f ) for: 10.0f not is within 0.5 of 11.0
+Matchers.tests.cpp:<line number>: passed: -10.f, WithinAbs( -10.f, 0.5f ) for: -10.0f is within 0.5 of -10.0
+Matchers.tests.cpp:<line number>: passed: -10.f, WithinAbs( -9.6f, 0.5f ) for: -10.0f is within 0.5 of -9.6000003815
+Matchers.tests.cpp:<line number>: passed: 1.f, WithinULP( 1.f, 0 ) for: 1.0f is within 0 ULPs of 1.00000000e+00f ([1.00000000e+00, 1.00000000e+00])
+Matchers.tests.cpp:<line number>: passed: -1.f, WithinULP( -1.f, 0 ) for: -1.0f is within 0 ULPs of -1.00000000e+00f ([-1.00000000e+00, -1.00000000e+00])
+Matchers.tests.cpp:<line number>: passed: nextafter( 1.f, 2.f ), WithinULP( 1.f, 1 ) for: 1.0f is within 1 ULPs of 1.00000000e+00f ([9.99999940e-01, 1.00000012e+00])
+Matchers.tests.cpp:<line number>: passed: 0.f, WithinULP( nextafter( 0.f, 1.f ), 1 ) for: 0.0f is within 1 ULPs of 1.40129846e-45f ([0.00000000e+00, 2.80259693e-45])
+Matchers.tests.cpp:<line number>: passed: 1.f, WithinULP( nextafter( 1.f, 0.f ), 1 ) for: 1.0f is within 1 ULPs of 9.99999940e-01f ([9.99999881e-01, 1.00000000e+00])
+Matchers.tests.cpp:<line number>: passed: 1.f, !WithinULP( nextafter( 1.f, 2.f ), 0 ) for: 1.0f not is within 0 ULPs of 1.00000012e+00f ([1.00000012e+00, 1.00000012e+00])
+Matchers.tests.cpp:<line number>: passed: 1.f, WithinULP( 1.f, 0 ) for: 1.0f is within 0 ULPs of 1.00000000e+00f ([1.00000000e+00, 1.00000000e+00])
+Matchers.tests.cpp:<line number>: passed: -0.f, WithinULP( 0.f, 0 ) for: -0.0f is within 0 ULPs of 0.00000000e+00f ([0.00000000e+00, 0.00000000e+00])
+Matchers.tests.cpp:<line number>: passed: 1.f, WithinAbs( 1.f, 0.5 ) || WithinULP( 1.f, 1 ) for: 1.0f ( is within 0.5 of 1.0 or is within 1 ULPs of 1.00000000e+00f ([9.99999940e-01, 1.00000012e+00]) )
+Matchers.tests.cpp:<line number>: passed: 1.f, WithinAbs( 2.f, 0.5 ) || WithinULP( 1.f, 0 ) for: 1.0f ( is within 0.5 of 2.0 or is within 0 ULPs of 1.00000000e+00f ([1.00000000e+00, 1.00000000e+00]) )
+Matchers.tests.cpp:<line number>: passed: 0.0001f, WithinAbs( 0.f, 0.001f ) || WithinRel( 0.f, 0.1f ) for: 0.0001f ( is within 0.001 of 0.0 or and 0 are within 10% of each other )
+Matchers.tests.cpp:<line number>: passed: WithinAbs( 1.f, 0.f )
+Matchers.tests.cpp:<line number>: passed: WithinAbs( 1.f, -1.f ), std::domain_error
+Matchers.tests.cpp:<line number>: passed: WithinULP( 1.f, 0 )
+Matchers.tests.cpp:<line number>: passed: WithinULP( 1.f, static_cast<uint64_t>( -1 ) ), std::domain_error
+Matchers.tests.cpp:<line number>: passed: WithinRel( 1.f, 0.f )
+Matchers.tests.cpp:<line number>: passed: WithinRel( 1.f, -0.2f ), std::domain_error
+Matchers.tests.cpp:<line number>: passed: WithinRel( 1.f, 1.f ), std::domain_error
+Generators.tests.cpp:<line number>: passed: i % 2 == 0 for: 0 == 0
+Generators.tests.cpp:<line number>: passed: i % 2 == 0 for: 0 == 0
+Generators.tests.cpp:<line number>: passed: i % 2 == 0 for: 0 == 0
+Generators.tests.cpp:<line number>: passed: filter([] (int) {return false; }, value(1)), Catch::GeneratorException
+Generators.tests.cpp:<line number>: passed: i < 4 for: 1 < 4
+Generators.tests.cpp:<line number>: passed: i < 4 for: 2 < 4
+Generators.tests.cpp:<line number>: passed: i < 4 for: 3 < 4
+Generators.tests.cpp:<line number>: passed: i % 2 == 0 for: 0 == 0
+Generators.tests.cpp:<line number>: passed: i % 2 == 0 for: 0 == 0
+Generators.tests.cpp:<line number>: passed: i % 2 == 0 for: 0 == 0
+Generators.tests.cpp:<line number>: passed: i.size() == 1 for: 1 == 1
+Generators.tests.cpp:<line number>: passed: i.size() == 1 for: 1 == 1
+Generators.tests.cpp:<line number>: passed: i.size() == 1 for: 1 == 1
+Generators.tests.cpp:<line number>: passed: i.size() == 1 for: 1 == 1
+Generators.tests.cpp:<line number>: passed: i.size() == 1 for: 1 == 1
+Generators.tests.cpp:<line number>: passed: i.size() == 1 for: 1 == 1
+Generators.tests.cpp:<line number>: passed: j > 0 for: 1 > 0
+Generators.tests.cpp:<line number>: passed: j > 0 for: 2 > 0
+Generators.tests.cpp:<line number>: passed: j > 0 for: 3 > 0
+Generators.tests.cpp:<line number>: passed: j > 0 for: 1 > 0
+Generators.tests.cpp:<line number>: passed: j > 0 for: 2 > 0
+Generators.tests.cpp:<line number>: passed: j > 0 for: 3 > 0
+Generators.tests.cpp:<line number>: passed: chunk2.size() == 2 for: 2 == 2
+Generators.tests.cpp:<line number>: passed: chunk2.front() == chunk2.back() for: 1 == 1
+Generators.tests.cpp:<line number>: passed: chunk2.size() == 2 for: 2 == 2
+Generators.tests.cpp:<line number>: passed: chunk2.front() == chunk2.back() for: 2 == 2
+Generators.tests.cpp:<line number>: passed: chunk2.size() == 2 for: 2 == 2
+Generators.tests.cpp:<line number>: passed: chunk2.front() == chunk2.back() for: 3 == 3
+Generators.tests.cpp:<line number>: passed: chunk2.size() == 2 for: 2 == 2
+Generators.tests.cpp:<line number>: passed: chunk2.front() == chunk2.back() for: 1 == 1
+Generators.tests.cpp:<line number>: passed: chunk2.front() < 3 for: 1 < 3
+Generators.tests.cpp:<line number>: passed: chunk2.size() == 2 for: 2 == 2
+Generators.tests.cpp:<line number>: passed: chunk2.front() == chunk2.back() for: 2 == 2
+Generators.tests.cpp:<line number>: passed: chunk2.front() < 3 for: 2 < 3
+Generators.tests.cpp:<line number>: passed: chunk2.size() == 0 for: 0 == 0
+Generators.tests.cpp:<line number>: passed: chunk2.size() == 0 for: 0 == 0
+Generators.tests.cpp:<line number>: passed: chunk2.size() == 0 for: 0 == 0
+Generators.tests.cpp:<line number>: passed: chunk(2, value(1)), Catch::GeneratorException
+Generators.tests.cpp:<line number>: passed: j < i for: -3 < 1
+Generators.tests.cpp:<line number>: passed: j < i for: -2 < 1
+Generators.tests.cpp:<line number>: passed: j < i for: -1 < 1
+Generators.tests.cpp:<line number>: passed: 4u * i > str.size() for: 4 > 1
+Generators.tests.cpp:<line number>: passed: 4u * i > str.size() for: 4 > 2
+Generators.tests.cpp:<line number>: passed: 4u * i > str.size() for: 4 > 3
+Generators.tests.cpp:<line number>: passed: j < i for: -3 < 2
+Generators.tests.cpp:<line number>: passed: j < i for: -2 < 2
+Generators.tests.cpp:<line number>: passed: j < i for: -1 < 2
+Generators.tests.cpp:<line number>: passed: 4u * i > str.size() for: 8 > 1
+Generators.tests.cpp:<line number>: passed: 4u * i > str.size() for: 8 > 2
+Generators.tests.cpp:<line number>: passed: 4u * i > str.size() for: 8 > 3
+Generators.tests.cpp:<line number>: passed: j < i for: -3 < 3
+Generators.tests.cpp:<line number>: passed: j < i for: -2 < 3
+Generators.tests.cpp:<line number>: passed: j < i for: -1 < 3
+Generators.tests.cpp:<line number>: passed: 4u * i > str.size() for: 12 > 1
+Generators.tests.cpp:<line number>: passed: 4u * i > str.size() for: 12 > 2
+Generators.tests.cpp:<line number>: passed: 4u * i > str.size() for: 12 > 3
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 123 for: 123 == 123
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 1 for: 1 == 1
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 3 for: 3 == 3
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 5 for: 5 == 5
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 1 for: 1 == 1
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 5 for: 5 == 5
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 2 for: 2 == 2
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 4 for: 4 == 4
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 0 for: 0 == 0
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get().size() == 2 for: 2 == 2
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == "aa" for: "aa" == "aa"
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == "bb" for: "bb" == "bb"
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == "cc" for: "cc" == "cc"
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 1 for: 1 == 1
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 3 for: 3 == 3
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 1 for: 1 == 1
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 3 for: 3 == 3
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: filter([](int) { return false; }, value(1)), Catch::GeneratorException
+GeneratorsImpl.tests.cpp:<line number>: passed: filter([](int) { return false; }, values({ 1, 2, 3 })), Catch::GeneratorException
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 1 for: 1 == 1
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 2 for: 2 == 2
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 1 for: 1 == 1
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 2.0 for: 2.0 == 2.0
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 4.0 for: 4.0 == 4.0
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 6.0 for: 6.0 == 6.0
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 2.0 for: 2.0 == 2.0
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 4.0 for: 4.0 == 4.0
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 6.0 for: 6.0 == 6.0
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 3 for: 3 == 3
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 1 for: 1 == 1
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 2 for: 2 == 2
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 3 for: 3 == 3
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 1 for: 1 == 1
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 2 for: 2 == 2
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 3 for: 3 == 3
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -2 for: -2 == -2
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -1 for: -1 == -1
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 0 for: 0 == 0
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 1 for: 1 == 1
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 2 for: 2 == 2
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 1 for: 1 == 1
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 0 for: 0 == 0
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -1 for: -1 == -1
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -7 for: -7 == -7
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -4 for: -4 == -4
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -1 for: -1 == -1
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 2 for: 2 == 2
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -7 for: -7 == -7
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -4 for: -4 == -4
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -1 for: -1 == -1
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 2 for: 2 == 2
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -7 for: -7 == -7
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -4 for: -4 == -4
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -1 for: -1 == -1
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 2 for: 2 == 2
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 5 for: 5 == 5
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -1.0 == Approx( -1.0 ) with 1 message: 'Current expected value is -1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.9 == Approx( -0.9 ) with 1 message: 'Current expected value is -0.9'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.9'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.8 == Approx( -0.8 ) with 1 message: 'Current expected value is -0.8'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.8'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.7 == Approx( -0.7 ) with 1 message: 'Current expected value is -0.7'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.7'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.6 == Approx( -0.6 ) with 1 message: 'Current expected value is -0.6'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.6'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.5 == Approx( -0.5 ) with 1 message: 'Current expected value is -0.5'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.5'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.4 == Approx( -0.4 ) with 1 message: 'Current expected value is -0.4'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.4'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.3 == Approx( -0.3 ) with 1 message: 'Current expected value is -0.3'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.3'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.2 == Approx( -0.2 ) with 1 message: 'Current expected value is -0.2'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.2'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.1 == Approx( -0.1 ) with 1 message: 'Current expected value is -0.1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.0 == Approx( -0.0 ) with 1 message: 'Current expected value is -1.38778e-16'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -1.38778e-16'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.1 == Approx( 0.1 ) with 1 message: 'Current expected value is 0.1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.2 == Approx( 0.2 ) with 1 message: 'Current expected value is 0.2'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.2'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.3 == Approx( 0.3 ) with 1 message: 'Current expected value is 0.3'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.3'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.4 == Approx( 0.4 ) with 1 message: 'Current expected value is 0.4'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.4'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.5 == Approx( 0.5 ) with 1 message: 'Current expected value is 0.5'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.5'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.6 == Approx( 0.6 ) with 1 message: 'Current expected value is 0.6'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.6'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.7 == Approx( 0.7 ) with 1 message: 'Current expected value is 0.7'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.7'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.8 == Approx( 0.8 ) with 1 message: 'Current expected value is 0.8'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.8'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.9 == Approx( 0.9 ) with 1 message: 'Current expected value is 0.9'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.9'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx( rangeEnd ) for: 1.0 == Approx( 1.0 )
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -1.0 == Approx( -1.0 ) with 1 message: 'Current expected value is -1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.7 == Approx( -0.7 ) with 1 message: 'Current expected value is -0.7'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.7'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.4 == Approx( -0.4 ) with 1 message: 'Current expected value is -0.4'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.4'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.1 == Approx( -0.1 ) with 1 message: 'Current expected value is -0.1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.2 == Approx( 0.2 ) with 1 message: 'Current expected value is 0.2'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.2'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.5 == Approx( 0.5 ) with 1 message: 'Current expected value is 0.5'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.5'
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -1.0 == Approx( -1.0 ) with 1 message: 'Current expected value is -1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.7 == Approx( -0.7 ) with 1 message: 'Current expected value is -0.7'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.7'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.4 == Approx( -0.4 ) with 1 message: 'Current expected value is -0.4'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.4'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: -0.1 == Approx( -0.1 ) with 1 message: 'Current expected value is -0.1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is -0.1'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.2 == Approx( 0.2 ) with 1 message: 'Current expected value is 0.2'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.2'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == Approx(expected) for: 0.5 == Approx( 0.5 ) with 1 message: 'Current expected value is 0.5'
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true with 1 message: 'Current expected value is 0.5'
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 5 for: 5 == 5
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 2 for: 2 == 2
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -1 for: -1 == -1
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -4 for: -4 == -4
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 5 for: 5 == 5
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 2 for: 2 == 2
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -1 for: -1 == -1
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -4 for: -4 == -4
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 5 for: 5 == 5
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == 2 for: 2 == 2
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -1 for: -1 == -1
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -4 for: -4 == -4
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.next() for: true
+GeneratorsImpl.tests.cpp:<line number>: passed: gen.get() == -7 for: -7 == -7
+GeneratorsImpl.tests.cpp:<line number>: passed: !(gen.next()) for: !false
+Approx.tests.cpp:<line number>: passed: d >= Approx( 1.22 ) for: 1.23 >= Approx( 1.22 )
+Approx.tests.cpp:<line number>: passed: d >= Approx( 1.23 ) for: 1.23 >= Approx( 1.23 )
+Approx.tests.cpp:<line number>: passed: !(d >= Approx( 1.24 )) for: !(1.23 >= Approx( 1.24 ))
+Approx.tests.cpp:<line number>: passed: d >= Approx( 1.24 ).epsilon(0.1) for: 1.23 >= Approx( 1.24 )
+Message.tests.cpp:<line number>: warning: 'this is a message' with 1 message: 'this is a warning'
+Message.tests.cpp:<line number>: failed: a == 1 for: 2 == 1 with 2 messages: 'this message should be logged' and 'so should this'
+Message.tests.cpp:<line number>: passed: a == 2 for: 2 == 2 with 1 message: 'this message may be logged later'
+Message.tests.cpp:<line number>: failed: a == 1 for: 2 == 1 with 2 messages: 'this message may be logged later' and 'this message should be logged'
+Message.tests.cpp:<line number>: failed: a == 0 for: 2 == 0 with 3 messages: 'this message may be logged later' and 'this message should be logged' and 'and this, but later'
+Message.tests.cpp:<line number>: passed: a == 2 for: 2 == 2 with 4 messages: 'this message may be logged later' and 'this message should be logged' and 'and this, but later' and 'but not this'
+Message.tests.cpp:<line number>: passed: i < 10 for: 0 < 10 with 2 messages: 'current counter 0' and 'i := 0'
+Message.tests.cpp:<line number>: passed: i < 10 for: 1 < 10 with 2 messages: 'current counter 1' and 'i := 1'
+Message.tests.cpp:<line number>: passed: i < 10 for: 2 < 10 with 2 messages: 'current counter 2' and 'i := 2'
+Message.tests.cpp:<line number>: passed: i < 10 for: 3 < 10 with 2 messages: 'current counter 3' and 'i := 3'
+Message.tests.cpp:<line number>: passed: i < 10 for: 4 < 10 with 2 messages: 'current counter 4' and 'i := 4'
+Message.tests.cpp:<line number>: passed: i < 10 for: 5 < 10 with 2 messages: 'current counter 5' and 'i := 5'
+Message.tests.cpp:<line number>: passed: i < 10 for: 6 < 10 with 2 messages: 'current counter 6' and 'i := 6'
+Message.tests.cpp:<line number>: passed: i < 10 for: 7 < 10 with 2 messages: 'current counter 7' and 'i := 7'
+Message.tests.cpp:<line number>: passed: i < 10 for: 8 < 10 with 2 messages: 'current counter 8' and 'i := 8'
+Message.tests.cpp:<line number>: passed: i < 10 for: 9 < 10 with 2 messages: 'current counter 9' and 'i := 9'
+Message.tests.cpp:<line number>: failed: i < 10 for: 10 < 10 with 2 messages: 'current counter 10' and 'i := 10'
+Condition.tests.cpp:<line number>: failed: data.int_seven != 7 for: 7 != 7
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one != Approx( 9.1f ) for: 9.1f != Approx( 9.1000003815 )
+Condition.tests.cpp:<line number>: failed: data.double_pi != Approx( 3.1415926535 ) for: 3.1415926535 != Approx( 3.1415926535 )
+Condition.tests.cpp:<line number>: failed: data.str_hello != "hello" for: "hello" != "hello"
+Condition.tests.cpp:<line number>: failed: data.str_hello.size() != 5 for: 5 != 5
+Condition.tests.cpp:<line number>: passed: data.int_seven != 6 for: 7 != 6
+Condition.tests.cpp:<line number>: passed: data.int_seven != 8 for: 7 != 8
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one != Approx( 9.11f ) for: 9.1f != Approx( 9.1099996567 )
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one != Approx( 9.0f ) for: 9.1f != Approx( 9.0 )
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one != Approx( 1 ) for: 9.1f != Approx( 1.0 )
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one != Approx( 0 ) for: 9.1f != Approx( 0.0 )
+Condition.tests.cpp:<line number>: passed: data.double_pi != Approx( 3.1415 ) for: 3.1415926535 != Approx( 3.1415 )
+Condition.tests.cpp:<line number>: passed: data.str_hello != "goodbye" for: "hello" != "goodbye"
+Condition.tests.cpp:<line number>: passed: data.str_hello != "hell" for: "hello" != "hell"
+Condition.tests.cpp:<line number>: passed: data.str_hello != "hello1" for: "hello" != "hello1"
+Condition.tests.cpp:<line number>: passed: data.str_hello.size() != 6 for: 5 != 6
+Compilation.tests.cpp:<line number>: passed: []() { return true; }() for: true
+Approx.tests.cpp:<line number>: passed: d <= Approx( 1.24 ) for: 1.23 <= Approx( 1.24 )
+Approx.tests.cpp:<line number>: passed: d <= Approx( 1.23 ) for: 1.23 <= Approx( 1.23 )
+Approx.tests.cpp:<line number>: passed: !(d <= Approx( 1.22 )) for: !(1.23 <= Approx( 1.22 ))
+Approx.tests.cpp:<line number>: passed: d <= Approx( 1.22 ).epsilon(0.1) for: 1.23 <= Approx( 1.22 )
+Misc.tests.cpp:<line number>: passed: with 1 message: 'was called'
+Matchers.tests.cpp:<line number>: passed: testStringForMatching(), ContainsSubstring( "string" ) && ContainsSubstring( "abc" ) && ContainsSubstring( "substring" ) && ContainsSubstring( "contains" ) for: "this string contains 'abc' as a substring" ( contains: "string" and contains: "abc" and contains: "substring" and contains: "contains" )
+Matchers.tests.cpp:<line number>: passed: testStringForMatching(), ContainsSubstring( "string" ) || ContainsSubstring( "different" ) || ContainsSubstring( "random" ) for: "this string contains 'abc' as a substring" ( contains: "string" or contains: "different" or contains: "random" )
+Matchers.tests.cpp:<line number>: passed: testStringForMatching2(), ContainsSubstring( "string" ) || ContainsSubstring( "different" ) || ContainsSubstring( "random" ) for: "some completely different text that contains one common word" ( contains: "string" or contains: "different" or contains: "random" )
+Matchers.tests.cpp:<line number>: passed: testStringForMatching(), ( ContainsSubstring( "string" ) || ContainsSubstring( "different" ) ) && ContainsSubstring( "substring" ) for: "this string contains 'abc' as a substring" ( ( contains: "string" or contains: "different" ) and contains: "substring" )
+Matchers.tests.cpp:<line number>: failed: testStringForMatching(), ( ContainsSubstring( "string" ) || ContainsSubstring( "different" ) ) && ContainsSubstring( "random" ) for: "this string contains 'abc' as a substring" ( ( contains: "string" or contains: "different" ) and contains: "random" )
+Matchers.tests.cpp:<line number>: passed: testStringForMatching(), !ContainsSubstring( "different" ) for: "this string contains 'abc' as a substring" not contains: "different"
+Matchers.tests.cpp:<line number>: failed: testStringForMatching(), !ContainsSubstring( "substring" ) for: "this string contains 'abc' as a substring" not contains: "substring"
+Condition.tests.cpp:<line number>: failed: explicitly
+Condition.tests.cpp:<line number>: failed: explicitly
+Condition.tests.cpp:<line number>: failed: explicitly
+Condition.tests.cpp:<line number>: failed: explicitly
+Exception.tests.cpp:<line number>: passed: thisThrows(), "expected exception" for: "expected exception" equals: "expected exception"
+Exception.tests.cpp:<line number>: failed: thisThrows(), "should fail" for: "expected exception" equals: "should fail"
+Generators.tests.cpp:<line number>: passed: values > -6 for: 3 > -6
+Generators.tests.cpp:<line number>: passed: values > -6 for: 4 > -6
+Generators.tests.cpp:<line number>: passed: values > -6 for: 5 > -6
+Generators.tests.cpp:<line number>: passed: values > -6 for: 6 > -6
+Generators.tests.cpp:<line number>: passed: values > -6 for: -5 > -6
+Generators.tests.cpp:<line number>: passed: values > -6 for: -4 > -6
+Generators.tests.cpp:<line number>: passed: values > -6 for: 90 > -6
+Generators.tests.cpp:<line number>: passed: values > -6 for: 91 > -6
+Generators.tests.cpp:<line number>: passed: values > -6 for: 92 > -6
+Generators.tests.cpp:<line number>: passed: values > -6 for: 93 > -6
+Generators.tests.cpp:<line number>: passed: values > -6 for: 94 > -6
+Generators.tests.cpp:<line number>: passed: values > -6 for: 95 > -6
+Generators.tests.cpp:<line number>: passed: values > -6 for: 96 > -6
+Generators.tests.cpp:<line number>: passed: values > -6 for: 97 > -6
+Generators.tests.cpp:<line number>: passed: values > -6 for: 98 > -6
+Generators.tests.cpp:<line number>: passed: values > -6 for: 99 > -6
+Misc.tests.cpp:<line number>: warning: 'This one ran'
+Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'custom exception'
+Tricky.tests.cpp:<line number>: passed: True for: {?}
+Tricky.tests.cpp:<line number>: passed: !False for: true
+Tricky.tests.cpp:<line number>: passed: !(False) for: !{?}
+Compilation.tests.cpp:<line number>: passed: with 1 message: 'std::is_void<void>::value'
+Compilation.tests.cpp:<line number>: passed: with 1 message: '!(std::is_void<int>::value)'
+Compilation.tests.cpp:<line number>: passed: with 1 message: 'std::is_void<void>::value'
+Compilation.tests.cpp:<line number>: passed: with 1 message: '!(std::is_void<int>::value)'
+Condition.tests.cpp:<line number>: failed: data.int_seven > 7 for: 7 > 7
+Condition.tests.cpp:<line number>: failed: data.int_seven < 7 for: 7 < 7
+Condition.tests.cpp:<line number>: failed: data.int_seven > 8 for: 7 > 8
+Condition.tests.cpp:<line number>: failed: data.int_seven < 6 for: 7 < 6
+Condition.tests.cpp:<line number>: failed: data.int_seven < 0 for: 7 < 0
+Condition.tests.cpp:<line number>: failed: data.int_seven < -1 for: 7 < -1
+Condition.tests.cpp:<line number>: failed: data.int_seven >= 8 for: 7 >= 8
+Condition.tests.cpp:<line number>: failed: data.int_seven <= 6 for: 7 <= 6
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one < 9 for: 9.1f < 9
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one > 10 for: 9.1f > 10
+Condition.tests.cpp:<line number>: failed: data.float_nine_point_one > 9.2 for: 9.1f > 9.2
+Condition.tests.cpp:<line number>: failed: data.str_hello > "hello" for: "hello" > "hello"
+Condition.tests.cpp:<line number>: failed: data.str_hello < "hello" for: "hello" < "hello"
+Condition.tests.cpp:<line number>: failed: data.str_hello > "hellp" for: "hello" > "hellp"
+Condition.tests.cpp:<line number>: failed: data.str_hello > "z" for: "hello" > "z"
+Condition.tests.cpp:<line number>: failed: data.str_hello < "hellm" for: "hello" < "hellm"
+Condition.tests.cpp:<line number>: failed: data.str_hello < "a" for: "hello" < "a"
+Condition.tests.cpp:<line number>: failed: data.str_hello >= "z" for: "hello" >= "z"
+Condition.tests.cpp:<line number>: failed: data.str_hello <= "a" for: "hello" <= "a"
+Condition.tests.cpp:<line number>: passed: data.int_seven < 8 for: 7 < 8
+Condition.tests.cpp:<line number>: passed: data.int_seven > 6 for: 7 > 6
+Condition.tests.cpp:<line number>: passed: data.int_seven > 0 for: 7 > 0
+Condition.tests.cpp:<line number>: passed: data.int_seven > -1 for: 7 > -1
+Condition.tests.cpp:<line number>: passed: data.int_seven >= 7 for: 7 >= 7
+Condition.tests.cpp:<line number>: passed: data.int_seven >= 6 for: 7 >= 6
+Condition.tests.cpp:<line number>: passed: data.int_seven <= 7 for: 7 <= 7
+Condition.tests.cpp:<line number>: passed: data.int_seven <= 8 for: 7 <= 8
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one > 9 for: 9.1f > 9
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one < 10 for: 9.1f < 10
+Condition.tests.cpp:<line number>: passed: data.float_nine_point_one < 9.2 for: 9.1f < 9.2
+Condition.tests.cpp:<line number>: passed: data.str_hello <= "hello" for: "hello" <= "hello"
+Condition.tests.cpp:<line number>: passed: data.str_hello >= "hello" for: "hello" >= "hello"
+Condition.tests.cpp:<line number>: passed: data.str_hello < "hellp" for: "hello" < "hellp"
+Condition.tests.cpp:<line number>: passed: data.str_hello < "zebra" for: "hello" < "zebra"
+Condition.tests.cpp:<line number>: passed: data.str_hello > "hellm" for: "hello" > "hellm"
+Condition.tests.cpp:<line number>: passed: data.str_hello > "a" for: "hello" > "a"
+RandomNumberGeneration.tests.cpp:<line number>: passed: rng() == 0x<hex digits> for: 4242248763 (0x<hex digits>)
+==
+4242248763 (0x<hex digits>)
+RandomNumberGeneration.tests.cpp:<line number>: passed: rng() == 0x<hex digits> for: 1867888929 (0x<hex digits>)
+==
+1867888929 (0x<hex digits>)
+RandomNumberGeneration.tests.cpp:<line number>: passed: rng() == 0x<hex digits> for: 1276619030 (0x<hex digits>)
+==
+1276619030 (0x<hex digits>)
+RandomNumberGeneration.tests.cpp:<line number>: passed: rng() == 0x<hex digits> for: 1911218783 (0x<hex digits>)
+==
+1911218783 (0x<hex digits>)
+RandomNumberGeneration.tests.cpp:<line number>: passed: rng() == 0x<hex digits> for: 1827115164 (0x<hex digits>)
+==
+1827115164 (0x<hex digits>)
+RandomNumberGeneration.tests.cpp:<line number>: passed: rng() == 0x<hex digits> for: 1472234645 (0x<hex digits>)
+==
+1472234645 (0x<hex digits>)
+RandomNumberGeneration.tests.cpp:<line number>: passed: rng() == 0x<hex digits> for: 868832940 (0x<hex digits>)
+==
+868832940 (0x<hex digits>)
+RandomNumberGeneration.tests.cpp:<line number>: passed: rng() == 0x<hex digits> for: 570883446 (0x<hex digits>)
+==
+570883446 (0x<hex digits>)
+RandomNumberGeneration.tests.cpp:<line number>: passed: rng() == 0x<hex digits> for: 889299803 (0x<hex digits>)
+==
+889299803 (0x<hex digits>)
+RandomNumberGeneration.tests.cpp:<line number>: passed: rng() == 0x<hex digits> for: 4261393167 (0x<hex digits>)
+==
+4261393167 (0x<hex digits>)
+RandomNumberGeneration.tests.cpp:<line number>: passed: rng() == 0x<hex digits> for: 1472234645 (0x<hex digits>)
+==
+1472234645 (0x<hex digits>)
+RandomNumberGeneration.tests.cpp:<line number>: passed: rng() == 0x<hex digits> for: 868832940 (0x<hex digits>)
+==
+868832940 (0x<hex digits>)
+RandomNumberGeneration.tests.cpp:<line number>: passed: rng() == 0x<hex digits> for: 570883446 (0x<hex digits>)
+==
+570883446 (0x<hex digits>)
+RandomNumberGeneration.tests.cpp:<line number>: passed: rng() == 0x<hex digits> for: 889299803 (0x<hex digits>)
+==
+889299803 (0x<hex digits>)
+RandomNumberGeneration.tests.cpp:<line number>: passed: rng() == 0x<hex digits> for: 4261393167 (0x<hex digits>)
+==
+4261393167 (0x<hex digits>)
+Message.tests.cpp:<line number>: failed: explicitly with 1 message: 'Message from section one'
+Message.tests.cpp:<line number>: failed: explicitly with 1 message: 'Message from section two'
+Matchers.tests.cpp:<line number>: passed: ( EvilMatcher(), EvilMatcher() ), EvilCommaOperatorUsed
+Matchers.tests.cpp:<line number>: passed: &EvilMatcher(), EvilAddressOfOperatorUsed
+Matchers.tests.cpp:<line number>: passed: EvilMatcher() || ( EvilMatcher() && !EvilMatcher() )
+Matchers.tests.cpp:<line number>: passed: ( EvilMatcher() && EvilMatcher() ) || !EvilMatcher()
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: parseTestSpec( "*a" ).matches( *tcA ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: parseTestSpec( "a*" ).matches( *tcA ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: parseTestSpec( "*a*" ).matches( *tcA ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == 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( " 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( "  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( "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
+TestSpecParser.tests.cpp:<line number>: passed: spec.hasFilters() for: true
+TestSpecParser.tests.cpp:<line number>: passed: spec.getInvalidSpecs().empty() for: true
+TestSpecParser.tests.cpp:<line number>: passed: spec.matches( testCase ) for: true
+CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--shard-count=8" }) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.shardCount == 8 for: 8 == 8
+CmdLine.tests.cpp:<line number>: passed: !(result) for: !{?}
+CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring("Shard count must be a positive number") for: "Shard count must be a positive number" contains: "Shard count must be a positive number"
+CmdLine.tests.cpp:<line number>: passed: !(result) for: !{?}
+CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring("Shard count must be a positive number") for: "Shard count must be a positive number" contains: "Shard count must be a positive number"
+CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--shard-index=2" }) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.shardIndex == 2 for: 2 == 2
+CmdLine.tests.cpp:<line number>: passed: !(result) for: !{?}
+CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring("Shard index must be a non-negative number") for: "Shard index must be a non-negative number" contains: "Shard index must be a non-negative number"
+CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--shard-index=0" }) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.shardIndex == 0 for: 0 == 0
+TestSpecParser.tests.cpp:<line number>: passed: spec.hasFilters() for: true with 1 message: 'tagString := "[tag with spaces]"'
+TestSpecParser.tests.cpp:<line number>: passed: spec.getInvalidSpecs().empty() for: true with 1 message: 'tagString := "[tag with spaces]"'
+TestSpecParser.tests.cpp:<line number>: passed: spec.matches( testCase ) for: true with 1 message: 'tagString := "[tag with spaces]"'
+TestSpecParser.tests.cpp:<line number>: passed: spec.hasFilters() for: true with 1 message: 'tagString := "[I said "good day" sir!]"'
+TestSpecParser.tests.cpp:<line number>: passed: spec.getInvalidSpecs().empty() for: true with 1 message: 'tagString := "[I said "good day" sir!]"'
+TestSpecParser.tests.cpp:<line number>: passed: spec.matches( testCase ) for: true with 1 message: 'tagString := "[I said "good day" sir!]"'
+CmdLine.tests.cpp:<line number>: passed: cli.parse( { "test", "-w", "NoAssertions" } ) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.warnings == WarnAbout::NoAssertions for: 1 == 1
+CmdLine.tests.cpp:<line number>: passed: !(cli.parse( { "test", "-w", "NoTests" } )) for: !{?}
+CmdLine.tests.cpp:<line number>: passed: cli.parse( { "test", "--warn", "NoAssertions", "--warn", "UnmatchedTestSpec" } ) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.warnings == ( WarnAbout::NoAssertions | WarnAbout::UnmatchedTestSpec ) for: 3 == 3
+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
+Condition.tests.cpp:<line number>: passed: cp != 0 for: 0x<hex digits> != 0
+Condition.tests.cpp:<line number>: passed: cpc != 0 for: 0x<hex digits> != 0
+Condition.tests.cpp:<line number>: passed: returnsNull() == 0 for: {null string} == 0
+Condition.tests.cpp:<line number>: passed: returnsConstNull() == 0 for: {null string} == 0
+Condition.tests.cpp:<line number>: passed: 0 != p for: 0 != 0x<hex digits>
+ToStringGeneral.tests.cpp:<line number>: passed: str1.size() == 3 + 5 for: 8 == 8
+ToStringGeneral.tests.cpp:<line number>: passed: str2.size() == 3 + 10 for: 13 == 13
+ToStringGeneral.tests.cpp:<line number>: passed: str1.size() == 2 + 5 for: 7 == 7
+ToStringGeneral.tests.cpp:<line number>: passed: str2.size() == 2 + 15 for: 17 == 17
+Matchers.tests.cpp:<line number>: passed: "foo", Predicate<const char*>( []( const char* const& ) { return true; } ) for: "foo" matches undescribed predicate
+CmdLine.tests.cpp:<line number>: passed: result for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.processName == "" for: "" == ""
+CmdLine.tests.cpp:<line number>: passed: result for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.processName == "test" for: "test" == "test"
+CmdLine.tests.cpp:<line number>: passed: config.shouldDebugBreak == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: config.abortAfter == -1 for: -1 == -1
+CmdLine.tests.cpp:<line number>: passed: config.noThrow == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: config.reporterSpecifications == std::vector<Catch::ConfigData::ReporterAndFile>{ {"console", {}} } for: { { console, <default-output> } }
+==
+{ { console, <default-output> } }
+CmdLine.tests.cpp:<line number>: passed: !(cfg.hasTestFilters()) for: !false
+CmdLine.tests.cpp:<line number>: passed: result for: {?}
+CmdLine.tests.cpp:<line number>: passed: cfg.hasTestFilters() for: true
+CmdLine.tests.cpp:<line number>: passed: cfg.testSpec().matches(*fakeTestCase("notIncluded")) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: cfg.testSpec().matches(*fakeTestCase("test1")) for: true
+CmdLine.tests.cpp:<line number>: passed: result for: {?}
+CmdLine.tests.cpp:<line number>: passed: cfg.hasTestFilters() for: true
+CmdLine.tests.cpp:<line number>: passed: cfg.testSpec().matches(*fakeTestCase("test1")) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: cfg.testSpec().matches(*fakeTestCase("alwaysIncluded")) for: true
+CmdLine.tests.cpp:<line number>: passed: result for: {?}
+CmdLine.tests.cpp:<line number>: passed: cfg.hasTestFilters() for: true
+CmdLine.tests.cpp:<line number>: passed: cfg.testSpec().matches(*fakeTestCase("test1")) == false for: false == false
+CmdLine.tests.cpp:<line number>: passed: cfg.testSpec().matches(*fakeTestCase("alwaysIncluded")) for: true
+CmdLine.tests.cpp:<line number>: passed: result for: {?} with 1 message: 'result.errorMessage() := ""'
+CmdLine.tests.cpp:<line number>: passed: config.reporterSpecifications == vec_ReporterAndFile{ {"console", {}} } for: { { console, <default-output> } }
+==
+{ { console, <default-output> } } with 1 message: 'result.errorMessage() := ""'
+CmdLine.tests.cpp:<line number>: passed: result for: {?} with 1 message: 'result.errorMessage() := ""'
+CmdLine.tests.cpp:<line number>: passed: config.reporterSpecifications == vec_ReporterAndFile{ {"xml", {}} } for: { { xml, <default-output> } }
+==
+{ { xml, <default-output> } } with 1 message: 'result.errorMessage() := ""'
+CmdLine.tests.cpp:<line number>: passed: result for: {?} with 1 message: 'result.errorMessage() := ""'
+CmdLine.tests.cpp:<line number>: passed: config.reporterSpecifications == vec_ReporterAndFile{ {"junit", {}} } for: { { junit, <default-output> } }
+==
+{ { junit, <default-output> } } with 1 message: 'result.errorMessage() := ""'
+CmdLine.tests.cpp:<line number>: passed: !result for: true
+CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring("Unrecognized reporter") for: "Unrecognized reporter, 'unsupported'. Check available with --list-reporters" contains: "Unrecognized reporter"
+CmdLine.tests.cpp:<line number>: passed: result for: {?} with 1 message: 'result.errorMessage() := ""'
+CmdLine.tests.cpp:<line number>: passed: config.reporterSpecifications == vec_ReporterAndFile{ {"console", "out.txt"s} } for: { { console, out.txt } }
+==
+{ { console, out.txt } } with 1 message: 'result.errorMessage() := ""'
+CmdLine.tests.cpp:<line number>: passed: result for: {?} with 1 message: 'result.errorMessage() := ""'
+CmdLine.tests.cpp:<line number>: passed: config.reporterSpecifications == vec_ReporterAndFile{ {"console", "C:\\Temp\\out.txt"s} } for: { { console, C:\Temp\out.txt } }
+==
+{ { console, C:\Temp\out.txt } } with 1 message: 'result.errorMessage() := ""'
+CmdLine.tests.cpp:<line number>: passed: !result for: true
+CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring("empty filename") for: "Reporter 'console' has empty filename specified as its output. Supply a filename or remove the colons to use the default output." contains: "empty filename"
+CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "-r", "xml::output.xml", "-r", "junit::output-junit.xml" }) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.reporterSpecifications == vec_ReporterAndFile{ {"xml", "output.xml"s}, {"junit", "output-junit.xml"s} } for: { { xml, output.xml }, { junit, output-junit.xml } }
+==
+{ { xml, output.xml }, { junit, output-junit.xml } }
+CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "-r", "xml::output.xml", "-r", "console" }) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.reporterSpecifications == vec_ReporterAndFile{ {"xml", "output.xml"s}, {"console", {}} } for: { { xml, output.xml }, { console, <default-output> } }
+==
+{ { xml, output.xml }, { console, <default-output> } }
+CmdLine.tests.cpp:<line number>: passed: !result for: true
+CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring("Only one reporter may have unspecified output file.") for: "Only one reporter may have unspecified output file." contains: "Only one reporter may have unspecified output file."
+CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "-b"}) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.shouldDebugBreak == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "--break"}) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.shouldDebugBreak for: true
+CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "-a"}) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.abortAfter == 1 for: 1 == 1
+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(), ContainsSubstring("convert") && ContainsSubstring("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(), ContainsSubstring("never") && ContainsSubstring("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: {?}
+CmdLine.tests.cpp:<line number>: passed: config.noThrow for: true
+CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "-o", "filename.ext"}) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.defaultOutputFilename == "filename.ext" for: "filename.ext" == "filename.ext"
+CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "--out", "filename.ext"}) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.defaultOutputFilename == "filename.ext" for: "filename.ext" == "filename.ext"
+CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "-abe"}) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.abortAfter == 1 for: 1 == 1
+CmdLine.tests.cpp:<line number>: passed: config.shouldDebugBreak for: true
+CmdLine.tests.cpp:<line number>: passed: config.noThrow == true for: true == true
+CmdLine.tests.cpp:<line number>: passed: cli.parse({"test"}) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.useColour == UseColour::Auto for: 0 == 0
+CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "--use-colour", "auto"}) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.useColour == UseColour::Auto for: 0 == 0
+CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "--use-colour", "yes"}) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.useColour == UseColour::Yes for: 1 == 1
+CmdLine.tests.cpp:<line number>: passed: cli.parse({"test", "--use-colour", "no"}) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.useColour == UseColour::No for: 2 == 2
+CmdLine.tests.cpp:<line number>: passed: !result for: true
+CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring( "colour mode must be one of" ) for: "colour mode must be one of: auto, yes or no. 'wrong' not recognised" contains: "colour mode must be one of"
+CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--benchmark-samples=200" }) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.benchmarkSamples == 200 for: 200 == 200
+CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--benchmark-resamples=20000" }) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.benchmarkResamples == 20000 for: 20000 (0x<hex digits>) == 20000 (0x<hex digits>)
+CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--benchmark-confidence-interval=0.99" }) for: {?}
+CmdLine.tests.cpp:<line number>: passed: config.benchmarkConfidenceInterval == Catch::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
+RandomNumberGeneration.tests.cpp:<line number>: passed: Catch::generateRandomSeed(method)
+RandomNumberGeneration.tests.cpp:<line number>: passed: Catch::generateRandomSeed(method)
+RandomNumberGeneration.tests.cpp:<line number>: passed: Catch::generateRandomSeed(method)
+RandomNumberGeneration.tests.cpp:<line number>: passed: Catch::generateRandomSeed(static_cast<Catch::GenerateFrom>(77))
+ToString.tests.cpp:<line number>: passed: Catch::Detail::stringify(UsesSentinel{}) == "{  }" for: "{  }" == "{  }"
+Decomposition.tests.cpp:<line number>: failed: truthy(false) for: Hey, its truthy!
+Matchers.tests.cpp:<line number>: failed: testStringForMatching(), Matches( "this STRING contains 'abc' as a substring" ) for: "this string contains 'abc' as a substring" matches "this STRING contains 'abc' as a substring" case sensitively
+Matchers.tests.cpp:<line number>: failed: testStringForMatching(), Matches( "contains 'abc' as a substring" ) for: "this string contains 'abc' as a substring" matches "contains 'abc' as a substring" case sensitively
+Matchers.tests.cpp:<line number>: failed: testStringForMatching(), Matches( "this string contains 'abc' as a" ) for: "this string contains 'abc' as a substring" matches "this string contains 'abc' as a" case sensitively
+Matchers.tests.cpp:<line number>: passed: actual, !UnorderedEquals( expected ) for: { 'a', 'b' } not UnorderedEquals: { 'c', 'b' }
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring("fakeTag"s) for: "All available tags:
+   1  [fakeTag]
+1 tag
+
+" contains: "fakeTag" with 1 message: 'Tested reporter: Automake'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring("fake reporter"s) for: "Available reporters:
+  fake reporter:  fake description
+
+" contains: "fake reporter" with 1 message: 'Tested reporter: Automake'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) for: "All available test cases:
+  fake test name
+      [fakeTestTag]
+1 test case
+
+" ( contains: "fake test name" and contains: "fakeTestTag" ) with 1 message: 'Tested reporter: Automake'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring("fakeTag"s) for: "All available tags:
+   1  [fakeTag]
+1 tag
+
+" contains: "fakeTag" with 1 message: 'Tested reporter: compact'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring("fake reporter"s) for: "Available reporters:
+  fake reporter:  fake description
+
+" contains: "fake reporter" with 1 message: 'Tested reporter: compact'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) for: "All available test cases:
+  fake test name
+      [fakeTestTag]
+1 test case
+
+" ( contains: "fake test name" and contains: "fakeTestTag" ) with 1 message: 'Tested reporter: compact'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring("fakeTag"s) for: "All available tags:
+   1  [fakeTag]
+1 tag
+
+" contains: "fakeTag" with 1 message: 'Tested reporter: console'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring("fake reporter"s) for: "Available reporters:
+  fake reporter:  fake description
+
+" contains: "fake reporter" with 1 message: 'Tested reporter: console'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) for: "All available test cases:
+  fake test name
+      [fakeTestTag]
+1 test case
+
+" ( contains: "fake test name" and contains: "fakeTestTag" ) with 1 message: 'Tested reporter: console'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring("fakeTag"s) for: "<?xml version="1.0" encoding="UTF-8"?>
+All available tags:
+   1  [fakeTag]
+1 tag
+
+" contains: "fakeTag" with 1 message: 'Tested reporter: JUnit'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring("fake reporter"s) for: "<?xml version="1.0" encoding="UTF-8"?>
+Available reporters:
+  fake reporter:  fake description
+
+" contains: "fake reporter" with 1 message: 'Tested reporter: JUnit'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) for: "<?xml version="1.0" encoding="UTF-8"?>
+All available test cases:
+  fake test name
+      [fakeTestTag]
+1 test case
+
+" ( contains: "fake test name" and contains: "fakeTestTag" ) with 1 message: 'Tested reporter: JUnit'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring("fakeTag"s) for: "<?xml version="1.0" encoding="UTF-8"?>
+All available tags:
+   1  [fakeTag]
+1 tag
+
+" contains: "fakeTag" with 1 message: 'Tested reporter: SonarQube'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring("fake reporter"s) for: "<?xml version="1.0" encoding="UTF-8"?>
+Available reporters:
+  fake reporter:  fake description
+
+" contains: "fake reporter" with 1 message: 'Tested reporter: SonarQube'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) for: "<?xml version="1.0" encoding="UTF-8"?>
+All available test cases:
+  fake test name
+      [fakeTestTag]
+1 test case
+
+" ( contains: "fake test name" and contains: "fakeTestTag" ) with 1 message: 'Tested reporter: SonarQube'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring("fakeTag"s) for: "All available tags:
+   1  [fakeTag]
+1 tag
+
+" contains: "fakeTag" with 1 message: 'Tested reporter: TAP'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring("fake reporter"s) for: "Available reporters:
+  fake reporter:  fake description
+
+" contains: "fake reporter" with 1 message: 'Tested reporter: TAP'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) for: "All available test cases:
+  fake test name
+      [fakeTestTag]
+1 test case
+
+" ( contains: "fake test name" and contains: "fakeTestTag" ) with 1 message: 'Tested reporter: TAP'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring("fakeTag"s) for: "All available tags:
+   1  [fakeTag]
+1 tag
+
+" contains: "fakeTag" with 1 message: 'Tested reporter: TeamCity'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring("fake reporter"s) for: "Available reporters:
+  fake reporter:  fake description
+
+" contains: "fake reporter" with 1 message: 'Tested reporter: TeamCity'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) for: "All available test cases:
+  fake test name
+      [fakeTestTag]
+1 test case
+
+" ( contains: "fake test name" and contains: "fakeTestTag" ) with 1 message: 'Tested reporter: TeamCity'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring("fakeTag"s) for: "<?xml version="1.0" encoding="UTF-8"?>
+<TagsFromMatchingTests>
+  <Tag>
+    <Count>1</Count>
+    <Aliases>
+      <Alias>fakeTag</Alias>
+    </Aliases>
+  </Tag>
+</TagsFromMatchingTests>" contains: "fakeTag" with 1 message: 'Tested reporter: XML'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring("fake reporter"s) for: "<?xml version="1.0" encoding="UTF-8"?>
+<AvailableReporters>
+  <Reporter>
+    <Name>fake reporter</Name>
+    <Description>fake description</Description>
+  </Reporter>
+</AvailableReporters>" contains: "fake reporter" with 1 message: 'Tested reporter: XML'
+Reporters.tests.cpp:<line number>: passed: !(factories.empty()) for: !false
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) for: "<?xml version="1.0" encoding="UTF-8"?>
+<MatchingTests>
+  <TestCase>
+    <Name>fake test name</Name>
+    <ClassName/>
+    <Tags>[fakeTestTag]</Tags>
+    <SourceInfo>
+      <File>fake-file.cpp</File>
+      <Line>123456789</Line>
+    </SourceInfo>
+  </TestCase>
+</MatchingTests>" ( contains: "fake test name" and contains: "fakeTestTag" ) with 1 message: 'Tested reporter: XML'
+Reporters.tests.cpp:<line number>: passed:
+Message.tests.cpp:<line number>: passed: with 1 message: 'this is a success'
+Message.tests.cpp:<line number>: passed:
+BDD.tests.cpp:<line number>: passed: before == 0 for: 0 == 0
+BDD.tests.cpp:<line number>: passed: after > before for: 1 > 0
+BDD.tests.cpp:<line number>: passed: itDoesThis() for: true
+BDD.tests.cpp:<line number>: passed: itDoesThat() for: true
+BDD.tests.cpp:<line number>: passed: with 1 message: 'boo!'
+BDD.tests.cpp:<line number>: passed: v.size() == 0 for: 0 == 0
+BDD.tests.cpp:<line number>: passed: v.size() == 10 for: 10 == 10
+BDD.tests.cpp:<line number>: passed: v.capacity() >= 10 for: 10 >= 10
+BDD.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+BDD.tests.cpp:<line number>: passed: v.capacity() >= 10 for: 10 >= 10
+BDD.tests.cpp:<line number>: passed: v.size() == 0 for: 0 == 0
+BDD.tests.cpp:<line number>: passed: v.capacity() >= 10 for: 10 >= 10
+BDD.tests.cpp:<line number>: passed: v.size() == 0 for: 0 == 0
+Approx.tests.cpp:<line number>: passed: d == Approx( 1.23 ) for: 1.23 == Approx( 1.23 )
+Approx.tests.cpp:<line number>: passed: d != Approx( 1.22 ) for: 1.23 != Approx( 1.22 )
+Approx.tests.cpp:<line number>: passed: d != Approx( 1.24 ) for: 1.23 != Approx( 1.24 )
+Approx.tests.cpp:<line number>: passed: d == 1.23_a for: 1.23 == Approx( 1.23 )
+Approx.tests.cpp:<line number>: passed: d != 1.22_a for: 1.23 != Approx( 1.22 )
+Approx.tests.cpp:<line number>: passed: Approx( d ) == 1.23 for: Approx( 1.23 ) == 1.23
+Approx.tests.cpp:<line number>: passed: Approx( d ) != 1.22 for: Approx( 1.23 ) != 1.22
+Approx.tests.cpp:<line number>: passed: Approx( d ) != 1.24 for: Approx( 1.23 ) != 1.24
+Matchers.tests.cpp:<line number>: failed: testStringForMatching(), StartsWith( "This String" ) for: "this string contains 'abc' as a substring" starts with: "This String"
+Matchers.tests.cpp:<line number>: failed: testStringForMatching(), StartsWith( "string", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" starts with: "string" (case insensitive)
+ToStringGeneral.tests.cpp:<line number>: passed: Catch::Detail::stringify(singular) == "{ 1 }" for: "{ 1 }" == "{ 1 }"
+ToStringGeneral.tests.cpp:<line number>: passed: Catch::Detail::stringify(arr) == "{ 3, 2, 1 }" for: "{ 3, 2, 1 }" == "{ 3, 2, 1 }"
+ToStringGeneral.tests.cpp:<line number>: passed: Catch::Detail::stringify(arr) == R"({ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } })" for: "{ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } }"
+==
+"{ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } }"
+Matchers.tests.cpp:<line number>: passed: testStringForMatching(), ContainsSubstring( "string" ) for: "this string contains 'abc' as a substring" contains: "string"
+Matchers.tests.cpp:<line number>: passed: testStringForMatching(), ContainsSubstring( "string", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" contains: "string" (case insensitive)
+Matchers.tests.cpp:<line number>: passed: testStringForMatching(), ContainsSubstring( "abc" ) for: "this string contains 'abc' as a substring" contains: "abc"
+Matchers.tests.cpp:<line number>: passed: testStringForMatching(), ContainsSubstring( "aBC", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" contains: "abc" (case insensitive)
+Matchers.tests.cpp:<line number>: passed: testStringForMatching(), StartsWith( "this" ) for: "this string contains 'abc' as a substring" starts with: "this"
+Matchers.tests.cpp:<line number>: passed: testStringForMatching(), StartsWith( "THIS", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" starts with: "this" (case insensitive)
+Matchers.tests.cpp:<line number>: passed: testStringForMatching(), EndsWith( "substring" ) for: "this string contains 'abc' as a substring" ends with: "substring"
+Matchers.tests.cpp:<line number>: passed: testStringForMatching(), EndsWith( " SuBsTrInG", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" ends with: " substring" (case insensitive)
+String.tests.cpp:<line number>: passed: empty.empty() for: true
+String.tests.cpp:<line number>: passed: empty.size() == 0 for: 0 == 0
+String.tests.cpp:<line number>: passed: std::strcmp( empty.data(), "" ) == 0 for: 0 == 0
+String.tests.cpp:<line number>: passed: s.empty() == false for: false == false
+String.tests.cpp:<line number>: passed: s.size() == 5 for: 5 == 5
+String.tests.cpp:<line number>: passed: std::strcmp( rawChars, "hello" ) == 0 for: 0 == 0
+String.tests.cpp:<line number>: passed: s.data() == rawChars for: "hello" == "hello"
+String.tests.cpp:<line number>: passed: original == "original"
+String.tests.cpp:<line number>: passed: original.data()
+String.tests.cpp:<line number>: passed: original.begin() == copy.begin() for: "original string" == "original string"
+String.tests.cpp:<line number>: passed: original.begin() == copy.begin() for: "original string" == "original string"
+String.tests.cpp:<line number>: passed: ss.empty() == false for: false == false
+String.tests.cpp:<line number>: passed: ss.size() == 5 for: 5 == 5
+String.tests.cpp:<line number>: passed: std::strncmp( ss.data(), "hello", 5 ) == 0 for: 0 == 0
+String.tests.cpp:<line number>: passed: ss == "hello" for: hello == "hello"
+String.tests.cpp:<line number>: passed: ss.size() == 6 for: 6 == 6
+String.tests.cpp:<line number>: passed: std::strcmp( ss.data(), "world!" ) == 0 for: 0 == 0
+String.tests.cpp:<line number>: passed: s.data() == s2.data() for: "hello world!" == "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.data(), "world!") == 0 for: 0 == 0
+String.tests.cpp:<line number>: passed: s.substr(1'000'000, 1).empty() for: true
+String.tests.cpp:<line number>: passed: reinterpret_cast<char*>(buffer1) != reinterpret_cast<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"
+String.tests.cpp:<line number>: passed: sr.size() == stdStr.size() for: 17 == 17
+String.tests.cpp:<line number>: passed: sr == "a standard string" for: a standard string == "a standard string"
+String.tests.cpp:<line number>: passed: sr.size() == stdStr.size() for: 17 == 17
+String.tests.cpp:<line number>: passed: sr == "a standard string" for: a standard string == "a standard string"
+String.tests.cpp:<line number>: passed: sr.size() == stdStr.size() for: 17 == 17
+String.tests.cpp:<line number>: passed: stdStr == "a stringref" for: "a stringref" == "a stringref"
+String.tests.cpp:<line number>: passed: stdStr.size() == sr.size() for: 11 == 11
+String.tests.cpp:<line number>: passed: stdStr == "a stringref" for: "a stringref" == "a stringref"
+String.tests.cpp:<line number>: passed: stdStr.size() == sr.size() for: 11 == 11
+String.tests.cpp:<line number>: passed: lhs == "some string += the stringref contents" for: "some string += the stringref contents"
+==
+"some string += the stringref contents"
+String.tests.cpp:<line number>: passed: together == "abrakadabra" for: "abrakadabra" == "abrakadabra"
+String.tests.cpp:<line number>: passed: with 1 message: 'empty.size() == 0'
+String.tests.cpp:<line number>: passed: with 1 message: 'empty.begin() == empty.end()'
+String.tests.cpp:<line number>: passed: with 1 message: 'stringref.size() == 3'
+String.tests.cpp:<line number>: passed: with 1 message: 'stringref.data() == abc'
+String.tests.cpp:<line number>: passed: with 1 message: 'stringref.begin() == abc'
+String.tests.cpp:<line number>: passed: with 1 message: 'stringref.begin() != stringref.end()'
+String.tests.cpp:<line number>: passed: with 1 message: 'stringref.substr(10, 0).empty()'
+String.tests.cpp:<line number>: passed: with 1 message: 'stringref.substr(2, 1).data() == abc + 2'
+String.tests.cpp:<line number>: passed: with 1 message: 'stringref[1] == 'b''
+String.tests.cpp:<line number>: passed: with 1 message: 'shortened.size() == 2'
+String.tests.cpp:<line number>: passed: with 1 message: 'shortened.data() == abc'
+String.tests.cpp:<line number>: passed: with 1 message: 'shortened.begin() != shortened.end()'
+String.tests.cpp:<line number>: passed: with 1 message: '!(sr1.empty())'
+String.tests.cpp:<line number>: passed: with 1 message: 'sr1.size() == 3'
+String.tests.cpp:<line number>: passed: with 1 message: 'sr2.empty()'
+String.tests.cpp:<line number>: passed: with 1 message: 'sr2.size() == 0'
+ToString.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( with_null_terminator ) == R"("abc")"s for: ""abc"" == ""abc""
+ToString.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s for: ""abc"" == ""abc""
+ToString.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( with_null_terminator ) == R"("abc")"s for: ""abc"" == ""abc""
+ToString.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s for: ""abc"" == ""abc""
+ToString.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( with_null_terminator ) == R"("abc")"s for: ""abc"" == ""abc""
+ToString.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s for: ""abc"" == ""abc""
+ToStringChrono.tests.cpp:<line number>: passed: minute == seconds for: 1 m == 60 s
+ToStringChrono.tests.cpp:<line number>: passed: hour != seconds for: 1 h != 60 s
+ToStringChrono.tests.cpp:<line number>: passed: micro != milli for: 1 us != 1 ms
+ToStringChrono.tests.cpp:<line number>: passed: nano != micro for: 1 ns != 1 us
+ToStringChrono.tests.cpp:<line number>: passed: half_minute != femto_second for: 1 [30/1]s != 1 fs
+ToStringChrono.tests.cpp:<line number>: passed: pico_second != atto_second for: 1 ps != 1 as
+ToStringChrono.tests.cpp:<line number>: passed: now != later for: {iso8601-timestamp}
+!=
+{iso8601-timestamp}
+Misc.tests.cpp:<line number>: failed: s1 == s2 for: "if ($b == 10) {
+		$a	= 20;
+}"
+==
+"if ($b == 10) {
+	$a = 20;
+}
+"
+Tag.tests.cpp:<line number>: passed: what, ContainsSubstring( "[@zzz]" ) for: "error: tag alias, '[@zzz]' already registered.
+	First seen at: file:2
+	Redefined at: file:10" contains: "[@zzz]"
+Tag.tests.cpp:<line number>: passed: what, ContainsSubstring( "file" ) for: "error: tag alias, '[@zzz]' already registered.
+	First seen at: file:2
+	Redefined at: file:10" contains: "file"
+Tag.tests.cpp:<line number>: passed: what, ContainsSubstring( "2" ) for: "error: tag alias, '[@zzz]' already registered.
+	First seen at: file:2
+	Redefined at: file:10" contains: "2"
+Tag.tests.cpp:<line number>: passed: what, ContainsSubstring( "10" ) for: "error: tag alias, '[@zzz]' already registered.
+	First seen at: file:2
+	Redefined at: file:10" contains: "10"
+Tag.tests.cpp:<line number>: passed: registry.add( "[no ampersat]", "", Catch::SourceLineInfo( "file", 3 ) )
+Tag.tests.cpp:<line number>: passed: registry.add( "[the @ is not at the start]", "", Catch::SourceLineInfo( "file", 3 ) )
+Tag.tests.cpp:<line number>: passed: registry.add( "@no square bracket at start]", "", Catch::SourceLineInfo( "file", 3 ) )
+Tag.tests.cpp:<line number>: passed: registry.add( "[@no square bracket at end", "", Catch::SourceLineInfo( "file", 3 ) )
+Tag.tests.cpp:<line number>: passed: testCase.tags.size() == 2 for: 2 == 2
+Tag.tests.cpp:<line number>: passed: testCase.tags, VectorContains( Tag( "tag with spaces" ) ) && VectorContains( Tag( "I said \"good day\" sir!"_catch_sr ) ) for: { {?}, {?} } ( Contains: {?} and Contains: {?} )
+Class.tests.cpp:<line number>: passed: Template_Fixture<TestType>::m_a == 1 for: 1 == 1
+Class.tests.cpp:<line number>: passed: Template_Fixture<TestType>::m_a == 1 for: 1 == 1
+Class.tests.cpp:<line number>: passed: Template_Fixture<TestType>::m_a == 1 for: 1.0 == 1
+Misc.tests.cpp:<line number>: passed: sizeof(TestType) > 0 for: 1 > 0
+Misc.tests.cpp:<line number>: passed: sizeof(TestType) > 0 for: 4 > 0
+Misc.tests.cpp:<line number>: passed: sizeof(TestType) > 0 for: 1 > 0
+Misc.tests.cpp:<line number>: passed: sizeof(TestType) > 0 for: 4 > 0
+Misc.tests.cpp:<line number>: passed: sizeof(TestType) > 0 for: 4 > 0
+Misc.tests.cpp:<line number>: passed: sizeof(TestType) > 0 for: 1 > 0
+Misc.tests.cpp:<line number>: passed: sizeof(TestType) > 0 for: 4 > 0
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 10 for: 10 == 10
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 10 for: 10 >= 10
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.capacity() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 10 for: 10 >= 10
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 10 for: 10 == 10
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 10 for: 10 >= 10
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.capacity() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 10 for: 10 >= 10
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 10 for: 10 == 10
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 10 for: 10 >= 10
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.capacity() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 10 for: 10 >= 10
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 10 for: 10 == 10
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 10 for: 10 >= 10
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.capacity() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 10 for: 10 >= 10
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 6 == 6
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 6 >= 6
+Misc.tests.cpp:<line number>: passed: v.size() == 2 * V for: 12 == 12
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 2 * V for: 12 >= 12
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 6 == 6
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 6 >= 6
+Misc.tests.cpp:<line number>: passed: v.size() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 6 >= 6
+Misc.tests.cpp:<line number>: passed: v.capacity() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 6 == 6
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 6 >= 6
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 6 == 6
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 2 * V for: 12 >= 12
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 6 == 6
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 6 >= 6
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 6 == 6
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 6 >= 6
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 4 == 4
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 4 >= 4
+Misc.tests.cpp:<line number>: passed: v.size() == 2 * V for: 8 == 8
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 2 * V for: 8 >= 8
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 4 == 4
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 4 >= 4
+Misc.tests.cpp:<line number>: passed: v.size() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 4 >= 4
+Misc.tests.cpp:<line number>: passed: v.capacity() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 4 == 4
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 4 >= 4
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 4 == 4
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 2 * V for: 8 >= 8
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 4 == 4
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 4 >= 4
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 4 == 4
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 4 >= 4
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 2 * V for: 10 == 10
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 2 * V for: 10 >= 10
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.capacity() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 2 * V for: 10 >= 10
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 15 == 15
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 15 >= 15
+Misc.tests.cpp:<line number>: passed: v.size() == 2 * V for: 30 == 30
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 2 * V for: 30 >= 30
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 15 == 15
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 15 >= 15
+Misc.tests.cpp:<line number>: passed: v.size() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 15 >= 15
+Misc.tests.cpp:<line number>: passed: v.capacity() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 15 == 15
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 15 >= 15
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 15 == 15
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 2 * V for: 30 >= 30
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 15 == 15
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 15 >= 15
+Misc.tests.cpp:<line number>: passed: v.size() == V for: 15 == 15
+Misc.tests.cpp:<line number>: passed: v.capacity() >= V for: 15 >= 15
+Tag.tests.cpp:<line number>: passed: testCase.tags.size() == 1 for: 1 == 1
+Tag.tests.cpp:<line number>: passed: testCase.tags[0] == Tag( "tag1" ) for: {?} == {?}
+VariadicMacros.tests.cpp:<line number>: passed: with 1 message: 'no assertions'
+Tricky.tests.cpp:<line number>: passed: 0x<hex digits> == bit30and31 for: 3221225472 (0x<hex digits>) == 3221225472
+CmdLine.tests.cpp:<line number>: passed:
+Misc.tests.cpp:<line number>: passed: true
+Misc.tests.cpp:<line number>: passed:
+Misc.tests.cpp:<line number>: failed - but was ok: false
+Misc.tests.cpp:<line number>: passed: true
+Misc.tests.cpp:<line number>: failed - but was ok: false
+Misc.tests.cpp:<line number>: passed:
+Misc.tests.cpp:<line number>: passed: true
+Misc.tests.cpp:<line number>: failed: explicitly
+Misc.tests.cpp:<line number>: failed - but was ok: false
+Misc.tests.cpp:<line number>: failed: explicitly
+Message.tests.cpp:<line number>: failed - but was ok: 1 == 2
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring("[fakeTag]"s) for: "All available tags:
+   1  [fakeTag]
+1 tag
+
+" contains: "[fakeTag]"
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring("fake reporter"s) for: "Available reporters:
+  fake reporter:  fake description
+
+" contains: "fake reporter"
+Reporters.tests.cpp:<line number>: passed: listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) for: "All available test cases:
+  fake test name
+      [fakeTestTag]
+1 test case
+
+" ( contains: "fake test name" and contains: "fakeTestTag" )
+Misc.tests.cpp:<line number>: passed: with 1 message: 'oops!'
+Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'For some reason someone is throwing a string literal!'
+PartTracker.tests.cpp:<line number>: passed: testCase.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: s1.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: s1.isSuccessfullyCompleted() for: true
+PartTracker.tests.cpp:<line number>: passed: testCase.isComplete() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: ctx.completedCycle() for: true
+PartTracker.tests.cpp:<line number>: passed: testCase.isSuccessfullyCompleted() for: true
+PartTracker.tests.cpp:<line number>: passed: testCase.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: s1.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: s1.isComplete() for: true
+PartTracker.tests.cpp:<line number>: passed: s1.isSuccessfullyCompleted() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: testCase.isComplete() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: ctx.completedCycle() for: true
+PartTracker.tests.cpp:<line number>: passed: testCase.isSuccessfullyCompleted() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: testCase2.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: s1b.isOpen() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: ctx.completedCycle() for: true
+PartTracker.tests.cpp:<line number>: passed: testCase.isComplete() for: true
+PartTracker.tests.cpp:<line number>: passed: testCase.isSuccessfullyCompleted() for: true
+PartTracker.tests.cpp:<line number>: passed: testCase.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: s1.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: s1.isComplete() for: true
+PartTracker.tests.cpp:<line number>: passed: s1.isSuccessfullyCompleted() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: testCase.isComplete() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: ctx.completedCycle() for: true
+PartTracker.tests.cpp:<line number>: passed: testCase.isSuccessfullyCompleted() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: testCase2.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: s1b.isOpen() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: s2.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: ctx.completedCycle() for: true
+PartTracker.tests.cpp:<line number>: passed: testCase.isComplete() for: true
+PartTracker.tests.cpp:<line number>: passed: testCase.isSuccessfullyCompleted() for: true
+PartTracker.tests.cpp:<line number>: passed: testCase.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: s1.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: s2.isOpen() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: testCase.isComplete() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: testCase2.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: s1b.isOpen() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: s2b.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: ctx.completedCycle() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: ctx.completedCycle() for: true
+PartTracker.tests.cpp:<line number>: passed: s2b.isSuccessfullyCompleted() for: true
+PartTracker.tests.cpp:<line number>: passed: testCase2.isComplete() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: testCase2.isSuccessfullyCompleted() for: true
+PartTracker.tests.cpp:<line number>: passed: testCase.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: s1.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: s2.isOpen() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: testCase.isComplete() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: testCase2.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: s1b.isOpen() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: s2b.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: ctx.completedCycle() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: ctx.completedCycle() for: true
+PartTracker.tests.cpp:<line number>: passed: s2b.isComplete() for: true
+PartTracker.tests.cpp:<line number>: passed: s2b.isSuccessfullyCompleted() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: testCase2.isSuccessfullyCompleted() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: testCase3.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: s1c.isOpen() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: s2c.isOpen() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: testCase3.isSuccessfullyCompleted() for: true
+PartTracker.tests.cpp:<line number>: passed: testCase.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: s1.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: s2.isOpen() for: true
+PartTracker.tests.cpp:<line number>: passed: s2.isComplete() for: true
+PartTracker.tests.cpp:<line number>: passed: s1.isComplete() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: s1.isComplete() for: true
+PartTracker.tests.cpp:<line number>: passed: testCase.isComplete() == false for: false == false
+PartTracker.tests.cpp:<line number>: passed: testCase.isComplete() for: true
+StringManip.tests.cpp:<line number>: passed: trim(std::string(no_whitespace)) == no_whitespace for: "There is no extra whitespace here"
+==
+"There is no extra whitespace here"
+StringManip.tests.cpp:<line number>: passed: trim(std::string(leading_whitespace)) == no_whitespace for: "There is no extra whitespace here"
+==
+"There is no extra whitespace here"
+StringManip.tests.cpp:<line number>: passed: trim(std::string(trailing_whitespace)) == no_whitespace for: "There is no extra whitespace here"
+==
+"There is no extra whitespace here"
+StringManip.tests.cpp:<line number>: passed: trim(std::string(whitespace_at_both_ends)) == no_whitespace for: "There is no extra whitespace here"
+==
+"There is no extra whitespace here"
+StringManip.tests.cpp:<line number>: passed: trim(StringRef(no_whitespace)) == StringRef(no_whitespace) for: There is no extra whitespace here
+==
+There is no extra whitespace here
+StringManip.tests.cpp:<line number>: passed: trim(StringRef(leading_whitespace)) == StringRef(no_whitespace) for: There is no extra whitespace here
+==
+There is no extra whitespace here
+StringManip.tests.cpp:<line number>: passed: trim(StringRef(trailing_whitespace)) == StringRef(no_whitespace) for: There is no extra whitespace here
+==
+There is no extra whitespace here
+StringManip.tests.cpp:<line number>: passed: trim(StringRef(whitespace_at_both_ends)) == StringRef(no_whitespace) for: There is no extra whitespace here
+==
+There is no extra whitespace here
+Exception.tests.cpp:<line number>: failed: unexpected exception with message: '3.14'
+UniquePtr.tests.cpp:<line number>: passed: bptr->i == 3 for: 3 == 3
+UniquePtr.tests.cpp:<line number>: passed: bptr->i == 3 for: 3 == 3
+MatchersRanges.tests.cpp:<line number>: passed: data, AllMatch(SizeIs(5)) for: { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } all match has size == 5
+MatchersRanges.tests.cpp:<line number>: passed: data, !AllMatch(Contains(0) && Contains(1)) for: { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } not all match ( contains element 0 and contains element 1 )
+MatchersRanges.tests.cpp:<line number>: passed: needs_adl, AllMatch( Predicate<int>( []( int elem ) { return elem < 6; } ) ) for: { 1, 2, 3, 4, 5 } all match matches undescribed predicate
+MatchersRanges.tests.cpp:<line number>: passed: mocked, allMatch for: { 1, 2, 3, 4, 5 } all match matches undescribed predicate
+MatchersRanges.tests.cpp:<line number>: passed: mocked.derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.derefed[1] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.derefed[2] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.derefed[3] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.derefed[4] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked, !allMatch for: { 1, 2, 3, 4, 5 } not all match matches undescribed predicate
+MatchersRanges.tests.cpp:<line number>: passed: mocked.derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.derefed[1] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.derefed[2] for: true
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.derefed[3]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.derefed[4]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: data, AnyMatch(SizeIs(5)) for: { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } any match has size == 5
+MatchersRanges.tests.cpp:<line number>: passed: data, !AnyMatch(Contains(0) && Contains(10)) for: { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } not any match ( contains element 0 and contains element 10 )
+MatchersRanges.tests.cpp:<line number>: passed: needs_adl, AnyMatch( Predicate<int>( []( int elem ) { return elem < 3; } ) ) for: { 1, 2, 3, 4, 5 } any match matches undescribed predicate
+MatchersRanges.tests.cpp:<line number>: passed: mocked, !anyMatch for: { 1, 2, 3, 4, 5 } not any match matches undescribed predicate
+MatchersRanges.tests.cpp:<line number>: passed: mocked.derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.derefed[1] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.derefed[2] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.derefed[3] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.derefed[4] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked, anyMatch for: { 1, 2, 3, 4, 5 } any match matches undescribed predicate
+MatchersRanges.tests.cpp:<line number>: passed: mocked.derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.derefed[1]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.derefed[2]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.derefed[3]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.derefed[4]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: data, NoneMatch(SizeIs(6)) for: { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } none match has size == 6
+MatchersRanges.tests.cpp:<line number>: passed: data, !NoneMatch(Contains(0) && Contains(1)) for: { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } not none match ( contains element 0 and contains element 1 )
+MatchersRanges.tests.cpp:<line number>: passed: needs_adl, NoneMatch( Predicate<int>( []( int elem ) { return elem > 6; } ) ) for: { 1, 2, 3, 4, 5 } none match matches undescribed predicate
+MatchersRanges.tests.cpp:<line number>: passed: mocked, noneMatch for: { 1, 2, 3, 4, 5 } none match matches undescribed predicate
+MatchersRanges.tests.cpp:<line number>: passed: mocked.derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.derefed[1] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.derefed[2] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.derefed[3] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.derefed[4] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked, !noneMatch for: { 1, 2, 3, 4, 5 } not none match matches undescribed predicate
+MatchersRanges.tests.cpp:<line number>: passed: mocked.derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.derefed[1]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.derefed[2]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.derefed[3]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.derefed[4]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: empty_vec, SizeIs(0) for: {  } has size == 0
+MatchersRanges.tests.cpp:<line number>: passed: empty_vec, !SizeIs(2) for: {  } not has size == 2
+MatchersRanges.tests.cpp:<line number>: passed: empty_vec, SizeIs(Lt(2)) for: {  } size matches is less than 2
+MatchersRanges.tests.cpp:<line number>: passed: arr, SizeIs(2) for: { 0, 0 } has size == 2
+MatchersRanges.tests.cpp:<line number>: passed: arr, SizeIs( Lt(3)) for: { 0, 0 } size matches is less than 3
+MatchersRanges.tests.cpp:<line number>: passed: arr, !SizeIs(!Lt(3)) for: { 0, 0 } not size matches not is less than 3
+MatchersRanges.tests.cpp:<line number>: passed: map, SizeIs(3) for: { {?}, {?}, {?} } has size == 3
+MatchersRanges.tests.cpp:<line number>: passed: unrelated::ADL_size{}, SizeIs(12) for: {?} has size == 12
+MatchersRanges.tests.cpp:<line number>: passed: has_size{}, SizeIs(13) for: {?} has size == 13
+Approx.tests.cpp:<line number>: passed: d == approx( 1.23 ) for: 1.23 == Approx( 1.23 )
+Approx.tests.cpp:<line number>: passed: d == approx( 1.22 ) for: 1.23 == Approx( 1.22 )
+Approx.tests.cpp:<line number>: passed: d == approx( 1.24 ) for: 1.23 == Approx( 1.24 )
+Approx.tests.cpp:<line number>: passed: d != approx( 1.25 ) for: 1.23 != Approx( 1.25 )
+Approx.tests.cpp:<line number>: passed: approx( d ) == 1.23 for: Approx( 1.23 ) == 1.23
+Approx.tests.cpp:<line number>: passed: approx( d ) == 1.22 for: Approx( 1.23 ) == 1.22
+Approx.tests.cpp:<line number>: passed: approx( d ) == 1.24 for: Approx( 1.23 ) == 1.24
+Approx.tests.cpp:<line number>: passed: approx( d ) != 1.25 for: Approx( 1.23 ) != 1.25
+VariadicMacros.tests.cpp:<line number>: passed: with 1 message: 'no assertions'
+Matchers.tests.cpp:<line number>: passed: empty, Approx( empty ) for: {  } is approx: {  }
+Matchers.tests.cpp:<line number>: passed: v1, Approx( v1 ) for: { 1.0, 2.0, 3.0 } is approx: { 1.0, 2.0, 3.0 }
+Matchers.tests.cpp:<line number>: passed: v1, Approx<double>( { 1., 2., 3. } ) for: { 1.0, 2.0, 3.0 } is approx: { 1.0, 2.0, 3.0 }
+Matchers.tests.cpp:<line number>: passed: v1, !Approx( temp ) for: { 1.0, 2.0, 3.0 } not is approx: { 1.0, 2.0, 3.0, 4.0 }
+Matchers.tests.cpp:<line number>: passed: v1, !Approx( v2 ) for: { 1.0, 2.0, 3.0 } not is approx: { 1.5, 2.5, 3.5 }
+Matchers.tests.cpp:<line number>: passed: v1, Approx( v2 ).margin( 0.5 ) for: { 1.0, 2.0, 3.0 } is approx: { 1.5, 2.5, 3.5 }
+Matchers.tests.cpp:<line number>: passed: v1, Approx( v2 ).epsilon( 0.5 ) for: { 1.0, 2.0, 3.0 } is approx: { 1.5, 2.5, 3.5 }
+Matchers.tests.cpp:<line number>: passed: v1, Approx( v2 ).epsilon( 0.1 ).scale( 500 ) for: { 1.0, 2.0, 3.0 } is approx: { 1.5, 2.5, 3.5 }
+Matchers.tests.cpp:<line number>: failed: empty, Approx( t1 ) for: {  } is approx: { 1.0, 2.0 }
+Matchers.tests.cpp:<line number>: failed: v1, Approx( v2 ) for: { 2.0, 4.0, 6.0 } is approx: { 1.0, 3.0, 5.0 }
+Matchers.tests.cpp:<line number>: passed: v, VectorContains( 1 ) for: { 1, 2, 3 } Contains: 1
+Matchers.tests.cpp:<line number>: passed: v, VectorContains( 2 ) for: { 1, 2, 3 } Contains: 2
+Matchers.tests.cpp:<line number>: passed: v5, ( VectorContains<int, CustomAllocator<int>>( 2 ) ) for: { 1, 2, 3 } Contains: 2
+Matchers.tests.cpp:<line number>: passed: v, Contains( v2 ) for: { 1, 2, 3 } Contains: { 1, 2 }
+Matchers.tests.cpp:<line number>: passed: v, Contains<int>( { 1, 2 } ) for: { 1, 2, 3 } Contains: { 1, 2 }
+Matchers.tests.cpp:<line number>: passed: v5, ( Contains<int, std::allocator<int>, CustomAllocator<int>>( v2 ) ) for: { 1, 2, 3 } Contains: { 1, 2 }
+Matchers.tests.cpp:<line number>: passed: v, Contains( v2 ) for: { 1, 2, 3 } Contains: { 1, 2, 3 }
+Matchers.tests.cpp:<line number>: passed: v, Contains( empty ) for: { 1, 2, 3 } Contains: {  }
+Matchers.tests.cpp:<line number>: passed: empty, Contains( empty ) for: {  } Contains: {  }
+Matchers.tests.cpp:<line number>: passed: v5, ( Contains<int, std::allocator<int>, CustomAllocator<int>>( v2 ) ) for: { 1, 2, 3 } Contains: { 1, 2, 3 }
+Matchers.tests.cpp:<line number>: passed: v5, Contains( v6 ) for: { 1, 2, 3 } Contains: { 1, 2 }
+Matchers.tests.cpp:<line number>: passed: v, VectorContains( 1 ) && VectorContains( 2 ) for: { 1, 2, 3 } ( Contains: 1 and Contains: 2 )
+Matchers.tests.cpp:<line number>: passed: v, Equals( v ) for: { 1, 2, 3 } Equals: { 1, 2, 3 }
+Matchers.tests.cpp:<line number>: passed: empty, Equals( empty ) for: {  } Equals: {  }
+Matchers.tests.cpp:<line number>: passed: v, Equals<int>( { 1, 2, 3 } ) for: { 1, 2, 3 } Equals: { 1, 2, 3 }
+Matchers.tests.cpp:<line number>: passed: v, Equals( v2 ) for: { 1, 2, 3 } Equals: { 1, 2, 3 }
+Matchers.tests.cpp:<line number>: passed: v5, ( Equals<int, std::allocator<int>, CustomAllocator<int>>( v2 ) ) for: { 1, 2, 3 } Equals: { 1, 2, 3 }
+Matchers.tests.cpp:<line number>: passed: v5, Equals( v6 ) for: { 1, 2, 3 } Equals: { 1, 2, 3 }
+Matchers.tests.cpp:<line number>: passed: v, UnorderedEquals( v ) for: { 1, 2, 3 } UnorderedEquals: { 1, 2, 3 }
+Matchers.tests.cpp:<line number>: passed: v, UnorderedEquals<int>( { 3, 2, 1 } ) for: { 1, 2, 3 } UnorderedEquals: { 3, 2, 1 }
+Matchers.tests.cpp:<line number>: passed: empty, UnorderedEquals( empty ) for: {  } UnorderedEquals: {  }
+Matchers.tests.cpp:<line number>: passed: permuted, UnorderedEquals( v ) for: { 1, 3, 2 } UnorderedEquals: { 1, 2, 3 }
+Matchers.tests.cpp:<line number>: passed: permuted, UnorderedEquals( v ) for: { 2, 3, 1 } UnorderedEquals: { 1, 2, 3 }
+Matchers.tests.cpp:<line number>: passed: v5, ( UnorderedEquals<int, std::allocator<int>, CustomAllocator<int>>( permuted ) ) for: { 1, 2, 3 } UnorderedEquals: { 2, 3, 1 }
+Matchers.tests.cpp:<line number>: passed: v5_permuted, UnorderedEquals( v5 ) for: { 1, 3, 2 } UnorderedEquals: { 1, 2, 3 }
+Matchers.tests.cpp:<line number>: failed: v, VectorContains( -1 ) for: { 1, 2, 3 } Contains: -1
+Matchers.tests.cpp:<line number>: failed: empty, VectorContains( 1 ) for: {  } Contains: 1
+Matchers.tests.cpp:<line number>: failed: empty, Contains( v ) for: {  } Contains: { 1, 2, 3 }
+Matchers.tests.cpp:<line number>: failed: v, Contains( v2 ) for: { 1, 2, 3 } Contains: { 1, 2, 4 }
+Matchers.tests.cpp:<line number>: failed: v, Equals( v2 ) for: { 1, 2, 3 } Equals: { 1, 2 }
+Matchers.tests.cpp:<line number>: failed: v2, Equals( v ) for: { 1, 2 } Equals: { 1, 2, 3 }
+Matchers.tests.cpp:<line number>: failed: empty, Equals( v ) for: {  } Equals: { 1, 2, 3 }
+Matchers.tests.cpp:<line number>: failed: v, Equals( empty ) for: { 1, 2, 3 } Equals: {  }
+Matchers.tests.cpp:<line number>: failed: v, UnorderedEquals( empty ) for: { 1, 2, 3 } UnorderedEquals: {  }
+Matchers.tests.cpp:<line number>: failed: empty, UnorderedEquals( v ) for: {  } UnorderedEquals: { 1, 2, 3 }
+Matchers.tests.cpp:<line number>: failed: permuted, UnorderedEquals( v ) for: { 1, 3 } UnorderedEquals: { 1, 2, 3 }
+Matchers.tests.cpp:<line number>: failed: permuted, UnorderedEquals( v ) for: { 3, 1 } UnorderedEquals: { 1, 2, 3 }
+Exception.tests.cpp:<line number>: passed: thisThrows(), std::domain_error
+Exception.tests.cpp:<line number>: passed: thisDoesntThrow()
+Exception.tests.cpp:<line number>: passed: thisThrows()
+Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'unexpected exception'
+Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'expected exception'; expression was: thisThrows() == 0
+Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'expected exception'; expression was: thisThrows() == 0
+Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'expected exception'; expression was: thisThrows() == 0
+Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'unexpected exception'
+Tricky.tests.cpp:<line number>: passed:
+Tricky.tests.cpp:<line number>: passed:
+Tricky.tests.cpp:<line number>: passed:
+Tricky.tests.cpp:<line number>: passed:
+Xml.tests.cpp:<line number>: passed: encode( "normal string" ) == "normal string" for: "normal string" == "normal string"
+Xml.tests.cpp:<line number>: passed: encode( "" ) == "" for: "" == ""
+Xml.tests.cpp:<line number>: passed: encode( "smith & jones" ) == "smith &amp; jones" for: "smith &amp; jones" == "smith &amp; jones"
+Xml.tests.cpp:<line number>: passed: encode( "smith < jones" ) == "smith &lt; jones" for: "smith &lt; jones" == "smith &lt; jones"
+Xml.tests.cpp:<line number>: passed: encode( "smith > jones" ) == "smith > jones" for: "smith > jones" == "smith > jones"
+Xml.tests.cpp:<line number>: passed: encode( "smith ]]> jones" ) == "smith ]]&gt; jones" for: "smith ]]&gt; jones"
+==
+"smith ]]&gt; jones"
+Xml.tests.cpp:<line number>: passed: encode( stringWithQuotes ) == stringWithQuotes for: "don't "quote" me on that"
+==
+"don't "quote" me on that"
+Xml.tests.cpp:<line number>: passed: encode( stringWithQuotes, Catch::XmlEncode::ForAttributes ) == "don't &quot;quote&quot; me on that" for: "don't &quot;quote&quot; me on that"
+==
+"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: stream.str(), ContainsSubstring(R"(attr1="true")") && ContainsSubstring(R"(attr2="false")") for: "<?xml version="1.0" encoding="UTF-8"?>
+<Element1 attr1="true" attr2="false"/>
+" ( contains: "attr1="true"" and contains: "attr2="false"" )
+InternalBenchmark.tests.cpp:<line number>: passed: analysis.mean.point.count() == 23 for: 23.0 == 23
+InternalBenchmark.tests.cpp:<line number>: passed: analysis.mean.lower_bound.count() == 23 for: 23.0 == 23
+InternalBenchmark.tests.cpp:<line number>: passed: analysis.mean.upper_bound.count() == 23 for: 23.0 == 23
+InternalBenchmark.tests.cpp:<line number>: passed: analysis.standard_deviation.point.count() == 0 for: 0.0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: analysis.standard_deviation.lower_bound.count() == 0 for: 0.0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: analysis.standard_deviation.upper_bound.count() == 0 for: 0.0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: analysis.outliers.total() == 0 for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: analysis.outliers.low_mild == 0 for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: analysis.outliers.low_severe == 0 for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: analysis.outliers.high_mild == 0 for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: analysis.outliers.high_severe == 0 for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: analysis.outliers.samples_seen == 0 for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: analysis.outlier_variance == 0 for: 0.0 == 0
+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 }"
+InternalBenchmark.tests.cpp:<line number>: passed: model.started == 1 for: 1 == 1
+InternalBenchmark.tests.cpp:<line number>: passed: model.finished == 0 for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: model.started == 1 for: 1 == 1
+InternalBenchmark.tests.cpp:<line number>: passed: model.finished == 1 for: 1 == 1
+InternalBenchmark.tests.cpp:<line number>: passed: called == 1 for: 1 == 1
+InternalBenchmark.tests.cpp:<line number>: passed: model.started == 0 for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: model.finished == 0 for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: model.started == 0 for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: model.finished == 0 for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: called == 1 for: 1 == 1
+Tricky.tests.cpp:<line number>: passed: obj.prop != 0 for: 0x<hex digits> != 0
+Misc.tests.cpp:<line number>: passed: flag for: true
+Misc.tests.cpp:<line number>: passed: testCheckedElse( true ) for: true
+Misc.tests.cpp:<line number>: failed - but was ok: flag for: false
+Misc.tests.cpp:<line number>: failed: testCheckedElse( false ) for: false
+Misc.tests.cpp:<line number>: passed: flag for: true
+Misc.tests.cpp:<line number>: passed: testCheckedIf( true ) for: true
+Misc.tests.cpp:<line number>: failed - but was ok: flag for: false
+Misc.tests.cpp:<line number>: failed: testCheckedIf( false ) for: false
+InternalBenchmark.tests.cpp:<line number>: passed: o.samples_seen == static_cast<int>(x.size()) for: 6 == 6
+InternalBenchmark.tests.cpp:<line number>: passed: o.low_severe == los for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: o.low_mild == lom for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: o.high_mild == him for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: o.high_severe == his for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: o.total() == los + lom + him + his for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: o.samples_seen == static_cast<int>(x.size()) for: 6 == 6
+InternalBenchmark.tests.cpp:<line number>: passed: o.low_severe == los for: 1 == 1
+InternalBenchmark.tests.cpp:<line number>: passed: o.low_mild == lom for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: o.high_mild == him for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: o.high_severe == his for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: o.total() == los + lom + him + his for: 1 == 1
+InternalBenchmark.tests.cpp:<line number>: passed: o.samples_seen == static_cast<int>(x.size()) for: 6 == 6
+InternalBenchmark.tests.cpp:<line number>: passed: o.low_severe == los for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: o.low_mild == lom for: 1 == 1
+InternalBenchmark.tests.cpp:<line number>: passed: o.high_mild == him for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: o.high_severe == his for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: o.total() == los + lom + him + his for: 1 == 1
+InternalBenchmark.tests.cpp:<line number>: passed: o.samples_seen == static_cast<int>(x.size()) for: 6 == 6
+InternalBenchmark.tests.cpp:<line number>: passed: o.low_severe == los for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: o.low_mild == lom for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: o.high_mild == him for: 1 == 1
+InternalBenchmark.tests.cpp:<line number>: passed: o.high_severe == his for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: o.total() == los + lom + him + his for: 1 == 1
+InternalBenchmark.tests.cpp:<line number>: passed: o.samples_seen == static_cast<int>(x.size()) for: 6 == 6
+InternalBenchmark.tests.cpp:<line number>: passed: o.low_severe == los for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: o.low_mild == lom for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: o.high_mild == him for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: o.high_severe == his for: 1 == 1
+InternalBenchmark.tests.cpp:<line number>: passed: o.total() == los + lom + him + his for: 1 == 1
+InternalBenchmark.tests.cpp:<line number>: passed: o.samples_seen == static_cast<int>(x.size()) for: 6 == 6
+InternalBenchmark.tests.cpp:<line number>: passed: o.low_severe == los for: 1 == 1
+InternalBenchmark.tests.cpp:<line number>: passed: o.low_mild == lom for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: o.high_mild == him for: 1 == 1
+InternalBenchmark.tests.cpp:<line number>: passed: o.high_severe == his for: 0 == 0
+InternalBenchmark.tests.cpp:<line number>: passed: o.total() == los + lom + him + his for: 2 == 2
+Condition.tests.cpp:<line number>: passed: unsigned_char_var == 1 for: 1 == 1
+Condition.tests.cpp:<line number>: passed: unsigned_short_var == 1 for: 1 == 1
+Condition.tests.cpp:<line number>: passed: unsigned_int_var == 1 for: 1 == 1
+Condition.tests.cpp:<line number>: passed: unsigned_long_var == 1 for: 1 == 1
+Condition.tests.cpp:<line number>: passed: long_var == unsigned_char_var for: 1 == 1
+Condition.tests.cpp:<line number>: passed: long_var == unsigned_short_var for: 1 == 1
+Condition.tests.cpp:<line number>: passed: long_var == unsigned_int_var for: 1 == 1
+Condition.tests.cpp:<line number>: passed: long_var == unsigned_long_var for: 1 == 1
+FloatingPoint.tests.cpp:<line number>: passed: convertToBits( 0.f ) == 0 for: 0 == 0
+FloatingPoint.tests.cpp:<line number>: passed: convertToBits( -0.f ) == ( 1ULL << 31 ) for: 2147483648 (0x<hex digits>)
+==
+2147483648 (0x<hex digits>)
+FloatingPoint.tests.cpp:<line number>: passed: convertToBits( 0. ) == 0 for: 0 == 0
+FloatingPoint.tests.cpp:<line number>: passed: convertToBits( -0. ) == ( 1ULL << 63 ) for: 9223372036854775808 (0x<hex digits>)
+==
+9223372036854775808 (0x<hex digits>)
+FloatingPoint.tests.cpp:<line number>: passed: convertToBits( std::numeric_limits<float>::denorm_min() ) == 1 for: 1 == 1
+FloatingPoint.tests.cpp:<line number>: passed: convertToBits( std::numeric_limits<double>::denorm_min() ) == 1 for: 1 == 1
+Tag.tests.cpp:<line number>: passed: Catch::TestCaseInfo("", { "test with an empty tag", "[]" }, dummySourceLineInfo)
+InternalBenchmark.tests.cpp:<line number>: passed: erfc_inv(1.103560) == Approx(-0.09203687623843015) for: -0.0920368762 == Approx( -0.0920368762 )
+InternalBenchmark.tests.cpp:<line number>: passed: erfc_inv(1.067400) == Approx(-0.05980291115763361) for: -0.0598029112 == Approx( -0.0598029112 )
+InternalBenchmark.tests.cpp:<line number>: passed: erfc_inv(0.050000) == Approx(1.38590382434967796) for: 1.3859038243 == Approx( 1.3859038243 )
+InternalBenchmark.tests.cpp:<line number>: passed: res.mean.count() == rate for: 2000.0 == 2000 (0x<hex digits>)
+InternalBenchmark.tests.cpp:<line number>: passed: res.outliers.total() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed:
+Misc.tests.cpp:<line number>: passed:
+Misc.tests.cpp:<line number>: passed:
+Clara.tests.cpp:<line number>: passed: with 1 message: 'Catch::Clara::Detail::is_unary_function<decltype(unary1)>::value'
+Clara.tests.cpp:<line number>: passed: with 1 message: 'Catch::Clara::Detail::is_unary_function<decltype(unary2)>::value'
+Clara.tests.cpp:<line number>: passed: with 1 message: 'Catch::Clara::Detail::is_unary_function<decltype(unary3)>::value'
+Clara.tests.cpp:<line number>: passed: with 1 message: 'Catch::Clara::Detail::is_unary_function<decltype(unary4)>::value'
+Clara.tests.cpp:<line number>: passed: with 1 message: 'Catch::Clara::Detail::is_unary_function<decltype(unary5)>::value'
+Clara.tests.cpp:<line number>: passed: with 1 message: 'Catch::Clara::Detail::is_unary_function<decltype(unary6)>::value'
+Clara.tests.cpp:<line number>: passed: with 1 message: '!(Catch::Clara::Detail::is_unary_function<decltype(binary1)>::value)'
+Clara.tests.cpp:<line number>: passed: with 1 message: '!(Catch::Clara::Detail::is_unary_function<decltype(binary2)>::value)'
+Clara.tests.cpp:<line number>: passed: with 1 message: '!(Catch::Clara::Detail::is_unary_function<decltype(nullary1)>::value)'
+Clara.tests.cpp:<line number>: passed: with 1 message: '!(Catch::Clara::Detail::is_unary_function<decltype(nullary2)>::value)'
+Clara.tests.cpp:<line number>: passed: with 1 message: '!(Catch::Clara::Detail::is_unary_function<int>::value)'
+Clara.tests.cpp:<line number>: passed: with 1 message: '!(Catch::Clara::Detail::is_unary_function<std::string const&>::value)'
+Message.tests.cpp:<line number>: failed: explicitly with 1 message: 'Previous info should not be seen'
+Message.tests.cpp:<line number>: failed: explicitly with 1 message: 'previous unscoped info SHOULD not be seen'
+Misc.tests.cpp:<line number>: passed: l == std::numeric_limits<long long>::max() for: 9223372036854775807 (0x<hex digits>)
+==
+9223372036854775807 (0x<hex digits>)
+Misc.tests.cpp:<line number>: failed: b > a for: 0 > 1
+Misc.tests.cpp:<line number>: failed: b > a for: 1 > 1
+Misc.tests.cpp:<line number>: passed: b > a for: 2 > 1
+Misc.tests.cpp:<line number>: passed: b > a for: 3 > 1
+Misc.tests.cpp:<line number>: passed: b > a for: 4 > 1
+Misc.tests.cpp:<line number>: passed: b > a for: 5 > 1
+Misc.tests.cpp:<line number>: passed: b > a for: 6 > 1
+Misc.tests.cpp:<line number>: passed: b > a for: 7 > 1
+Misc.tests.cpp:<line number>: passed: b > a for: 8 > 1
+Misc.tests.cpp:<line number>: passed: b > a for: 9 > 1
+Misc.tests.cpp:<line number>: failed: ( fib[i] % 2 ) == 0 for: 1 == 0 with 1 message: 'Testing if fib[0] (1) is even'
+Misc.tests.cpp:<line number>: failed: ( fib[i] % 2 ) == 0 for: 1 == 0 with 1 message: 'Testing if fib[1] (1) is even'
+Misc.tests.cpp:<line number>: passed: ( fib[i] % 2 ) == 0 for: 0 == 0 with 1 message: 'Testing if fib[2] (2) is even'
+Misc.tests.cpp:<line number>: failed: ( fib[i] % 2 ) == 0 for: 1 == 0 with 1 message: 'Testing if fib[3] (3) is even'
+Misc.tests.cpp:<line number>: failed: ( fib[i] % 2 ) == 0 for: 1 == 0 with 1 message: 'Testing if fib[4] (5) is even'
+Misc.tests.cpp:<line number>: passed: ( fib[i] % 2 ) == 0 for: 0 == 0 with 1 message: 'Testing if fib[5] (8) is even'
+Misc.tests.cpp:<line number>: failed: ( fib[i] % 2 ) == 0 for: 1 == 0 with 1 message: 'Testing if fib[6] (13) is even'
+Misc.tests.cpp:<line number>: failed: ( fib[i] % 2 ) == 0 for: 1 == 0 with 1 message: 'Testing if fib[7] (21) is even'
+UniquePtr.tests.cpp:<line number>: passed: !(lval.has_moved) for: !false
+UniquePtr.tests.cpp:<line number>: passed: rval.has_moved for: true
+UniquePtr.tests.cpp:<line number>: passed: *ptr == std::tuple<int, double, int>{1, 2., 3} for: {?} == {?}
+InternalBenchmark.tests.cpp:<line number>: passed: m == 19. for: 19.0 == 19.0
+InternalBenchmark.tests.cpp:<line number>: passed: x == 17 for: 17 == 17
+InternalBenchmark.tests.cpp:<line number>: passed: x == 23 for: 23 == 23
+InternalBenchmark.tests.cpp:<line number>: passed: r.elapsed.count() == 42 for: 42 == 42
+InternalBenchmark.tests.cpp:<line number>: passed: r.result == 23 for: 23 == 23
+InternalBenchmark.tests.cpp:<line number>: passed: r.iterations == 1 for: 1 == 1
+InternalBenchmark.tests.cpp:<line number>: passed: s.elapsed.count() == 69 for: 69 == 69
+InternalBenchmark.tests.cpp:<line number>: passed: s.result == 17 for: 17 == 17
+InternalBenchmark.tests.cpp:<line number>: passed: s.iterations == 1 for: 1 == 1
+Message.tests.cpp:<line number>: warning: 'info' with 2 messages: 'unscoped info' and 'and warn may mix'
+Message.tests.cpp:<line number>: warning: 'info' with 2 messages: 'unscoped info' and 'they are not cleared after warnings'
+Misc.tests.cpp:<line number>: failed: a == b for: 1 == 2
+Misc.tests.cpp:<line number>: passed: a != b for: 1 != 2
+Misc.tests.cpp:<line number>: passed: a < b for: 1 < 2
+Misc.tests.cpp:<line number>: passed: a != b for: 1 != 2
+Misc.tests.cpp:<line number>: passed: b != a for: 2 != 1
+Misc.tests.cpp:<line number>: passed: a != b for: 1 != 2
+Tricky.tests.cpp:<line number>: passed: s == "7" for: "7" == "7"
+Tricky.tests.cpp:<line number>: passed: ti == typeid(int) for: {?} == {?}
+InternalBenchmark.tests.cpp:<line number>: passed: normal_cdf(0.000000) == Approx(0.50000000000000000) for: 0.5 == Approx( 0.5 )
+InternalBenchmark.tests.cpp:<line number>: passed: normal_cdf(1.000000) == Approx(0.84134474606854293) for: 0.8413447461 == Approx( 0.8413447461 )
+InternalBenchmark.tests.cpp:<line number>: passed: normal_cdf(-1.000000) == Approx(0.15865525393145705) for: 0.1586552539 == Approx( 0.1586552539 )
+InternalBenchmark.tests.cpp:<line number>: passed: normal_cdf(2.809729) == Approx(0.99752083845315409) for: 0.9975208385 == Approx( 0.9975208385 )
+InternalBenchmark.tests.cpp:<line number>: passed: normal_cdf(-1.352570) == Approx(0.08809652095066035) for: 0.088096521 == Approx( 0.088096521 )
+InternalBenchmark.tests.cpp:<line number>: passed: normal_quantile(0.551780) == Approx(0.13015979861484198) for: 0.1301597986 == Approx( 0.1301597986 )
+InternalBenchmark.tests.cpp:<line number>: passed: normal_quantile(0.533700) == Approx(0.08457408802851875) for: 0.084574088 == Approx( 0.084574088 )
+InternalBenchmark.tests.cpp:<line number>: passed: normal_quantile(0.025000) == Approx(-1.95996398454005449) for: -1.9599639845 == Approx( -1.9599639845 )
+Misc.tests.cpp:<line number>: passed:
+Message.tests.cpp:<line number>: passed: true with 1 message: 'this MAY be seen only for the FIRST assertion IF info is printed for passing assertions'
+Message.tests.cpp:<line number>: passed: true with 1 message: 'this MAY be seen only for the SECOND assertion IF info is printed for passing assertions'
+Message.tests.cpp:<line number>: failed: false with 1 message: 'this SHOULD be seen'
+Misc.tests.cpp:<line number>: passed: makeString( false ) != static_cast<char*>(0) for: "valid string" != {null string}
+Misc.tests.cpp:<line number>: passed: makeString( true ) == static_cast<char*>(0) for: {null string} == {null string}
+Tricky.tests.cpp:<line number>: passed: ptr.get() == 0 for: 0 == 0
+ToStringPair.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( pair ) == "{ { 42, \"Arthur\" }, { \"Ford\", 24 } }" for: "{ { 42, "Arthur" }, { "Ford", 24 } }"
+==
+"{ { 42, "Arthur" }, { "Ford", 24 } }"
+ToString.tests.cpp:<line number>: passed: parseEnums( "" ), Equals( std::vector<Catch::StringRef>{} ) for: {  } Equals: {  }
+ToString.tests.cpp:<line number>: passed: parseEnums( "ClassName::EnumName::Value1" ), Equals(std::vector<Catch::StringRef>{"Value1"} ) for: { Value1 } Equals: { Value1 }
+ToString.tests.cpp:<line number>: passed: parseEnums( "Value1" ), Equals( std::vector<Catch::StringRef>{"Value1"} ) for: { Value1 } Equals: { Value1 }
+ToString.tests.cpp:<line number>: passed: parseEnums( "EnumName::Value1" ), Equals(std::vector<Catch::StringRef>{"Value1"} ) for: { Value1 } Equals: { Value1 }
+ToString.tests.cpp:<line number>: passed: parseEnums( "ClassName::EnumName::Value1, ClassName::EnumName::Value2" ), Equals( std::vector<Catch::StringRef>{"Value1", "Value2"} ) for: { Value1, Value2 } Equals: { Value1, Value2 }
+ToString.tests.cpp:<line number>: passed: parseEnums( "ClassName::EnumName::Value1, ClassName::EnumName::Value2, ClassName::EnumName::Value3" ), Equals( std::vector<Catch::StringRef>{"Value1", "Value2", "Value3"} ) for: { Value1, Value2, Value3 } Equals: { Value1, Value2, Value3 }
+ToString.tests.cpp:<line number>: passed: parseEnums( "ClassName::EnumName::Value1,ClassName::EnumName::Value2 , ClassName::EnumName::Value3" ), Equals( std::vector<Catch::StringRef>{"Value1", "Value2", "Value3"} ) for: { Value1, Value2, Value3 } Equals: { Value1, Value2, Value3 }
+Tricky.tests.cpp:<line number>: passed: p == 0 for: 0 == 0
+Message.tests.cpp:<line number>: passed: true with 1 message: 'this MAY be seen IF info is printed for passing assertions'
+Message.tests.cpp:<line number>: failed: false with 2 messages: 'this SHOULD be seen' and 'this SHOULD also be seen'
+Message.tests.cpp:<line number>: failed: false with 1 message: 'this SHOULD be seen only ONCE'
+Message.tests.cpp:<line number>: passed: true
+Message.tests.cpp:<line number>: passed: true with 1 message: 'this MAY also be seen only ONCE IF info is printed for passing assertions'
+Message.tests.cpp:<line number>: passed: true
+Misc.tests.cpp:<line number>: passed: a != b for: 1 != 2
+Misc.tests.cpp:<line number>: passed: b != a for: 2 != 1
+Misc.tests.cpp:<line number>: passed: a != b for: 1 != 2
+StringManip.tests.cpp:<line number>: passed: Catch::replaceInPlace(letters, "b", "z") for: true
+StringManip.tests.cpp:<line number>: passed: letters == "azcdefcg" for: "azcdefcg" == "azcdefcg"
+StringManip.tests.cpp:<line number>: passed: Catch::replaceInPlace(letters, "c", "z") for: true
+StringManip.tests.cpp:<line number>: passed: letters == "abzdefzg" for: "abzdefzg" == "abzdefzg"
+StringManip.tests.cpp:<line number>: passed: Catch::replaceInPlace(letters, "a", "z") for: true
+StringManip.tests.cpp:<line number>: passed: letters == "zbcdefcg" for: "zbcdefcg" == "zbcdefcg"
+StringManip.tests.cpp:<line number>: passed: Catch::replaceInPlace(letters, "g", "z") for: true
+StringManip.tests.cpp:<line number>: passed: letters == "abcdefcz" for: "abcdefcz" == "abcdefcz"
+StringManip.tests.cpp:<line number>: passed: Catch::replaceInPlace(letters, letters, "replaced") for: true
+StringManip.tests.cpp:<line number>: passed: letters == "replaced" for: "replaced" == "replaced"
+StringManip.tests.cpp:<line number>: passed: !(Catch::replaceInPlace(letters, "x", "z")) for: !false
+StringManip.tests.cpp:<line number>: passed: letters == letters for: "abcdefcg" == "abcdefcg"
+StringManip.tests.cpp:<line number>: passed: Catch::replaceInPlace(s, "'", "|'") for: true
+StringManip.tests.cpp:<line number>: passed: s == "didn|'t" for: "didn|'t" == "didn|'t"
+InternalBenchmark.tests.cpp:<line number>: passed: res.size() == count for: 10 == 10
+InternalBenchmark.tests.cpp:<line number>: passed: res[i] == rate for: 1000.0 == 1000 (0x<hex digits>)
+InternalBenchmark.tests.cpp:<line number>: passed: res[i] == rate for: 1000.0 == 1000 (0x<hex digits>)
+InternalBenchmark.tests.cpp:<line number>: passed: res[i] == rate for: 1000.0 == 1000 (0x<hex digits>)
+InternalBenchmark.tests.cpp:<line number>: passed: res[i] == rate for: 1000.0 == 1000 (0x<hex digits>)
+InternalBenchmark.tests.cpp:<line number>: passed: res[i] == rate for: 1000.0 == 1000 (0x<hex digits>)
+InternalBenchmark.tests.cpp:<line number>: passed: res[i] == rate for: 1000.0 == 1000 (0x<hex digits>)
+InternalBenchmark.tests.cpp:<line number>: passed: res[i] == rate for: 1000.0 == 1000 (0x<hex digits>)
+InternalBenchmark.tests.cpp:<line number>: passed: res[i] == rate for: 1000.0 == 1000 (0x<hex digits>)
+InternalBenchmark.tests.cpp:<line number>: passed: res[i] == rate for: 1000.0 == 1000 (0x<hex digits>)
+InternalBenchmark.tests.cpp:<line number>: passed: meter.runs() >= old_runs for: 1 >= 1
+InternalBenchmark.tests.cpp:<line number>: passed: meter.runs() >= old_runs for: 2 >= 1
+InternalBenchmark.tests.cpp:<line number>: passed: meter.runs() >= old_runs for: 4 >= 2
+InternalBenchmark.tests.cpp:<line number>: passed: meter.runs() >= old_runs for: 8 >= 4
+InternalBenchmark.tests.cpp:<line number>: passed: meter.runs() >= old_runs for: 16 >= 8
+InternalBenchmark.tests.cpp:<line number>: passed: meter.runs() >= old_runs for: 32 >= 16
+InternalBenchmark.tests.cpp:<line number>: passed: meter.runs() >= old_runs for: 64 >= 32
+InternalBenchmark.tests.cpp:<line number>: passed: meter.runs() >= old_runs for: 128 >= 64
+InternalBenchmark.tests.cpp:<line number>: passed: Timing.elapsed >= time for: 128 ns >= 100 ns
+InternalBenchmark.tests.cpp:<line number>: passed: Timing.result == Timing.iterations + 17 for: 145 == 145
+InternalBenchmark.tests.cpp:<line number>: passed: Timing.iterations >= time.count() for: 128 >= 100
+InternalBenchmark.tests.cpp:<line number>: passed: x >= old_x for: 1 >= 1
+InternalBenchmark.tests.cpp:<line number>: passed: x >= old_x for: 2 >= 1
+InternalBenchmark.tests.cpp:<line number>: passed: x >= old_x for: 4 >= 2
+InternalBenchmark.tests.cpp:<line number>: passed: x >= old_x for: 8 >= 4
+InternalBenchmark.tests.cpp:<line number>: passed: x >= old_x for: 16 >= 8
+InternalBenchmark.tests.cpp:<line number>: passed: x >= old_x for: 32 >= 16
+InternalBenchmark.tests.cpp:<line number>: passed: x >= old_x for: 64 >= 32
+InternalBenchmark.tests.cpp:<line number>: passed: x >= old_x for: 128 >= 64
+InternalBenchmark.tests.cpp:<line number>: passed: Timing.elapsed >= time for: 128 ns >= 100 ns
+InternalBenchmark.tests.cpp:<line number>: passed: Timing.result == Timing.iterations + 17 for: 145 == 145
+InternalBenchmark.tests.cpp:<line number>: passed: Timing.iterations >= time.count() for: 128 >= 100
+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, VectorContains( Tag( "magic-tag" ) ) && VectorContains( Tag( "."_catch_sr ) ) for: { {?}, {?} } ( Contains: {?} 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 }
+Message.tests.cpp:<line number>: failed: false with 4 messages: 'Count 1 to 3...' and '1' and '2' and '3'
+Message.tests.cpp:<line number>: failed: false with 4 messages: 'Count 4 to 6...' and '4' and '5' and '6'
+StringManip.tests.cpp:<line number>: passed: !(startsWith("", 'c')) for: !false
+StringManip.tests.cpp:<line number>: passed: startsWith(std::string("abc"), 'a') for: true
+StringManip.tests.cpp:<line number>: passed: startsWith("def"_catch_sr, 'd') for: true
+ToStringGeneral.tests.cpp:<line number>: passed: Catch::Detail::stringify( emptyMap ) == "{  }" for: "{  }" == "{  }"
+ToStringGeneral.tests.cpp:<line number>: passed: Catch::Detail::stringify( map ) == "{ { \"one\", 1 } }" for: "{ { "one", 1 } }" == "{ { "one", 1 } }"
+ToStringGeneral.tests.cpp:<line number>: passed: Catch::Detail::stringify( map ) == "{ { \"abc\", 1 }, { \"def\", 2 }, { \"ghi\", 3 } }" for: "{ { "abc", 1 }, { "def", 2 }, { "ghi", 3 } }"
+==
+"{ { "abc", 1 }, { "def", 2 }, { "ghi", 3 } }"
+ToStringPair.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(value) == "{ 34, \"xyzzy\" }" for: "{ 34, "xyzzy" }" == "{ 34, "xyzzy" }"
+ToStringPair.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( value ) == "{ 34, \"xyzzy\" }" for: "{ 34, "xyzzy" }" == "{ 34, "xyzzy" }"
+ToStringGeneral.tests.cpp:<line number>: passed: Catch::Detail::stringify( emptySet ) == "{  }" for: "{  }" == "{  }"
+ToStringGeneral.tests.cpp:<line number>: passed: Catch::Detail::stringify( set ) == "{ \"one\" }" for: "{ "one" }" == "{ "one" }"
+ToStringGeneral.tests.cpp:<line number>: passed: Catch::Detail::stringify( set ) == "{ \"abc\", \"def\", \"ghi\" }" for: "{ "abc", "def", "ghi" }"
+==
+"{ "abc", "def", "ghi" }"
+ToStringPair.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( pr ) == "{ { \"green\", 55 } }" for: "{ { "green", 55 } }"
+==
+"{ { "green", 55 } }"
+ToStringWhich.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(streamable_range{}) == "op<<(streamable_range)" for: "op<<(streamable_range)"
+==
+"op<<(streamable_range)"
+ToStringWhich.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(stringmaker_range{}) == "stringmaker(streamable_range)" for: "stringmaker(streamable_range)"
+==
+"stringmaker(streamable_range)"
+ToStringWhich.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(just_range{}) == "{ 1, 2, 3, 4 }" for: "{ 1, 2, 3, 4 }" == "{ 1, 2, 3, 4 }"
+ToStringWhich.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(disabled_range{}) == "{?}" for: "{?}" == "{?}"
+ToStringWhich.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( item ) == "StringMaker<has_maker>" for: "StringMaker<has_maker>"
+==
+"StringMaker<has_maker>"
+ToStringWhich.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( item ) == "StringMaker<has_maker_and_operator>" for: "StringMaker<has_maker_and_operator>"
+==
+"StringMaker<has_maker_and_operator>"
+ToStringWhich.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(item) == "{?}" for: "{?}" == "{?}"
+ToStringWhich.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( item ) == "operator<<( has_operator )" for: "operator<<( has_operator )"
+==
+"operator<<( has_operator )"
+ToStringWhich.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( item ) == "operator<<( has_template_operator )" for: "operator<<( has_template_operator )"
+==
+"operator<<( has_template_operator )"
+ToStringWhich.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( v ) == "{ StringMaker<has_maker> }" for: "{ StringMaker<has_maker> }"
+==
+"{ StringMaker<has_maker> }"
+ToStringWhich.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( v ) == "{ StringMaker<has_maker_and_operator> }" for: "{ StringMaker<has_maker_and_operator> }"
+==
+"{ StringMaker<has_maker_and_operator> }"
+ToStringWhich.tests.cpp:<line number>: passed: ::Catch::Detail::stringify( v ) == "{ operator<<( has_operator ) }" for: "{ operator<<( has_operator ) }"
+==
+"{ operator<<( has_operator ) }"
+Generators.tests.cpp:<line number>: passed: data.str.size() == data.len for: 3 == 3
+Generators.tests.cpp:<line number>: passed: data.str.size() == data.len for: 3 == 3
+Generators.tests.cpp:<line number>: passed: data.str.size() == data.len for: 5 == 5
+Generators.tests.cpp:<line number>: passed: data.str.size() == data.len for: 4 == 4
+Generators.tests.cpp:<line number>: passed: strlen(std::get<0>(data)) == static_cast<size_t>(std::get<1>(data)) for: 5 == 5
+Generators.tests.cpp:<line number>: passed: strlen(std::get<0>(data)) == static_cast<size_t>(std::get<1>(data)) for: 6 == 6
+Generators.tests.cpp:<line number>: passed: strlen(std::get<0>(data)) == static_cast<size_t>(std::get<1>(data)) for: 5 == 5
+Generators.tests.cpp:<line number>: passed: strlen(std::get<0>(data)) == static_cast<size_t>(std::get<1>(data)) for: 6 == 6
+Tag.tests.cpp:<line number>: passed: testcase.tags.size() == 1 for: 1 == 1
+Tag.tests.cpp:<line number>: passed: testcase.tags[0].original == "magic.tag"_catch_sr for: magic.tag == magic.tag
+Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'Why would you throw a std::string?'
+Misc.tests.cpp:<line number>: passed: result == "\"wide load\"" for: ""wide load"" == ""wide load""
+Misc.tests.cpp:<line number>: passed: result == "\"wide load\"" for: ""wide load"" == ""wide load""
+Misc.tests.cpp:<line number>: passed: result == "\"wide load\"" for: ""wide load"" == ""wide load""
+Misc.tests.cpp:<line number>: passed: result == "\"wide load\"" for: ""wide load"" == ""wide load""
+EnumToString.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(e0) == "E2/V0" for: "E2/V0" == "E2/V0"
+EnumToString.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(e1) == "E2/V1" for: "E2/V1" == "E2/V1"
+EnumToString.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(e3) == "Unknown enum value 10" for: "Unknown enum value 10"
+==
+"Unknown enum value 10"
+EnumToString.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(e0) == "0" for: "0" == "0"
+EnumToString.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(e1) == "1" for: "1" == "1"
+EnumToString.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(e0) == "E2{0}" for: "E2{0}" == "E2{0}"
+EnumToString.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(e1) == "E2{1}" for: "E2{1}" == "E2{1}"
+EnumToString.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(e0) == "0" for: "0" == "0"
+EnumToString.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(e1) == "1" for: "1" == "1"
+ToStringTuple.tests.cpp:<line number>: passed: "{ }" == ::Catch::Detail::stringify(type{}) for: "{ }" == "{ }"
+ToStringTuple.tests.cpp:<line number>: passed: "{ }" == ::Catch::Detail::stringify(value) for: "{ }" == "{ }"
+ToStringTuple.tests.cpp:<line number>: passed: "1.2f" == ::Catch::Detail::stringify(float(1.2)) for: "1.2f" == "1.2f"
+ToStringTuple.tests.cpp:<line number>: passed: "{ 1.2f, 0 }" == ::Catch::Detail::stringify(type{1.2f,0}) for: "{ 1.2f, 0 }" == "{ 1.2f, 0 }"
+ToStringTuple.tests.cpp:<line number>: passed: "{ 0 }" == ::Catch::Detail::stringify(type{0}) for: "{ 0 }" == "{ 0 }"
+ToStringTuple.tests.cpp:<line number>: passed: "{ 0, 42, \"Catch me\" }" == ::Catch::Detail::stringify(value) for: "{ 0, 42, "Catch me" }"
+==
+"{ 0, 42, "Catch me" }"
+ToStringTuple.tests.cpp:<line number>: passed: "{ \"hello\", \"world\" }" == ::Catch::Detail::stringify(type{"hello","world"}) for: "{ "hello", "world" }"
+==
+"{ "hello", "world" }"
+ToStringTuple.tests.cpp:<line number>: passed: "{ { 42 }, { }, 1.2f }" == ::Catch::Detail::stringify(value) for: "{ { 42 }, { }, 1.2f }"
+==
+"{ { 42 }, { }, 1.2f }"
+InternalBenchmark.tests.cpp:<line number>: passed: e.point == 23 for: 23.0 == 23
+InternalBenchmark.tests.cpp:<line number>: passed: e.upper_bound == 23 for: 23.0 == 23
+InternalBenchmark.tests.cpp:<line number>: passed: e.lower_bound == 23 for: 23.0 == 23
+InternalBenchmark.tests.cpp:<line number>: passed: e.confidence_interval == 0.95 for: 0.95 == 0.95
+UniquePtr.tests.cpp:<line number>: passed: !(ptr) for: !{?}
+UniquePtr.tests.cpp:<line number>: passed: ptr.get() == 0 for: 0 == 0
+UniquePtr.tests.cpp:<line number>: passed: ptr for: {?}
+UniquePtr.tests.cpp:<line number>: passed: *ptr == 0 for: 0 == 0
+UniquePtr.tests.cpp:<line number>: passed: ptr.get() == naked_ptr for: 0x<hex digits> == 0x<hex digits>
+UniquePtr.tests.cpp:<line number>: passed: !(ptr) for: !{?}
+UniquePtr.tests.cpp:<line number>: passed: ptr.get() == 0 for: 0 == 0
+UniquePtr.tests.cpp:<line number>: passed: ptr for: {?}
+UniquePtr.tests.cpp:<line number>: passed: *ptr == 0 for: 0 == 0
+UniquePtr.tests.cpp:<line number>: passed: ptr.get() == naked_ptr for: 0x<hex digits> == 0x<hex digits>
+UniquePtr.tests.cpp:<line number>: passed: ptr for: {?}
+UniquePtr.tests.cpp:<line number>: passed: ptr.get() != 0 for: 0x<hex digits> != 0
+UniquePtr.tests.cpp:<line number>: passed: *ptr == 2 for: 2 == 2
+UniquePtr.tests.cpp:<line number>: passed: !(ptr) for: !{?}
+UniquePtr.tests.cpp:<line number>: passed: ptr.get() == 0 for: 0 == 0
+UniquePtr.tests.cpp:<line number>: passed: !(ptr1) for: !{?}
+UniquePtr.tests.cpp:<line number>: passed: ptr2 for: {?}
+UniquePtr.tests.cpp:<line number>: passed: *ptr2 == 1 for: 1 == 1
+UniquePtr.tests.cpp:<line number>: passed: !(ptr2) for: !{?}
+UniquePtr.tests.cpp:<line number>: passed: ptr1 for: {?}
+UniquePtr.tests.cpp:<line number>: passed: *ptr1 == 2 for: 2 == 2
+UniquePtr.tests.cpp:<line number>: passed: *ptr1 == 2 for: 2 == 2
+UniquePtr.tests.cpp:<line number>: passed: *ptr2 == 1 for: 1 == 1
+ToStringVector.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(v) == "{  }" for: "{  }" == "{  }"
+ToStringVector.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(v) == "{ { \"hello\" }, { \"world\" } }" for: "{ { "hello" }, { "world" } }"
+==
+"{ { "hello" }, { "world" } }"
+ToStringVector.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(bools) == "{  }" for: "{  }" == "{  }"
+ToStringVector.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(bools) == "{ true }" for: "{ true }" == "{ true }"
+ToStringVector.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(bools) == "{ true, false }" for: "{ true, false }" == "{ true, false }"
+ToStringVector.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(vv) == "{  }" for: "{  }" == "{  }"
+ToStringVector.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(vv) == "{ 42 }" for: "{ 42 }" == "{ 42 }"
+ToStringVector.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(vv) == "{ 42, 250 }" for: "{ 42, 250 }" == "{ 42, 250 }"
+ToStringVector.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(vv) == "{  }" for: "{  }" == "{  }"
+ToStringVector.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(vv) == "{ 42 }" for: "{ 42 }" == "{ 42 }"
+ToStringVector.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(vv) == "{ 42, 250 }" for: "{ 42, 250 }" == "{ 42, 250 }"
+ToStringVector.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(vv) == "{  }" for: "{  }" == "{  }"
+ToStringVector.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(vv) == "{ \"hello\" }" for: "{ "hello" }" == "{ "hello" }"
+ToStringVector.tests.cpp:<line number>: passed: ::Catch::Detail::stringify(vv) == "{ \"hello\", \"world\" }" for: "{ "hello", "world" }"
+==
+"{ "hello", "world" }"
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 10 for: 10 == 10
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 10 for: 10 >= 10
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.capacity() == 0 for: 0 == 0
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 10 for: 10 >= 10
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+Misc.tests.cpp:<line number>: passed: v.size() == 5 for: 5 == 5
+Misc.tests.cpp:<line number>: passed: v.capacity() >= 5 for: 5 >= 5
+InternalBenchmark.tests.cpp:<line number>: passed: (iterations * rate) > Catch::Benchmark::Detail::warmup_time.count() for: 160000000 (0x<hex digits>) > 100
+InternalBenchmark.tests.cpp:<line number>: passed: (end - start) > Catch::Benchmark::Detail::warmup_time for: 310016000 ns > 100 ms
+InternalBenchmark.tests.cpp:<line number>: passed: q1 == 14.5 for: 14.5 == 14.5
+InternalBenchmark.tests.cpp:<line number>: passed: med == 18. for: 18.0 == 18.0
+InternalBenchmark.tests.cpp:<line number>: passed: q3 == 23. for: 23.0 == 23.0
+Misc.tests.cpp:<line number>: passed:
+Misc.tests.cpp:<line number>: passed:
+Failed 83 test cases, failed 143 assertions.
+
diff --git a/tests/SelfTest/Baselines/console.std.approved.txt b/tests/SelfTest/Baselines/console.std.approved.txt
index 51bb9e52..dfc8d3bd 100644
--- a/tests/SelfTest/Baselines/console.std.approved.txt
+++ b/tests/SelfTest/Baselines/console.std.approved.txt
@@ -1396,5 +1396,5 @@ due to unexpected exception with message:
 
 ===============================================================================
 test cases:  380 |  304 passed |  69 failed |  7 failed as expected
-assertions: 2183 | 2028 passed | 128 failed | 27 failed as expected
+assertions: 2194 | 2039 passed | 128 failed | 27 failed as expected
 
diff --git a/tests/SelfTest/Baselines/console.sw.approved.txt b/tests/SelfTest/Baselines/console.sw.approved.txt
index a037f16f..4b4a2ed0 100644
--- a/tests/SelfTest/Baselines/console.sw.approved.txt
+++ b/tests/SelfTest/Baselines/console.sw.approved.txt
@@ -9158,9 +9158,11 @@ with expansion:
   false == false
 
 CmdLine.tests.cpp:<line number>: PASSED:
-  CHECK( config.reporterName == "console" )
+  CHECK( config.reporterSpecifications == std::vector<Catch::ConfigData::ReporterAndFile>{ {"console", {}} } )
 with expansion:
-  "console" == "console"
+  { { console, <default-output> } }
+  ==
+  { { console, <default-output> } }
 
 CmdLine.tests.cpp:<line number>: PASSED:
   CHECK_FALSE( cfg.hasTestFilters() )
@@ -9260,14 +9262,20 @@ CmdLine.tests.cpp:<line number>
 ...............................................................................
 
 CmdLine.tests.cpp:<line number>: PASSED:
-  CHECK( cli.parse({"test", "-r", "console"}) )
+  CHECK( result )
 with expansion:
   {?}
+with message:
+  result.errorMessage() := ""
 
 CmdLine.tests.cpp:<line number>: PASSED:
-  REQUIRE( config.reporterName == "console" )
+  REQUIRE( config.reporterSpecifications == vec_ReporterAndFile{ {"console", {}} } )
 with expansion:
-  "console" == "console"
+  { { console, <default-output> } }
+  ==
+  { { console, <default-output> } }
+with message:
+  result.errorMessage() := ""
 
 -------------------------------------------------------------------------------
 Process can be configured on command line
@@ -9278,14 +9286,20 @@ CmdLine.tests.cpp:<line number>
 ...............................................................................
 
 CmdLine.tests.cpp:<line number>: PASSED:
-  CHECK( cli.parse({"test", "-r", "xml"}) )
+  CHECK( result )
 with expansion:
   {?}
+with message:
+  result.errorMessage() := ""
 
 CmdLine.tests.cpp:<line number>: PASSED:
-  REQUIRE( config.reporterName == "xml" )
+  REQUIRE( config.reporterSpecifications == vec_ReporterAndFile{ {"xml", {}} } )
 with expansion:
-  "xml" == "xml"
+  { { xml, <default-output> } }
+  ==
+  { { xml, <default-output> } }
+with message:
+  result.errorMessage() := ""
 
 -------------------------------------------------------------------------------
 Process can be configured on command line
@@ -9296,32 +9310,92 @@ CmdLine.tests.cpp:<line number>
 ...............................................................................
 
 CmdLine.tests.cpp:<line number>: PASSED:
-  CHECK( cli.parse({"test", "--reporter", "junit"}) )
+  CHECK( result )
 with expansion:
   {?}
+with message:
+  result.errorMessage() := ""
 
 CmdLine.tests.cpp:<line number>: PASSED:
-  REQUIRE( config.reporterName == "junit" )
+  REQUIRE( config.reporterSpecifications == vec_ReporterAndFile{ {"junit", {}} } )
 with expansion:
-  "junit" == "junit"
+  { { junit, <default-output> } }
+  ==
+  { { junit, <default-output> } }
+with message:
+  result.errorMessage() := ""
 
 -------------------------------------------------------------------------------
 Process can be configured on command line
   reporter
-  Only one reporter is accepted
+  must match one of the available ones
 -------------------------------------------------------------------------------
 CmdLine.tests.cpp:<line number>
 ...............................................................................
 
 CmdLine.tests.cpp:<line number>: PASSED:
-  REQUIRE_FALSE( cli.parse({ "test", "-r", "xml", "-r", "junit" }) )
+  CHECK( !result )
 with expansion:
-  !{?}
+  true
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( result.errorMessage(), ContainsSubstring("Unrecognized reporter") )
+with expansion:
+  "Unrecognized reporter, 'unsupported'. Check available with --list-reporters"
+  contains: "Unrecognized reporter"
 
 -------------------------------------------------------------------------------
 Process can be configured on command line
   reporter
-  must match one of the available ones
+  With output file
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  CHECK( result )
+with expansion:
+  {?}
+with message:
+  result.errorMessage() := ""
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  REQUIRE( config.reporterSpecifications == vec_ReporterAndFile{ {"console", "out.txt"s} } )
+with expansion:
+  { { console, out.txt } }
+  ==
+  { { console, out.txt } }
+with message:
+  result.errorMessage() := ""
+
+-------------------------------------------------------------------------------
+Process can be configured on command line
+  reporter
+  With Windows-like absolute path as output file
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  CHECK( result )
+with expansion:
+  {?}
+with message:
+  result.errorMessage() := ""
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  REQUIRE( config.reporterSpecifications == vec_ReporterAndFile{ {"console", "C:\\Temp\\out.txt"s} } )
+with expansion:
+  { { console, C:\Temp\out.txt } }
+  ==
+  { { console, C:\Temp\out.txt } }
+with message:
+  result.errorMessage() := ""
+
+-------------------------------------------------------------------------------
+Process can be configured on command line
+  reporter
+  Output file cannot be empty
 -------------------------------------------------------------------------------
 CmdLine.tests.cpp:<line number>
 ...............................................................................
@@ -9332,10 +9406,73 @@ with expansion:
   true
 
 CmdLine.tests.cpp:<line number>: PASSED:
-  REQUIRE_THAT( result.errorMessage(), ContainsSubstring("Unrecognized reporter") )
+  REQUIRE_THAT( result.errorMessage(), ContainsSubstring("empty filename") )
 with expansion:
-  "Unrecognized reporter, 'unsupported'. Check available with --list-reporters"
-  contains: "Unrecognized reporter"
+  "Reporter 'console' has empty filename specified as its output. Supply a
+  filename or remove the colons to use the default output." contains: "empty
+  filename"
+
+-------------------------------------------------------------------------------
+Process can be configured on command line
+  reporter
+  Multiple reporters
+  All with output files
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  CHECK( cli.parse({ "test", "-r", "xml::output.xml", "-r", "junit::output-junit.xml" }) )
+with expansion:
+  {?}
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  REQUIRE( config.reporterSpecifications == vec_ReporterAndFile{ {"xml", "output.xml"s}, {"junit", "output-junit.xml"s} } )
+with expansion:
+  { { xml, output.xml }, { junit, output-junit.xml } }
+  ==
+  { { xml, output.xml }, { junit, output-junit.xml } }
+
+-------------------------------------------------------------------------------
+Process can be configured on command line
+  reporter
+  Multiple reporters
+  Mixed output files and default output
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  CHECK( cli.parse({ "test", "-r", "xml::output.xml", "-r", "console" }) )
+with expansion:
+  {?}
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  REQUIRE( config.reporterSpecifications == vec_ReporterAndFile{ {"xml", "output.xml"s}, {"console", {}} } )
+with expansion:
+  { { xml, output.xml }, { console, <default-output> } }
+  ==
+  { { xml, output.xml }, { console, <default-output> } }
+
+-------------------------------------------------------------------------------
+Process can be configured on command line
+  reporter
+  Multiple reporters
+  cannot have multiple reporters with default output
+-------------------------------------------------------------------------------
+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(), ContainsSubstring("Only one reporter may have unspecified output file.") )
+with expansion:
+  "Only one reporter may have unspecified output file." contains: "Only one
+  reporter may have unspecified output file."
 
 -------------------------------------------------------------------------------
 Process can be configured on command line
@@ -9574,7 +9711,7 @@ with expansion:
   {?}
 
 CmdLine.tests.cpp:<line number>: PASSED:
-  REQUIRE( config.outputFilename == "filename.ext" )
+  REQUIRE( config.defaultOutputFilename == "filename.ext" )
 with expansion:
   "filename.ext" == "filename.ext"
 
@@ -9592,7 +9729,7 @@ with expansion:
   {?}
 
 CmdLine.tests.cpp:<line number>: PASSED:
-  REQUIRE( config.outputFilename == "filename.ext" )
+  REQUIRE( config.defaultOutputFilename == "filename.ext" )
 with expansion:
   "filename.ext" == "filename.ext"
 
@@ -17517,5 +17654,5 @@ Misc.tests.cpp:<line number>: PASSED:
 
 ===============================================================================
 test cases:  380 |  290 passed |  83 failed |  7 failed as expected
-assertions: 2198 | 2028 passed | 143 failed | 27 failed as expected
+assertions: 2209 | 2039 passed | 143 failed | 27 failed as expected
 
diff --git a/tests/SelfTest/Baselines/console.sw.multi.approved.txt b/tests/SelfTest/Baselines/console.sw.multi.approved.txt
new file mode 100644
index 00000000..8c8d166f
--- /dev/null
+++ b/tests/SelfTest/Baselines/console.sw.multi.approved.txt
@@ -0,0 +1,17650 @@
+Filters: ~[!nonportable]~[!benchmark]~[approvals] *
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+<exe-name> is a <version> host application.
+Run with -? for options
+
+Randomness seeded to: 1
+
+-------------------------------------------------------------------------------
+# A test name that starts with a #
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+with message:
+  yay
+
+-------------------------------------------------------------------------------
+#1005: Comparing pointer to int and long (NULL can be either on various
+       systems)
+-------------------------------------------------------------------------------
+Decomposition.tests.cpp:<line number>
+...............................................................................
+
+Decomposition.tests.cpp:<line number>: PASSED:
+  REQUIRE( fptr == 0 )
+with expansion:
+  0 == 0
+
+Decomposition.tests.cpp:<line number>: PASSED:
+  REQUIRE( fptr == 0l )
+with expansion:
+  0 == 0
+
+-------------------------------------------------------------------------------
+#1027: Bitfields can be captured
+-------------------------------------------------------------------------------
+Compilation.tests.cpp:<line number>
+...............................................................................
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE( y.v == 0 )
+with expansion:
+  0 == 0
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE( 0 == y.v )
+with expansion:
+  0 == 0
+
+-------------------------------------------------------------------------------
+#1147
+-------------------------------------------------------------------------------
+Compilation.tests.cpp:<line number>
+...............................................................................
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE( t1 == t2 )
+with expansion:
+  {?} == {?}
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE( t1 != t2 )
+with expansion:
+  {?} != {?}
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE( t1 < t2 )
+with expansion:
+  {?} < {?}
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE( t1 > t2 )
+with expansion:
+  {?} > {?}
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE( t1 <= t2 )
+with expansion:
+  {?} <= {?}
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE( t1 >= t2 )
+with expansion:
+  {?} >= {?}
+
+-------------------------------------------------------------------------------
+#1175 - Hidden Test
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+
+-------------------------------------------------------------------------------
+#1238
+-------------------------------------------------------------------------------
+Compilation.tests.cpp:<line number>
+...............................................................................
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE( std::memcmp(uarr, "123", sizeof(uarr)) == 0 )
+with expansion:
+  0 == 0
+with messages:
+  uarr := "123"
+  sarr := "456"
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE( std::memcmp(sarr, "456", sizeof(sarr)) == 0 )
+with expansion:
+  0 == 0
+with messages:
+  uarr := "123"
+  sarr := "456"
+
+-------------------------------------------------------------------------------
+#1245
+-------------------------------------------------------------------------------
+Compilation.tests.cpp:<line number>
+...............................................................................
+
+Compilation.tests.cpp:<line number>: PASSED:
+
+-------------------------------------------------------------------------------
+#1319: Sections can have description (even if it is not saved
+  SectionName
+-------------------------------------------------------------------------------
+Compilation.tests.cpp:<line number>
+...............................................................................
+
+Compilation.tests.cpp:<line number>: PASSED:
+
+-------------------------------------------------------------------------------
+#1403
+-------------------------------------------------------------------------------
+Compilation.tests.cpp:<line number>
+...............................................................................
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE( h1 == h2 )
+with expansion:
+  [1403 helper] == [1403 helper]
+
+-------------------------------------------------------------------------------
+#1455 - INFO and WARN can start with a linebreak
+-------------------------------------------------------------------------------
+Message.tests.cpp:<line number>
+...............................................................................
+
+Message.tests.cpp:<line number>: warning:
+
+This info message starts with a linebreak
+
+This warning message starts with a linebreak
+
+
+No assertions in test case '#1455 - INFO and WARN can start with a linebreak'
+
+-------------------------------------------------------------------------------
+#1514: stderr/stdout is not captured in tests aborted by an exception
+-------------------------------------------------------------------------------
+Tricky.tests.cpp:<line number>
+...............................................................................
+
+Tricky.tests.cpp:<line number>: FAILED:
+explicitly with message:
+  1514
+
+-------------------------------------------------------------------------------
+#1548
+-------------------------------------------------------------------------------
+Compilation.tests.cpp:<line number>
+...............................................................................
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE( std::is_same<TypeList<int>, TypeList<int>>::value )
+with expansion:
+  true
+
+-------------------------------------------------------------------------------
+#1905 -- test spec parser properly clears internal state between compound tests
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  REQUIRE( spec.matches(*fakeTestCase("spec . char")) )
+with expansion:
+  true
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  REQUIRE( spec.matches(*fakeTestCase("spec , char")) )
+with expansion:
+  true
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( spec.matches(*fakeTestCase(R"(spec \, char)")) )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+#1912 -- test spec parser handles escaping
+  Various parentheses
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  REQUIRE( spec.matches(*fakeTestCase(R"(spec {a} char)")) )
+with expansion:
+  true
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  REQUIRE( spec.matches(*fakeTestCase(R"(spec [a] char)")) )
+with expansion:
+  true
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( spec.matches(*fakeTestCase("differs but has similar tag", "[a]")) )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+#1912 -- test spec parser handles escaping
+  backslash in test name
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
+
+CmdLine.tests.cpp:<line number>: PASSED:
+  REQUIRE( spec.matches(*fakeTestCase(R"(spec \ char)")) )
+with expansion:
+  true
+
+-------------------------------------------------------------------------------
+#1913 - GENERATE inside a for loop should not keep recreating the generator
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( counter < 7 )
+with expansion:
+  3 < 7
+
+-------------------------------------------------------------------------------
+#1913 - GENERATE inside a for loop should not keep recreating the generator
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( counter < 7 )
+with expansion:
+  6 < 7
+
+-------------------------------------------------------------------------------
+#1913 - GENERATEs can share a line
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( i != j )
+with expansion:
+  1 != 3
+
+-------------------------------------------------------------------------------
+#1913 - GENERATEs can share a line
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( i != j )
+with expansion:
+  1 != 4
+
+-------------------------------------------------------------------------------
+#1913 - GENERATEs can share a line
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( i != j )
+with expansion:
+  2 != 3
+
+-------------------------------------------------------------------------------
+#1913 - GENERATEs can share a line
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( i != j )
+with expansion:
+  2 != 4
+
+-------------------------------------------------------------------------------
+#1938 - GENERATE after a section
+  A
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+with message:
+  A
+
+-------------------------------------------------------------------------------
+#1938 - GENERATE after a section
+  B
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( m )
+with expansion:
+  1
+
+-------------------------------------------------------------------------------
+#1938 - GENERATE after a section
+  B
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( m )
+with expansion:
+  2
+
+-------------------------------------------------------------------------------
+#1938 - GENERATE after a section
+  B
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( m )
+with expansion:
+  3
+
+-------------------------------------------------------------------------------
+#1938 - Section followed by flat generate
+  A
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( 1 )
+
+-------------------------------------------------------------------------------
+#1938 - Section followed by flat generate
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( m )
+with expansion:
+  2
+
+-------------------------------------------------------------------------------
+#1938 - Section followed by flat generate
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( m )
+with expansion:
+  3
+
+-------------------------------------------------------------------------------
+#1938 - flat generate
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( m )
+with expansion:
+  1
+
+-------------------------------------------------------------------------------
+#1938 - flat generate
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( m )
+with expansion:
+  2
+
+-------------------------------------------------------------------------------
+#1938 - flat generate
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( m )
+with expansion:
+  3
+
+-------------------------------------------------------------------------------
+#1938 - mixed sections and generates
+  A
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+with message:
+  A
+
+-------------------------------------------------------------------------------
+#1938 - mixed sections and generates
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+with messages:
+  i := 1
+  j := 3
+  k := 5
+
+-------------------------------------------------------------------------------
+#1938 - mixed sections and generates
+  B
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+with message:
+  B
+
+-------------------------------------------------------------------------------
+#1938 - mixed sections and generates
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+with messages:
+  i := 1
+  j := 3
+  k := 6
+
+-------------------------------------------------------------------------------
+#1938 - mixed sections and generates
+  B
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+with message:
+  B
+
+-------------------------------------------------------------------------------
+#1938 - mixed sections and generates
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+with messages:
+  i := 1
+  j := 4
+  k := 5
+
+-------------------------------------------------------------------------------
+#1938 - mixed sections and generates
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+with messages:
+  i := 1
+  j := 4
+  k := 6
+
+-------------------------------------------------------------------------------
+#1938 - mixed sections and generates
+  A
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+with message:
+  A
+
+-------------------------------------------------------------------------------
+#1938 - mixed sections and generates
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+with messages:
+  i := 2
+  j := 3
+  k := 5
+
+-------------------------------------------------------------------------------
+#1938 - mixed sections and generates
+  B
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+with message:
+  B
+
+-------------------------------------------------------------------------------
+#1938 - mixed sections and generates
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+with messages:
+  i := 2
+  j := 3
+  k := 6
+
+-------------------------------------------------------------------------------
+#1938 - mixed sections and generates
+  B
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+with message:
+  B
+
+-------------------------------------------------------------------------------
+#1938 - mixed sections and generates
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+with messages:
+  i := 2
+  j := 4
+  k := 5
+
+-------------------------------------------------------------------------------
+#1938 - mixed sections and generates
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+with messages:
+  i := 2
+  j := 4
+  k := 6
+
+-------------------------------------------------------------------------------
+#1938 - nested generate
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( m )
+with expansion:
+  1
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( n )
+with expansion:
+  1
+
+-------------------------------------------------------------------------------
+#1938 - nested generate
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( m )
+with expansion:
+  1
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( n )
+with expansion:
+  2
+
+-------------------------------------------------------------------------------
+#1938 - nested generate
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( m )
+with expansion:
+  1
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( n )
+with expansion:
+  3
+
+-------------------------------------------------------------------------------
+#1938 - nested generate
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( m )
+with expansion:
+  2
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( n )
+with expansion:
+  1
+
+-------------------------------------------------------------------------------
+#1938 - nested generate
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( m )
+with expansion:
+  2
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( n )
+with expansion:
+  2
+
+-------------------------------------------------------------------------------
+#1938 - nested generate
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( m )
+with expansion:
+  2
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( n )
+with expansion:
+  3
+
+-------------------------------------------------------------------------------
+#1938 - nested generate
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( m )
+with expansion:
+  3
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( n )
+with expansion:
+  1
+
+-------------------------------------------------------------------------------
+#1938 - nested generate
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( m )
+with expansion:
+  3
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( n )
+with expansion:
+  2
+
+-------------------------------------------------------------------------------
+#1938 - nested generate
+-------------------------------------------------------------------------------
+PartTracker.tests.cpp:<line number>
+...............................................................................
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( m )
+with expansion:
+  3
+
+PartTracker.tests.cpp:<line number>: PASSED:
+  REQUIRE( n )
+with expansion:
+  3
+
+-------------------------------------------------------------------------------
+#1954 - 7 arg template test case sig compiles - 1, 1, 1, 1, 1, 0, 0
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+
+-------------------------------------------------------------------------------
+#1954 - 7 arg template test case sig compiles - 5, 1, 1, 1, 1, 0, 0
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+
+-------------------------------------------------------------------------------
+#1954 - 7 arg template test case sig compiles - 5, 3, 1, 1, 1, 0, 0
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+
+-------------------------------------------------------------------------------
+#2152 - ULP checks between differently signed values were wrong - double
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  CHECK_THAT( smallest_non_zero, WithinULP( -smallest_non_zero, 2 ) )
+with expansion:
+  0.0 is within 2 ULPs of -4.9406564584124654e-324 ([-1.4821969375237396e-323,
+  4.9406564584124654e-324])
+
+Matchers.tests.cpp:<line number>: PASSED:
+  CHECK_THAT( smallest_non_zero, !WithinULP( -smallest_non_zero, 1 ) )
+with expansion:
+  0.0 not is within 1 ULPs of -4.9406564584124654e-324 ([-9.8813129168249309e-
+  324, -0.0000000000000000e+00])
+
+-------------------------------------------------------------------------------
+#2152 - ULP checks between differently signed values were wrong - float
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  CHECK_THAT( smallest_non_zero, WithinULP( -smallest_non_zero, 2 ) )
+with expansion:
+  0.0f is within 2 ULPs of -1.40129846e-45f ([-4.20389539e-45, 1.40129846e-45])
+
+Matchers.tests.cpp:<line number>: PASSED:
+  CHECK_THAT( smallest_non_zero, !WithinULP( -smallest_non_zero, 1 ) )
+with expansion:
+  0.0f not is within 1 ULPs of -1.40129846e-45f ([-2.80259693e-45, -0.
+  00000000e+00])
+
+-------------------------------------------------------------------------------
+#748 - captures with unexpected exceptions
+  outside assertions
+-------------------------------------------------------------------------------
+Exception.tests.cpp:<line number>
+...............................................................................
+
+Exception.tests.cpp:<line number>: FAILED:
+due to unexpected exception with messages:
+  answer := 42
+  expected exception
+
+-------------------------------------------------------------------------------
+#748 - captures with unexpected exceptions
+  inside REQUIRE_NOTHROW
+-------------------------------------------------------------------------------
+Exception.tests.cpp:<line number>
+...............................................................................
+
+Exception.tests.cpp:<line number>: FAILED:
+  REQUIRE_NOTHROW( thisThrows() )
+due to unexpected exception with messages:
+  answer := 42
+  expected exception
+
+-------------------------------------------------------------------------------
+#748 - captures with unexpected exceptions
+  inside REQUIRE_THROWS
+-------------------------------------------------------------------------------
+Exception.tests.cpp:<line number>
+...............................................................................
+
+Exception.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS( thisThrows() )
+with message:
+  answer := 42
+
+-------------------------------------------------------------------------------
+#809
+-------------------------------------------------------------------------------
+Compilation.tests.cpp:<line number>
+...............................................................................
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE( 42 == f )
+with expansion:
+  42 == {?}
+
+-------------------------------------------------------------------------------
+#833
+-------------------------------------------------------------------------------
+Compilation.tests.cpp:<line number>
+...............................................................................
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE( a == t )
+with expansion:
+  3 == 3
+
+Compilation.tests.cpp:<line number>: PASSED:
+  CHECK( a == t )
+with expansion:
+  3 == 3
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS( throws_int(true) )
+
+Compilation.tests.cpp:<line number>: PASSED:
+  CHECK_THROWS_AS( throws_int(true), int )
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE_NOTHROW( throws_int(false) )
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( "aaa", Catch::Matchers::EndsWith("aaa") )
+with expansion:
+  "aaa" ends with: "aaa"
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE( templated_tests<int>(3) )
+with expansion:
+  true
+
+-------------------------------------------------------------------------------
+#835 -- errno should not be touched by Catch
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: FAILED:
+  CHECK( f() == 0 )
+with expansion:
+  1 == 0
+
+Misc.tests.cpp:<line number>: PASSED:
+  REQUIRE( errno == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+#872
+-------------------------------------------------------------------------------
+Compilation.tests.cpp:<line number>
+...............................................................................
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE( x == 4 )
+with expansion:
+  {?} == 4
+with message:
+  dummy := 0
+
+-------------------------------------------------------------------------------
+#961 -- Dynamically created sections should all be reported
+  Looped section 0
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+with message:
+  Everything is OK
+
+-------------------------------------------------------------------------------
+#961 -- Dynamically created sections should all be reported
+  Looped section 1
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+with message:
+  Everything is OK
+
+-------------------------------------------------------------------------------
+#961 -- Dynamically created sections should all be reported
+  Looped section 2
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+with message:
+  Everything is OK
+
+-------------------------------------------------------------------------------
+#961 -- Dynamically created sections should all be reported
+  Looped section 3
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+with message:
+  Everything is OK
+
+-------------------------------------------------------------------------------
+#961 -- Dynamically created sections should all be reported
+  Looped section 4
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+with message:
+  Everything is OK
+
+-------------------------------------------------------------------------------
+'Not' checks that should fail
+-------------------------------------------------------------------------------
+Condition.tests.cpp:<line number>
+...............................................................................
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK( false != false )
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK( true != true )
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK( !true )
+with expansion:
+  false
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK_FALSE( true )
+with expansion:
+  !true
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK( !trueValue )
+with expansion:
+  false
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK_FALSE( trueValue )
+with expansion:
+  !true
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK( !(1 == 1) )
+with expansion:
+  false
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK_FALSE( 1 == 1 )
+
+-------------------------------------------------------------------------------
+'Not' checks that should succeed
+-------------------------------------------------------------------------------
+Condition.tests.cpp:<line number>
+...............................................................................
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( false == false )
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( true == true )
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( !false )
+with expansion:
+  true
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( false )
+with expansion:
+  !false
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( !falseValue )
+with expansion:
+  true
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( falseValue )
+with expansion:
+  !false
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( !(1 == 2) )
+with expansion:
+  true
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( 1 == 2 )
+
+-------------------------------------------------------------------------------
+(unimplemented) static bools can be evaluated
+  compare to true
+-------------------------------------------------------------------------------
+Tricky.tests.cpp:<line number>
+...............................................................................
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE( is_true<true>::value == true )
+with expansion:
+  true == true
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE( true == is_true<true>::value )
+with expansion:
+  true == true
+
+-------------------------------------------------------------------------------
+(unimplemented) static bools can be evaluated
+  compare to false
+-------------------------------------------------------------------------------
+Tricky.tests.cpp:<line number>
+...............................................................................
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE( is_true<false>::value == false )
+with expansion:
+  false == false
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE( false == is_true<false>::value )
+with expansion:
+  false == false
+
+-------------------------------------------------------------------------------
+(unimplemented) static bools can be evaluated
+  negation
+-------------------------------------------------------------------------------
+Tricky.tests.cpp:<line number>
+...............................................................................
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE( !is_true<false>::value )
+with expansion:
+  true
+
+-------------------------------------------------------------------------------
+(unimplemented) static bools can be evaluated
+  double negation
+-------------------------------------------------------------------------------
+Tricky.tests.cpp:<line number>
+...............................................................................
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE( !!is_true<true>::value )
+with expansion:
+  true
+
+-------------------------------------------------------------------------------
+(unimplemented) static bools can be evaluated
+  direct
+-------------------------------------------------------------------------------
+Tricky.tests.cpp:<line number>
+...............................................................................
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE( is_true<true>::value )
+with expansion:
+  true
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( is_true<false>::value )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  1 < 4
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  4 < 7
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  1 < 7
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  1 < 4
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  4 < 8
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  1 < 8
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  1 < 4
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  4 < 9
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  1 < 9
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  1 < 5
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  5 < 7
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  1 < 7
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  1 < 5
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  5 < 8
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  1 < 8
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  1 < 5
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  5 < 9
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  1 < 9
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  1 < 6
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  6 < 7
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  1 < 7
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  1 < 6
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  6 < 8
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  1 < 8
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  1 < 6
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  6 < 9
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  1 < 9
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  2 < 4
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  4 < 7
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  2 < 7
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  2 < 4
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  4 < 8
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  2 < 8
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  2 < 4
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  4 < 9
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  2 < 9
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  2 < 5
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  5 < 7
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  2 < 7
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  2 < 5
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  5 < 8
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  2 < 8
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  2 < 5
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  5 < 9
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  2 < 9
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  2 < 6
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  6 < 7
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  2 < 7
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  2 < 6
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  6 < 8
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  2 < 8
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  2 < 6
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  6 < 9
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  2 < 9
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  3 < 4
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  4 < 7
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  3 < 7
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  3 < 4
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  4 < 8
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  3 < 8
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  3 < 4
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  4 < 9
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  3 < 9
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  3 < 5
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  5 < 7
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  3 < 7
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  3 < 5
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  5 < 8
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  3 < 8
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  3 < 5
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  5 < 9
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  3 < 9
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  3 < 6
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  6 < 7
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  3 < 7
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  3 < 6
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  6 < 8
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  3 < 8
+
+-------------------------------------------------------------------------------
+3x3x3 ints
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( x < y )
+with expansion:
+  3 < 6
+
+Generators.tests.cpp:<line number>: PASSED:
+  CHECK( y < z )
+with expansion:
+  6 < 9
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( x < z )
+with expansion:
+  3 < 9
+
+-------------------------------------------------------------------------------
+A METHOD_AS_TEST_CASE based test run that fails
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: FAILED:
+  REQUIRE( s == "world" )
+with expansion:
+  "hello" == "world"
+
+-------------------------------------------------------------------------------
+A METHOD_AS_TEST_CASE based test run that succeeds
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: PASSED:
+  REQUIRE( s == "hello" )
+with expansion:
+  "hello" == "hello"
+
+-------------------------------------------------------------------------------
+A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo
+<float>
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: FAILED:
+  REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )
+with expansion:
+  0 == 1
+
+-------------------------------------------------------------------------------
+A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo
+<int>
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: FAILED:
+  REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )
+with expansion:
+  0 == 1
+
+-------------------------------------------------------------------------------
+A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector
+<float>
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: FAILED:
+  REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )
+with expansion:
+  0 == 1
+
+-------------------------------------------------------------------------------
+A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector
+<int>
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: FAILED:
+  REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )
+with expansion:
+  0 == 1
+
+-------------------------------------------------------------------------------
+A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo
+<float>
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: PASSED:
+  REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 0 )
+with expansion:
+  0 == 0
+
+-------------------------------------------------------------------------------
+A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo
+<int>
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: PASSED:
+  REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 0 )
+with expansion:
+  0 == 0
+
+-------------------------------------------------------------------------------
+A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector
+<float>
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: PASSED:
+  REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 0 )
+with expansion:
+  0 == 0
+
+-------------------------------------------------------------------------------
+A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector
+<int>
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: PASSED:
+  REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 0 )
+with expansion:
+  0 == 0
+
+-------------------------------------------------------------------------------
+A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails -
+Template_Foo_2<float, 6>
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: FAILED:
+  REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )
+with expansion:
+  6 < 2
+
+-------------------------------------------------------------------------------
+A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails -
+Template_Foo_2<int, 2>
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: FAILED:
+  REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )
+with expansion:
+  2 < 2
+
+-------------------------------------------------------------------------------
+A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array
+<float, 6>
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: FAILED:
+  REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )
+with expansion:
+  6 < 2
+
+-------------------------------------------------------------------------------
+A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array
+<int, 2>
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: FAILED:
+  REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )
+with expansion:
+  2 < 2
+
+-------------------------------------------------------------------------------
+A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds -
+Template_Foo_2<float,6>
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: PASSED:
+  REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() >= 2 )
+with expansion:
+  6 >= 2
+
+-------------------------------------------------------------------------------
+A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds -
+Template_Foo_2<int,2>
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: PASSED:
+  REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() >= 2 )
+with expansion:
+  2 >= 2
+
+-------------------------------------------------------------------------------
+A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::
+array<float,6>
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: PASSED:
+  REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() >= 2 )
+with expansion:
+  6 >= 2
+
+-------------------------------------------------------------------------------
+A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::
+array<int,2>
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: PASSED:
+  REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() >= 2 )
+with expansion:
+  2 >= 2
+
+-------------------------------------------------------------------------------
+A TEMPLATE_TEST_CASE_METHOD based test run that fails - double
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: FAILED:
+  REQUIRE( Template_Fixture<TestType>::m_a == 2 )
+with expansion:
+  1.0 == 2
+
+-------------------------------------------------------------------------------
+A TEMPLATE_TEST_CASE_METHOD based test run that fails - float
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: FAILED:
+  REQUIRE( Template_Fixture<TestType>::m_a == 2 )
+with expansion:
+  1.0f == 2
+
+-------------------------------------------------------------------------------
+A TEMPLATE_TEST_CASE_METHOD based test run that fails - int
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: FAILED:
+  REQUIRE( Template_Fixture<TestType>::m_a == 2 )
+with expansion:
+  1 == 2
+
+-------------------------------------------------------------------------------
+A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: PASSED:
+  REQUIRE( Template_Fixture<TestType>::m_a == 1 )
+with expansion:
+  1.0 == 1
+
+-------------------------------------------------------------------------------
+A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - float
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: PASSED:
+  REQUIRE( Template_Fixture<TestType>::m_a == 1 )
+with expansion:
+  1.0f == 1
+
+-------------------------------------------------------------------------------
+A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - int
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: PASSED:
+  REQUIRE( Template_Fixture<TestType>::m_a == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: FAILED:
+  REQUIRE( Nttp_Fixture<V>::value == 0 )
+with expansion:
+  1 == 0
+
+-------------------------------------------------------------------------------
+A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: FAILED:
+  REQUIRE( Nttp_Fixture<V>::value == 0 )
+with expansion:
+  3 == 0
+
+-------------------------------------------------------------------------------
+A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: FAILED:
+  REQUIRE( Nttp_Fixture<V>::value == 0 )
+with expansion:
+  6 == 0
+
+-------------------------------------------------------------------------------
+A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: PASSED:
+  REQUIRE( Nttp_Fixture<V>::value > 0 )
+with expansion:
+  1 > 0
+
+-------------------------------------------------------------------------------
+A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 3
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: PASSED:
+  REQUIRE( Nttp_Fixture<V>::value > 0 )
+with expansion:
+  3 > 0
+
+-------------------------------------------------------------------------------
+A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 6
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: PASSED:
+  REQUIRE( Nttp_Fixture<V>::value > 0 )
+with expansion:
+  6 > 0
+
+-------------------------------------------------------------------------------
+A TEST_CASE_METHOD based test run that fails
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: FAILED:
+  REQUIRE( m_a == 2 )
+with expansion:
+  1 == 2
+
+-------------------------------------------------------------------------------
+A TEST_CASE_METHOD based test run that succeeds
+-------------------------------------------------------------------------------
+Class.tests.cpp:<line number>
+...............................................................................
+
+Class.tests.cpp:<line number>: PASSED:
+  REQUIRE( m_a == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+A Template product test case - Foo<float>
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+  REQUIRE( x.size() == 0 )
+with expansion:
+  0 == 0
+
+-------------------------------------------------------------------------------
+A Template product test case - Foo<int>
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+  REQUIRE( x.size() == 0 )
+with expansion:
+  0 == 0
+
+-------------------------------------------------------------------------------
+A Template product test case - std::vector<float>
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+  REQUIRE( x.size() == 0 )
+with expansion:
+  0 == 0
+
+-------------------------------------------------------------------------------
+A Template product test case - std::vector<int>
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+  REQUIRE( x.size() == 0 )
+with expansion:
+  0 == 0
+
+-------------------------------------------------------------------------------
+A Template product test case with array signature - Bar<float, 42>
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+  REQUIRE( x.size() > 0 )
+with expansion:
+  42 > 0
+
+-------------------------------------------------------------------------------
+A Template product test case with array signature - Bar<int, 9>
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+  REQUIRE( x.size() > 0 )
+with expansion:
+  9 > 0
+
+-------------------------------------------------------------------------------
+A Template product test case with array signature - std::array<float, 42>
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+  REQUIRE( x.size() > 0 )
+with expansion:
+  42 > 0
+
+-------------------------------------------------------------------------------
+A Template product test case with array signature - std::array<int, 9>
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+  REQUIRE( x.size() > 0 )
+with expansion:
+  9 > 0
+
+-------------------------------------------------------------------------------
+A comparison that uses literals instead of the normal constructor
+-------------------------------------------------------------------------------
+Approx.tests.cpp:<line number>
+...............................................................................
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( d == 1.23_a )
+with expansion:
+  1.23 == Approx( 1.23 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( d != 1.22_a )
+with expansion:
+  1.23 != Approx( 1.22 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( -d == -1.23_a )
+with expansion:
+  -1.23 == Approx( -1.23 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( d == 1.2_a .epsilon(.1) )
+with expansion:
+  1.23 == Approx( 1.2 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( d != 1.2_a .epsilon(.001) )
+with expansion:
+  1.23 != Approx( 1.2 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( d == 1_a .epsilon(.3) )
+with expansion:
+  1.23 == Approx( 1.0 )
+
+-------------------------------------------------------------------------------
+A couple of nested sections followed by a failure
+  Outer
+  Inner
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+with message:
+  that's not flying - that's failing in style
+
+-------------------------------------------------------------------------------
+A couple of nested sections followed by a failure
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: FAILED:
+explicitly with message:
+  to infinity and beyond
+
+-------------------------------------------------------------------------------
+A failing expression with a non streamable type is still captured
+-------------------------------------------------------------------------------
+Tricky.tests.cpp:<line number>
+...............................................................................
+
+Tricky.tests.cpp:<line number>: FAILED:
+  CHECK( &o1 == &o2 )
+with expansion:
+  0x<hex digits> == 0x<hex digits>
+
+Tricky.tests.cpp:<line number>: FAILED:
+  CHECK( o1 == o2 )
+with expansion:
+  {?} == {?}
+
+-------------------------------------------------------------------------------
+Absolute margin
+-------------------------------------------------------------------------------
+Approx.tests.cpp:<line number>
+...............................................................................
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( 104.0 != Approx(100.0) )
+with expansion:
+  104.0 != Approx( 100.0 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( 104.0 == Approx(100.0).margin(5) )
+with expansion:
+  104.0 == Approx( 100.0 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( 104.0 == Approx(100.0).margin(4) )
+with expansion:
+  104.0 == Approx( 100.0 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( 104.0 != Approx(100.0).margin(3) )
+with expansion:
+  104.0 != Approx( 100.0 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( 100.3 != Approx(100.0) )
+with expansion:
+  100.3 != Approx( 100.0 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( 100.3 == Approx(100.0).margin(0.5) )
+with expansion:
+  100.3 == Approx( 100.0 )
+
+-------------------------------------------------------------------------------
+An empty test with no assertions
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+
+No assertions in test case 'An empty test with no assertions'
+
+-------------------------------------------------------------------------------
+An expression with side-effects should only be evaluated once
+-------------------------------------------------------------------------------
+Tricky.tests.cpp:<line number>
+...............................................................................
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE( i++ == 7 )
+with expansion:
+  7 == 7
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE( i++ == 8 )
+with expansion:
+  8 == 8
+
+-------------------------------------------------------------------------------
+An unchecked exception reports the line of the last assertion
+-------------------------------------------------------------------------------
+Exception.tests.cpp:<line number>
+...............................................................................
+
+Exception.tests.cpp:<line number>: PASSED:
+  CHECK( 1 == 1 )
+
+Exception.tests.cpp:<line number>: FAILED:
+  {Unknown expression after the reported line}
+due to unexpected exception with message:
+  unexpected exception
+
+-------------------------------------------------------------------------------
+Anonymous test case 1
+-------------------------------------------------------------------------------
+VariadicMacros.tests.cpp:<line number>
+...............................................................................
+
+VariadicMacros.tests.cpp:<line number>: PASSED:
+with message:
+  anonymous test case
+
+-------------------------------------------------------------------------------
+Approx setters validate their arguments
+-------------------------------------------------------------------------------
+Approx.tests.cpp:<line number>
+...............................................................................
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE_NOTHROW( Approx(0).margin(0) )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE_NOTHROW( Approx(0).margin(1234656) )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_AS( Approx(0).margin(-2), std::domain_error )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE_NOTHROW( Approx(0).epsilon(0) )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE_NOTHROW( Approx(0).epsilon(1) )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_AS( Approx(0).epsilon(-0.001), std::domain_error )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_AS( Approx(0).epsilon(1.0001), std::domain_error )
+
+-------------------------------------------------------------------------------
+Approx with exactly-representable margin
+-------------------------------------------------------------------------------
+Approx.tests.cpp:<line number>
+...............................................................................
+
+Approx.tests.cpp:<line number>: PASSED:
+  CHECK( 0.25f == Approx(0.0f).margin(0.25f) )
+with expansion:
+  0.25f == Approx( 0.0 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  CHECK( 0.0f == Approx(0.25f).margin(0.25f) )
+with expansion:
+  0.0f == Approx( 0.25 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  CHECK( 0.5f == Approx(0.25f).margin(0.25f) )
+with expansion:
+  0.5f == Approx( 0.25 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  CHECK( 245.0f == Approx(245.25f).margin(0.25f) )
+with expansion:
+  245.0f == Approx( 245.25 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  CHECK( 245.5f == Approx(245.25f).margin(0.25f) )
+with expansion:
+  245.5f == Approx( 245.25 )
+
+-------------------------------------------------------------------------------
+Approximate PI
+-------------------------------------------------------------------------------
+Approx.tests.cpp:<line number>
+...............................................................................
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( divide( 22, 7 ) == Approx( 3.141 ).epsilon( 0.001 ) )
+with expansion:
+  3.1428571429 == Approx( 3.141 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( divide( 22, 7 ) != Approx( 3.141 ).epsilon( 0.0001 ) )
+with expansion:
+  3.1428571429 != Approx( 3.141 )
+
+-------------------------------------------------------------------------------
+Approximate comparisons with different epsilons
+-------------------------------------------------------------------------------
+Approx.tests.cpp:<line number>
+...............................................................................
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( d != Approx( 1.231 ) )
+with expansion:
+  1.23 != Approx( 1.231 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( d == Approx( 1.231 ).epsilon( 0.1 ) )
+with expansion:
+  1.23 == Approx( 1.231 )
+
+-------------------------------------------------------------------------------
+Approximate comparisons with floats
+-------------------------------------------------------------------------------
+Approx.tests.cpp:<line number>
+...............................................................................
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( 1.23f == Approx( 1.23f ) )
+with expansion:
+  1.23f == Approx( 1.2300000191 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( 0.0f == Approx( 0.0f ) )
+with expansion:
+  0.0f == Approx( 0.0 )
+
+-------------------------------------------------------------------------------
+Approximate comparisons with ints
+-------------------------------------------------------------------------------
+Approx.tests.cpp:<line number>
+...............................................................................
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( 1 == Approx( 1 ) )
+with expansion:
+  1 == Approx( 1.0 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( 0 == Approx( 0 ) )
+with expansion:
+  0 == Approx( 0.0 )
+
+-------------------------------------------------------------------------------
+Approximate comparisons with mixed numeric types
+-------------------------------------------------------------------------------
+Approx.tests.cpp:<line number>
+...............................................................................
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( 1.0f == Approx( 1 ) )
+with expansion:
+  1.0f == Approx( 1.0 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( 0 == Approx( dZero) )
+with expansion:
+  0 == Approx( 0.0 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( 0 == Approx( dSmall ).margin( 0.001 ) )
+with expansion:
+  0 == Approx( 0.00001 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( 1.234f == Approx( dMedium ) )
+with expansion:
+  1.234f == Approx( 1.234 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( dMedium == Approx( 1.234f ) )
+with expansion:
+  1.234 == Approx( 1.2339999676 )
+
+-------------------------------------------------------------------------------
+Arbitrary predicate matcher
+  Function pointer
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1, Predicate<int>( alwaysTrue, "always true" ) )
+with expansion:
+  1 matches predicate: "always true"
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1, !Predicate<int>( alwaysFalse, "always false" ) )
+with expansion:
+  1 not matches predicate: "always false"
+
+-------------------------------------------------------------------------------
+Arbitrary predicate matcher
+  Lambdas + different type
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( "Hello olleH", Predicate<std::string>( []( std::string const& str ) -> bool { return str.front() == str.back(); }, "First and last character should be equal" ) )
+with expansion:
+  "Hello olleH" matches predicate: "First and last character should be equal"
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( "This wouldn't pass", !Predicate<std::string>( []( std::string const& str ) -> bool { return str.front() == str.back(); } ) )
+with expansion:
+  "This wouldn't pass" not matches undescribed predicate
+
+-------------------------------------------------------------------------------
+Assertion macros support bit operators and bool conversions
+-------------------------------------------------------------------------------
+Compilation.tests.cpp:<line number>
+...............................................................................
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE( lhs | rhs )
+with expansion:
+  Val: 1 | Val: 2
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( lhs & rhs )
+with expansion:
+  !(Val: 1 & Val: 2)
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE( HasBitOperators{ 1 } & HasBitOperators{ 1 } )
+with expansion:
+  Val: 1 & Val: 1
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE( lhs ^ rhs )
+with expansion:
+  Val: 1 ^ Val: 2
+
+Compilation.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( lhs ^ lhs )
+with expansion:
+  !(Val: 1 ^ Val: 1)
+
+-------------------------------------------------------------------------------
+Assertions then sections
+-------------------------------------------------------------------------------
+Tricky.tests.cpp:<line number>
+...............................................................................
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE( true )
+
+-------------------------------------------------------------------------------
+Assertions then sections
+  A section
+-------------------------------------------------------------------------------
+Tricky.tests.cpp:<line number>
+...............................................................................
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE( true )
+
+-------------------------------------------------------------------------------
+Assertions then sections
+  A section
+  Another section
+-------------------------------------------------------------------------------
+Tricky.tests.cpp:<line number>
+...............................................................................
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE( true )
+
+-------------------------------------------------------------------------------
+Assertions then sections
+-------------------------------------------------------------------------------
+Tricky.tests.cpp:<line number>
+...............................................................................
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE( true )
+
+-------------------------------------------------------------------------------
+Assertions then sections
+  A section
+-------------------------------------------------------------------------------
+Tricky.tests.cpp:<line number>
+...............................................................................
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE( true )
+
+-------------------------------------------------------------------------------
+Assertions then sections
+  A section
+  Another other section
+-------------------------------------------------------------------------------
+Tricky.tests.cpp:<line number>
+...............................................................................
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE( true )
+
+-------------------------------------------------------------------------------
+Basic use of the Contains range matcher
+  Different argument ranges, same element type, default comparison
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( a, Contains(1) )
+with expansion:
+  { 1, 2, 3 } contains element 1
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( b, Contains(1) )
+with expansion:
+  { 0, 1, 2 } contains element 1
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( c, !Contains(1) )
+with expansion:
+  { 4, 5, 6 } not contains element 1
+
+-------------------------------------------------------------------------------
+Basic use of the Contains range matcher
+  Different argument ranges, same element type, custom comparison
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( a, Contains(0, close_enough) )
+with expansion:
+  { 1, 2, 3 } contains element 0
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( b, Contains(0, close_enough) )
+with expansion:
+  { 0, 1, 2 } contains element 0
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( c, !Contains(0, close_enough) )
+with expansion:
+  { 4, 5, 6 } not contains element 0
+
+-------------------------------------------------------------------------------
+Basic use of the Contains range matcher
+  Different element type, custom comparisons
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( a, Contains(4, [](auto&& lhs, size_t sz) { return lhs.size() == sz; }) )
+with expansion:
+  { "abc", "abcd", "abcde" } contains element 4
+
+-------------------------------------------------------------------------------
+Basic use of the Contains range matcher
+  Can handle type that requires ADL-found free function begin and end
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( in, Contains(1) )
+with expansion:
+  { 1, 2, 3, 4, 5 } contains element 1
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( in, !Contains(8) )
+with expansion:
+  { 1, 2, 3, 4, 5 } not contains element 8
+
+-------------------------------------------------------------------------------
+Basic use of the Contains range matcher
+  Initialization with move only types
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( in, Contains(MoveOnlyTestElement{ 2 }) )
+with expansion:
+  { 1, 2, 3 } contains element 2
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( in, !Contains(MoveOnlyTestElement{ 9 }) )
+with expansion:
+  { 1, 2, 3 } not contains element 9
+
+-------------------------------------------------------------------------------
+Basic use of the Contains range matcher
+  Matching using matcher
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( in, Contains(Catch::Matchers::WithinAbs(0.5, 0.5)) )
+with expansion:
+  { 1.0, 2.0, 3.0, 0.0 } contains element matching is within 0.5 of 0.5
+
+-------------------------------------------------------------------------------
+Basic use of the Empty range matcher
+  Simple, std-provided containers
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( empty_array, IsEmpty() )
+with expansion:
+  {  } is empty
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( non_empty_array, !IsEmpty() )
+with expansion:
+  { 0.0 } not is empty
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( empty_vec, IsEmpty() )
+with expansion:
+  {  } is empty
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( non_empty_vec, !IsEmpty() )
+with expansion:
+  { 'a', 'b', 'c' } not is empty
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( inner_lists_are_empty, !IsEmpty() )
+with expansion:
+  { {  } } not is empty
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( inner_lists_are_empty.front(), IsEmpty() )
+with expansion:
+  {  } is empty
+
+-------------------------------------------------------------------------------
+Basic use of the Empty range matcher
+  Type with empty
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( has_empty{}, !IsEmpty() )
+with expansion:
+  {?} not is empty
+
+-------------------------------------------------------------------------------
+Basic use of the Empty range matcher
+  Type requires ADL found empty free function
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( unrelated::ADL_empty{}, IsEmpty() )
+with expansion:
+  {?} is empty
+
+-------------------------------------------------------------------------------
+CAPTURE can deal with complex expressions
+-------------------------------------------------------------------------------
+Message.tests.cpp:<line number>
+...............................................................................
+
+Message.tests.cpp:<line number>: PASSED:
+with messages:
+  a := 1
+  b := 2
+  c := 3
+  a + b := 3
+  a+b := 3
+  c > b := true
+  a == 1 := true
+
+-------------------------------------------------------------------------------
+CAPTURE can deal with complex expressions involving commas
+-------------------------------------------------------------------------------
+Message.tests.cpp:<line number>
+...............................................................................
+
+Message.tests.cpp:<line number>: PASSED:
+with messages:
+  std::vector<int>{1, 2, 3}[0, 1, 2] := 3
+  std::vector<int>{1, 2, 3}[(0, 1)] := 2
+  std::vector<int>{1, 2, 3}[0] := 1
+  (helper_1436<int, int>{12, -12}) := { 12, -12 }
+  (helper_1436<int, int>(-12, 12)) := { -12, 12 }
+  (1, 2) := 2
+  (2, 3) := 3
+
+-------------------------------------------------------------------------------
+CAPTURE parses string and character constants
+-------------------------------------------------------------------------------
+Message.tests.cpp:<line number>
+...............................................................................
+
+Message.tests.cpp:<line number>: PASSED:
+with messages:
+  ("comma, in string", "escaped, \", ") := "escaped, ", "
+  "single quote in string,'," := "single quote in string,',"
+  "some escapes, \\,\\\\" := "some escapes, \,\\"
+  "some, ), unmatched, } prenheses {[<" := "some, ), unmatched, } prenheses {[
+  <"
+  '"' := '"'
+  '\'' := '''
+  ',' := ','
+  '}' := '}'
+  ')' := ')'
+  '(' := '('
+  '{' := '{'
+
+-------------------------------------------------------------------------------
+Capture and info messages
+  Capture should stringify like assertions
+-------------------------------------------------------------------------------
+ToStringGeneral.tests.cpp:<line number>
+...............................................................................
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+  REQUIRE( true )
+with message:
+  i := 2
+
+-------------------------------------------------------------------------------
+Capture and info messages
+  Info should NOT stringify the way assertions do
+-------------------------------------------------------------------------------
+ToStringGeneral.tests.cpp:<line number>
+...............................................................................
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+  REQUIRE( true )
+with message:
+  3
+
+-------------------------------------------------------------------------------
+CaseInsensitiveEqualsTo is case insensitive
+  Degenerate cases
+-------------------------------------------------------------------------------
+Details.tests.cpp:<line number>
+...............................................................................
+
+Details.tests.cpp:<line number>: PASSED:
+  REQUIRE( eq( "", "" ) )
+with expansion:
+  true
+
+Details.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( eq( "", "a" ) )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+CaseInsensitiveEqualsTo is case insensitive
+  Plain comparisons
+-------------------------------------------------------------------------------
+Details.tests.cpp:<line number>
+...............................................................................
+
+Details.tests.cpp:<line number>: PASSED:
+  REQUIRE( eq( "a", "a" ) )
+with expansion:
+  true
+
+Details.tests.cpp:<line number>: PASSED:
+  REQUIRE( eq( "a", "A" ) )
+with expansion:
+  true
+
+Details.tests.cpp:<line number>: PASSED:
+  REQUIRE( eq( "A", "a" ) )
+with expansion:
+  true
+
+Details.tests.cpp:<line number>: PASSED:
+  REQUIRE( eq( "A", "A" ) )
+with expansion:
+  true
+
+Details.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( eq( "a", "b" ) )
+with expansion:
+  !false
+
+Details.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( eq( "a", "B" ) )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+CaseInsensitiveLess is case insensitive
+  Degenerate cases
+-------------------------------------------------------------------------------
+Details.tests.cpp:<line number>
+...............................................................................
+
+Details.tests.cpp:<line number>: PASSED:
+  REQUIRE( lt( "", "a" ) )
+with expansion:
+  true
+
+Details.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( lt( "a", "a" ) )
+with expansion:
+  !false
+
+Details.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( lt( "", "" ) )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+CaseInsensitiveLess is case insensitive
+  Plain comparisons
+-------------------------------------------------------------------------------
+Details.tests.cpp:<line number>
+...............................................................................
+
+Details.tests.cpp:<line number>: PASSED:
+  REQUIRE( lt( "a", "b" ) )
+with expansion:
+  true
+
+Details.tests.cpp:<line number>: PASSED:
+  REQUIRE( lt( "a", "B" ) )
+with expansion:
+  true
+
+Details.tests.cpp:<line number>: PASSED:
+  REQUIRE( lt( "A", "b" ) )
+with expansion:
+  true
+
+Details.tests.cpp:<line number>: PASSED:
+  REQUIRE( lt( "A", "B" ) )
+with expansion:
+  true
+
+-------------------------------------------------------------------------------
+Character pretty printing
+  Specifically escaped
+-------------------------------------------------------------------------------
+ToStringGeneral.tests.cpp:<line number>
+...............................................................................
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+  CHECK( tab == '\t' )
+with expansion:
+  '\t' == '\t'
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+  CHECK( newline == '\n' )
+with expansion:
+  '\n' == '\n'
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+  CHECK( carr_return == '\r' )
+with expansion:
+  '\r' == '\r'
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+  CHECK( form_feed == '\f' )
+with expansion:
+  '\f' == '\f'
+
+-------------------------------------------------------------------------------
+Character pretty printing
+  General chars
+-------------------------------------------------------------------------------
+ToStringGeneral.tests.cpp:<line number>
+...............................................................................
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+  CHECK( space == ' ' )
+with expansion:
+  ' ' == ' '
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+  REQUIRE( c == chars[i] )
+with expansion:
+  'a' == 'a'
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+  REQUIRE( c == chars[i] )
+with expansion:
+  'z' == 'z'
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+  REQUIRE( c == chars[i] )
+with expansion:
+  'A' == 'A'
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+  REQUIRE( c == chars[i] )
+with expansion:
+  'Z' == 'Z'
+
+-------------------------------------------------------------------------------
+Character pretty printing
+  Low ASCII
+-------------------------------------------------------------------------------
+ToStringGeneral.tests.cpp:<line number>
+...............................................................................
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+  CHECK( null_terminator == '\0' )
+with expansion:
+  0 == 0
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+  REQUIRE( c == i )
+with expansion:
+  2 == 2
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+  REQUIRE( c == i )
+with expansion:
+  3 == 3
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+  REQUIRE( c == i )
+with expansion:
+  4 == 4
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+  REQUIRE( c == i )
+with expansion:
+  5 == 5
+
+-------------------------------------------------------------------------------
+Clara::Arg supports single-arg parse the way Opt does
+-------------------------------------------------------------------------------
+Clara.tests.cpp:<line number>
+...............................................................................
+
+Clara.tests.cpp:<line number>: PASSED:
+  CHECK( name.empty() )
+with expansion:
+  true
+
+Clara.tests.cpp:<line number>: PASSED:
+  REQUIRE( name == "foo" )
+with expansion:
+  "foo" == "foo"
+
+-------------------------------------------------------------------------------
+Clara::Opt supports accept-many lambdas
+  Parsing fails on multiple options without accept_many
+-------------------------------------------------------------------------------
+Clara.tests.cpp:<line number>
+...............................................................................
+
+Clara.tests.cpp:<line number>: PASSED:
+  CHECK_FALSE( parse_result )
+with expansion:
+  !{?}
+
+-------------------------------------------------------------------------------
+Clara::Opt supports accept-many lambdas
+  Parsing succeeds on multiple options with accept_many
+-------------------------------------------------------------------------------
+Clara.tests.cpp:<line number>
+...............................................................................
+
+Clara.tests.cpp:<line number>: PASSED:
+  CHECK( parse_result )
+with expansion:
+  {?}
+
+Clara.tests.cpp:<line number>: PASSED:
+  CHECK( res == std::vector<std::string>{ "aaa", "bbb" } )
+with expansion:
+  { "aaa", "bbb" } == { "aaa", "bbb" }
+
+-------------------------------------------------------------------------------
+Combining MatchAllOfGeneric does not nest
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+with message:
+  std::is_same< decltype( ( MatcherA() && MatcherB() ) && MatcherC() ), Catch::
+  Matchers::Detail:: MatchAllOfGeneric<MatcherA, MatcherB, MatcherC>>::value
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1, ( MatcherA() && MatcherB() ) && MatcherC() )
+with expansion:
+  1 ( equals: (int) 1 or (float) 1.0f and equals: (long long) 1 and equals: (T)
+  1 )
+
+Matchers.tests.cpp:<line number>: PASSED:
+with message:
+  std::is_same< decltype( MatcherA() && ( MatcherB() && MatcherC() ) ), Catch::
+  Matchers::Detail:: MatchAllOfGeneric<MatcherA, MatcherB, MatcherC>>::value
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1, MatcherA() && ( MatcherB() && MatcherC() ) )
+with expansion:
+  1 ( equals: (int) 1 or (float) 1.0f and equals: (long long) 1 and equals: (T)
+  1 )
+
+Matchers.tests.cpp:<line number>: PASSED:
+with message:
+  std::is_same< decltype( ( MatcherA() && MatcherB() ) && ( MatcherC() &&
+  MatcherD() ) ), Catch::Matchers::Detail:: MatchAllOfGeneric<MatcherA,
+  MatcherB, MatcherC, MatcherD>>:: value
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1, ( MatcherA() && MatcherB() ) && ( MatcherC() && MatcherD() ) )
+with expansion:
+  1 ( equals: (int) 1 or (float) 1.0f and equals: (long long) 1 and equals: (T)
+  1 and equals: true )
+
+-------------------------------------------------------------------------------
+Combining MatchAnyOfGeneric does not nest
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+with message:
+  std::is_same< decltype( ( MatcherA() || MatcherB() ) || MatcherC() ), Catch::
+  Matchers::Detail:: MatchAnyOfGeneric<MatcherA, MatcherB, MatcherC>>::value
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1, ( MatcherA() || MatcherB() ) || MatcherC() )
+with expansion:
+  1 ( equals: (int) 1 or (float) 1.0f or equals: (long long) 1 or equals: (T) 1
+  )
+
+Matchers.tests.cpp:<line number>: PASSED:
+with message:
+  std::is_same< decltype( MatcherA() || ( MatcherB() || MatcherC() ) ), Catch::
+  Matchers::Detail:: MatchAnyOfGeneric<MatcherA, MatcherB, MatcherC>>::value
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1, MatcherA() || ( MatcherB() || MatcherC() ) )
+with expansion:
+  1 ( equals: (int) 1 or (float) 1.0f or equals: (long long) 1 or equals: (T) 1
+  )
+
+Matchers.tests.cpp:<line number>: PASSED:
+with message:
+  std::is_same< decltype( ( MatcherA() || MatcherB() ) || ( MatcherC() ||
+  MatcherD() ) ), Catch::Matchers::Detail:: MatchAnyOfGeneric<MatcherA,
+  MatcherB, MatcherC, MatcherD>>:: value
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1, ( MatcherA() || MatcherB() ) || ( MatcherC() || MatcherD() ) )
+with expansion:
+  1 ( equals: (int) 1 or (float) 1.0f or equals: (long long) 1 or equals: (T) 1
+  or equals: true )
+
+-------------------------------------------------------------------------------
+Combining MatchNotOfGeneric does not nest
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+with message:
+  std::is_same< decltype( !MatcherA() ), Catch::Matchers::Detail::
+  MatchNotOfGeneric<MatcherA>>::value
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 0, !MatcherA() )
+with expansion:
+  0 not equals: (int) 1 or (float) 1.0f
+
+Matchers.tests.cpp:<line number>: PASSED:
+with message:
+  std::is_same<decltype( !!MatcherA() ), MatcherA const&>::value
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1, !!MatcherA() )
+with expansion:
+  1 equals: (int) 1 or (float) 1.0f
+
+Matchers.tests.cpp:<line number>: PASSED:
+with message:
+  std::is_same< decltype( !!!MatcherA() ), Catch::Matchers::Detail::
+  MatchNotOfGeneric<MatcherA>>::value
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 0, !!!MatcherA() )
+with expansion:
+  0 not equals: (int) 1 or (float) 1.0f
+
+Matchers.tests.cpp:<line number>: PASSED:
+with message:
+  std::is_same<decltype( !!!!MatcherA() ), MatcherA const&>::value
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1, !!!!MatcherA() )
+with expansion:
+  1 equals: (int) 1 or (float) 1.0f
+
+-------------------------------------------------------------------------------
+Combining concrete matchers does not use templated matchers
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+with message:
+  std::is_same<decltype( StartsWith( "foo" ) || ( StartsWith( "bar" ) &&
+  EndsWith( "bar" ) && !EndsWith( "foo" ) ) ), Catch::Matchers::Detail::
+  MatchAnyOf<std::string>>::value
+
+-------------------------------------------------------------------------------
+Combining only templated matchers
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+with message:
+  std::is_same<decltype( MatcherA() || MatcherB() ), Catch::Matchers::Detail::
+  MatchAnyOfGeneric<MatcherA, MatcherB>>::value
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1, MatcherA() || MatcherB() )
+with expansion:
+  1 ( equals: (int) 1 or (float) 1.0f or equals: (long long) 1 )
+
+Matchers.tests.cpp:<line number>: PASSED:
+with message:
+  std::is_same<decltype( MatcherA() && MatcherB() ), Catch::Matchers::Detail::
+  MatchAllOfGeneric<MatcherA, MatcherB>>::value
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1, MatcherA() && MatcherB() )
+with expansion:
+  1 ( equals: (int) 1 or (float) 1.0f and equals: (long long) 1 )
+
+Matchers.tests.cpp:<line number>: PASSED:
+with message:
+  std::is_same< decltype( MatcherA() || !MatcherB() ), Catch::Matchers::Detail:
+  :MatchAnyOfGeneric< MatcherA, Catch::Matchers::Detail::MatchNotOfGeneric
+  <MatcherB>>>::value
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1, MatcherA() || !MatcherB() )
+with expansion:
+  1 ( equals: (int) 1 or (float) 1.0f or not equals: (long long) 1 )
+
+-------------------------------------------------------------------------------
+Combining templated and concrete matchers
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( vec, Predicate<std::vector<int>>( []( auto const& v ) { return std::all_of( v.begin(), v.end(), []( int elem ) { return elem % 2 == 1; } ); }, "All elements are odd" ) && !EqualsRange( a ) )
+with expansion:
+  { 1, 3, 5 } ( matches predicate: "All elements are odd" and not Equals: { 5,
+  3, 1 } )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( str, StartsWith( "foo" ) && EqualsRange( arr ) && EndsWith( "bar" ) )
+with expansion:
+  "foobar" ( starts with: "foo" and Equals: { 'f', 'o', 'o', 'b', 'a', 'r' }
+  and ends with: "bar" )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( str, StartsWith( "foo" ) && !EqualsRange( bad_arr ) && EndsWith( "bar" ) )
+with expansion:
+  "foobar" ( starts with: "foo" and not Equals: { 'o', 'o', 'f', 'b', 'a', 'r'
+  } and ends with: "bar" )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( str, EqualsRange( arr ) && StartsWith( "foo" ) && EndsWith( "bar" ) )
+with expansion:
+  "foobar" ( Equals: { 'f', 'o', 'o', 'b', 'a', 'r' } and starts with: "foo"
+  and ends with: "bar" )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( str, !EqualsRange( bad_arr ) && StartsWith( "foo" ) && EndsWith( "bar" ) )
+with expansion:
+  "foobar" ( not Equals: { 'o', 'o', 'f', 'b', 'a', 'r' } and starts with:
+  "foo" and ends with: "bar" )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( str, EqualsRange( bad_arr ) || ( StartsWith( "foo" ) && EndsWith( "bar" ) ) )
+with expansion:
+  "foobar" ( Equals: { 'o', 'o', 'f', 'b', 'a', 'r' } or ( starts with: "foo"
+  and ends with: "bar" ) )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( str, ( StartsWith( "foo" ) && EndsWith( "bar" ) ) || EqualsRange( bad_arr ) )
+with expansion:
+  "foobar" ( ( starts with: "foo" and ends with: "bar" ) or Equals: { 'o', 'o',
+  'f', 'b', 'a', 'r' } )
+
+-------------------------------------------------------------------------------
+Combining templated matchers
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( container, EqualsRange( a ) || EqualsRange( b ) || EqualsRange( c ) )
+with expansion:
+  { 1, 2, 3 } ( Equals: { 1, 2, 3 } or Equals: { 0, 1, 2 } or Equals: { 4, 5, 6
+  } )
+
+-------------------------------------------------------------------------------
+Commas in various macros are allowed
+-------------------------------------------------------------------------------
+Tricky.tests.cpp:<line number>
+...............................................................................
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS( std::vector<constructor_throws>{constructor_throws{}, constructor_throws{}} )
+
+Tricky.tests.cpp:<line number>: PASSED:
+  CHECK_THROWS( std::vector<constructor_throws>{constructor_throws{}, constructor_throws{}} )
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE_NOTHROW( std::vector<int>{1, 2, 3} == std::vector<int>{1, 2, 3} )
+
+Tricky.tests.cpp:<line number>: PASSED:
+  CHECK_NOTHROW( std::vector<int>{1, 2, 3} == std::vector<int>{1, 2, 3} )
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE( std::vector<int>{1, 2} == std::vector<int>{1, 2} )
+with expansion:
+  { 1, 2 } == { 1, 2 }
+
+Tricky.tests.cpp:<line number>: PASSED:
+  CHECK( std::vector<int>{1, 2} == std::vector<int>{1, 2} )
+with expansion:
+  { 1, 2 } == { 1, 2 }
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( std::vector<int>{1, 2} == std::vector<int>{1, 2, 3} )
+with expansion:
+  !({ 1, 2 } == { 1, 2, 3 })
+
+Tricky.tests.cpp:<line number>: PASSED:
+  CHECK_FALSE( std::vector<int>{1, 2} == std::vector<int>{1, 2, 3} )
+with expansion:
+  !({ 1, 2 } == { 1, 2, 3 })
+
+Tricky.tests.cpp:<line number>: PASSED:
+  CHECK_NOFAIL( std::vector<int>{1, 2} == std::vector<int>{1, 2} )
+with expansion:
+  { 1, 2 } == { 1, 2 }
+
+Tricky.tests.cpp:<line number>: PASSED:
+  CHECKED_IF( std::vector<int>{1, 2} == std::vector<int>{1, 2} )
+with expansion:
+  { 1, 2 } == { 1, 2 }
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE( true )
+
+Tricky.tests.cpp:<line number>: PASSED:
+  CHECKED_ELSE( std::vector<int>{1, 2} == std::vector<int>{1, 2} )
+with expansion:
+  { 1, 2 } == { 1, 2 }
+
+-------------------------------------------------------------------------------
+Comparing function pointers
+-------------------------------------------------------------------------------
+Tricky.tests.cpp:<line number>
+...............................................................................
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE( a )
+with expansion:
+  0x<hex digits>
+
+Tricky.tests.cpp:<line number>: PASSED:
+  REQUIRE( a == &foo )
+with expansion:
+  0x<hex digits> == 0x<hex digits>
+
+-------------------------------------------------------------------------------
+Comparison ops
+-------------------------------------------------------------------------------
+RandomNumberGeneration.tests.cpp:<line number>
+...............................................................................
+
+RandomNumberGeneration.tests.cpp:<line number>: PASSED:
+  REQUIRE( SimplePcg32{} == SimplePcg32{} )
+with expansion:
+  {?} == {?}
+
+RandomNumberGeneration.tests.cpp:<line number>: PASSED:
+  REQUIRE( SimplePcg32{ 0 } != SimplePcg32{} )
+with expansion:
+  {?} != {?}
+
+RandomNumberGeneration.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( SimplePcg32{ 1 } == SimplePcg32{ 2 } )
+with expansion:
+  !({?} == {?})
+
+RandomNumberGeneration.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( SimplePcg32{ 1 } != SimplePcg32{ 1 } )
+with expansion:
+  !({?} != {?})
+
+-------------------------------------------------------------------------------
+Comparison with explicitly convertible types
+-------------------------------------------------------------------------------
+Approx.tests.cpp:<line number>
+...............................................................................
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( td == Approx(10.0) )
+with expansion:
+  StrongDoubleTypedef(10) == Approx( 10.0 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( Approx(10.0) == td )
+with expansion:
+  Approx( 10.0 ) == StrongDoubleTypedef(10)
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( td != Approx(11.0) )
+with expansion:
+  StrongDoubleTypedef(10) != Approx( 11.0 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( Approx(11.0) != td )
+with expansion:
+  Approx( 11.0 ) != StrongDoubleTypedef(10)
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( td <= Approx(10.0) )
+with expansion:
+  StrongDoubleTypedef(10) <= Approx( 10.0 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( td <= Approx(11.0) )
+with expansion:
+  StrongDoubleTypedef(10) <= Approx( 11.0 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( Approx(10.0) <= td )
+with expansion:
+  Approx( 10.0 ) <= StrongDoubleTypedef(10)
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( Approx(9.0) <= td )
+with expansion:
+  Approx( 9.0 ) <= StrongDoubleTypedef(10)
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( td >= Approx(9.0) )
+with expansion:
+  StrongDoubleTypedef(10) >= Approx( 9.0 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( td >= Approx(td) )
+with expansion:
+  StrongDoubleTypedef(10) >= Approx( 10.0 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( Approx(td) >= td )
+with expansion:
+  Approx( 10.0 ) >= StrongDoubleTypedef(10)
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( Approx(11.0) >= td )
+with expansion:
+  Approx( 11.0 ) >= StrongDoubleTypedef(10)
+
+-------------------------------------------------------------------------------
+Comparisons between ints where one side is computed
+-------------------------------------------------------------------------------
+Condition.tests.cpp:<line number>
+...............................................................................
+
+Condition.tests.cpp:<line number>: PASSED:
+  CHECK( 54 == 6*9 )
+with expansion:
+  54 == 54
+
+-------------------------------------------------------------------------------
+Comparisons between unsigned ints and negative signed ints match c++ standard
+behaviour
+-------------------------------------------------------------------------------
+Condition.tests.cpp:<line number>
+...............................................................................
+
+Condition.tests.cpp:<line number>: PASSED:
+  CHECK( ( -1 > 2u ) )
+with expansion:
+  true
+
+Condition.tests.cpp:<line number>: PASSED:
+  CHECK( -1 > 2u )
+with expansion:
+  -1 > 2
+
+Condition.tests.cpp:<line number>: PASSED:
+  CHECK( ( 2u < -1 ) )
+with expansion:
+  true
+
+Condition.tests.cpp:<line number>: PASSED:
+  CHECK( 2u < -1 )
+with expansion:
+  2 < -1
+
+Condition.tests.cpp:<line number>: PASSED:
+  CHECK( ( minInt > 2u ) )
+with expansion:
+  true
+
+Condition.tests.cpp:<line number>: PASSED:
+  CHECK( minInt > 2u )
+with expansion:
+  -2147483648 > 2
+
+-------------------------------------------------------------------------------
+Comparisons with int literals don't warn when mixing signed/ unsigned
+-------------------------------------------------------------------------------
+Condition.tests.cpp:<line number>
+...............................................................................
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( i == 1 )
+with expansion:
+  1 == 1
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( ui == 2 )
+with expansion:
+  2 == 2
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( l == 3 )
+with expansion:
+  3 == 3
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( ul == 4 )
+with expansion:
+  4 == 4
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( c == 5 )
+with expansion:
+  5 == 5
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( uc == 6 )
+with expansion:
+  6 == 6
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( 1 == i )
+with expansion:
+  1 == 1
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( 2 == ui )
+with expansion:
+  2 == 2
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( 3 == l )
+with expansion:
+  3 == 3
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( 4 == ul )
+with expansion:
+  4 == 4
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( 5 == c )
+with expansion:
+  5 == 5
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( 6 == uc )
+with expansion:
+  6 == 6
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( (std::numeric_limits<uint32_t>::max)() > ul )
+with expansion:
+  4294967295 (0x<hex digits>) > 4
+
+-------------------------------------------------------------------------------
+Composed generic matchers shortcircuit
+  MatchAllOf
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  CHECK_FALSE( matcher.match( 1 ) )
+with expansion:
+  !false
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE( first.matchCalled )
+with expansion:
+  true
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE( !second.matchCalled )
+with expansion:
+  true
+
+-------------------------------------------------------------------------------
+Composed generic matchers shortcircuit
+  MatchAnyOf
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  CHECK( matcher.match( 1 ) )
+with expansion:
+  true
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE( first.matchCalled )
+with expansion:
+  true
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE( !second.matchCalled )
+with expansion:
+  true
+
+-------------------------------------------------------------------------------
+Composed matchers shortcircuit
+  MatchAllOf
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  CHECK_FALSE( matcher.match( 1 ) )
+with expansion:
+  !false
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE( first.matchCalled )
+with expansion:
+  true
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE( !second.matchCalled )
+with expansion:
+  true
+
+-------------------------------------------------------------------------------
+Composed matchers shortcircuit
+  MatchAnyOf
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  CHECK( matcher.match( 1 ) )
+with expansion:
+  true
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE( first.matchCalled )
+with expansion:
+  true
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE( !second.matchCalled )
+with expansion:
+  true
+
+-------------------------------------------------------------------------------
+Contains string matcher
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: FAILED:
+  CHECK_THAT( testStringForMatching(), ContainsSubstring( "not there", Catch::CaseSensitive::No ) )
+with expansion:
+  "this string contains 'abc' as a substring" contains: "not there" (case
+  insensitive)
+
+Matchers.tests.cpp:<line number>: FAILED:
+  CHECK_THAT( testStringForMatching(), ContainsSubstring( "STRING" ) )
+with expansion:
+  "this string contains 'abc' as a substring" contains: "STRING"
+
+-------------------------------------------------------------------------------
+Copy and then generate a range
+  from var and iterators
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( elem % 2 == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+Copy and then generate a range
+  from var and iterators
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( elem % 2 == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+Copy and then generate a range
+  from var and iterators
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( elem % 2 == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+Copy and then generate a range
+  from var and iterators
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( elem % 2 == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+Copy and then generate a range
+  from var and iterators
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( elem % 2 == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+Copy and then generate a range
+  from var and iterators
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( elem % 2 == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+Copy and then generate a range
+  From a temporary container
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( elem % 2 == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+Copy and then generate a range
+  From a temporary container
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( elem % 2 == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+Copy and then generate a range
+  From a temporary container
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( elem % 2 == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+Copy and then generate a range
+  From a temporary container
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( elem % 2 == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+Copy and then generate a range
+  From a temporary container
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( elem % 2 == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+Copy and then generate a range
+  From a temporary container
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( elem % 2 == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+Copy and then generate a range
+  Final validation
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( call_count == 1 )
+with expansion:
+  1 == 1
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( make_data().size() == test_count )
+with expansion:
+  6 == 6
+
+-------------------------------------------------------------------------------
+Custom exceptions can be translated when testing for nothrow
+-------------------------------------------------------------------------------
+Exception.tests.cpp:<line number>
+...............................................................................
+
+Exception.tests.cpp:<line number>: FAILED:
+  REQUIRE_NOTHROW( throwCustom() )
+due to unexpected exception with message:
+  custom exception - not std
+
+-------------------------------------------------------------------------------
+Custom exceptions can be translated when testing for throwing as something else
+-------------------------------------------------------------------------------
+Exception.tests.cpp:<line number>
+...............................................................................
+
+Exception.tests.cpp:<line number>: FAILED:
+  REQUIRE_THROWS_AS( throwCustom(), std::exception )
+due to unexpected exception with message:
+  custom exception - not std
+
+-------------------------------------------------------------------------------
+Custom std-exceptions can be custom translated
+-------------------------------------------------------------------------------
+Exception.tests.cpp:<line number>
+...............................................................................
+
+Exception.tests.cpp:<line number>: FAILED:
+due to unexpected exception with message:
+  custom std exception
+
+-------------------------------------------------------------------------------
+Default scale is invisible to comparison
+-------------------------------------------------------------------------------
+Approx.tests.cpp:<line number>
+...............................................................................
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( 101.000001 != Approx(100).epsilon(0.01) )
+with expansion:
+  101.000001 != Approx( 100.0 )
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( std::pow(10, -5) != Approx(std::pow(10, -7)) )
+with expansion:
+  0.00001 != Approx( 0.0000001 )
+
+-------------------------------------------------------------------------------
+Directly creating an EnumInfo
+-------------------------------------------------------------------------------
+ToString.tests.cpp:<line number>
+...............................................................................
+
+ToString.tests.cpp:<line number>: PASSED:
+  CHECK( enumInfo->lookup(0) == "Value1" )
+with expansion:
+  Value1 == "Value1"
+
+ToString.tests.cpp:<line number>: PASSED:
+  CHECK( enumInfo->lookup(1) == "Value2" )
+with expansion:
+  Value2 == "Value2"
+
+ToString.tests.cpp:<line number>: PASSED:
+  CHECK( enumInfo->lookup(3) == "{** unexpected enum value **}" )
+with expansion:
+  {** unexpected enum value **}
+  ==
+  "{** unexpected enum value **}"
+
+-------------------------------------------------------------------------------
+Empty tag is not allowed
+-------------------------------------------------------------------------------
+Tag.tests.cpp:<line number>
+...............................................................................
+
+Tag.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS( Catch::TestCaseInfo( "", { "fake test name", "[]" }, dummySourceLineInfo ) )
+
+-------------------------------------------------------------------------------
+EndsWith string matcher
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: FAILED:
+  CHECK_THAT( testStringForMatching(), EndsWith( "Substring" ) )
+with expansion:
+  "this string contains 'abc' as a substring" ends with: "Substring"
+
+Matchers.tests.cpp:<line number>: FAILED:
+  CHECK_THAT( testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No ) )
+with expansion:
+  "this string contains 'abc' as a substring" ends with: "this" (case
+  insensitive)
+
+-------------------------------------------------------------------------------
+Enums can quickly have stringification enabled using REGISTER_ENUM
+-------------------------------------------------------------------------------
+EnumToString.tests.cpp:<line number>
+...............................................................................
+
+EnumToString.tests.cpp:<line number>: PASSED:
+  REQUIRE( stringify( EnumClass3::Value1 ) == "Value1" )
+with expansion:
+  "Value1" == "Value1"
+
+EnumToString.tests.cpp:<line number>: PASSED:
+  REQUIRE( stringify( EnumClass3::Value2 ) == "Value2" )
+with expansion:
+  "Value2" == "Value2"
+
+EnumToString.tests.cpp:<line number>: PASSED:
+  REQUIRE( stringify( EnumClass3::Value3 ) == "Value3" )
+with expansion:
+  "Value3" == "Value3"
+
+EnumToString.tests.cpp:<line number>: PASSED:
+  REQUIRE( stringify( EnumClass3::Value4 ) == "{** unexpected enum value **}" )
+with expansion:
+  "{** unexpected enum value **}"
+  ==
+  "{** unexpected enum value **}"
+
+EnumToString.tests.cpp:<line number>: PASSED:
+  REQUIRE( stringify( ec3 ) == "Value2" )
+with expansion:
+  "Value2" == "Value2"
+
+-------------------------------------------------------------------------------
+Enums in namespaces can quickly have stringification enabled using
+REGISTER_ENUM
+-------------------------------------------------------------------------------
+EnumToString.tests.cpp:<line number>
+...............................................................................
+
+EnumToString.tests.cpp:<line number>: PASSED:
+  REQUIRE( stringify( Bikeshed::Colours::Red ) == "Red" )
+with expansion:
+  "Red" == "Red"
+
+EnumToString.tests.cpp:<line number>: PASSED:
+  REQUIRE( stringify( Bikeshed::Colours::Blue ) == "Blue" )
+with expansion:
+  "Blue" == "Blue"
+
+-------------------------------------------------------------------------------
+Epsilon only applies to Approx's value
+-------------------------------------------------------------------------------
+Approx.tests.cpp:<line number>
+...............................................................................
+
+Approx.tests.cpp:<line number>: PASSED:
+  REQUIRE( 101.01 != Approx(100).epsilon(0.01) )
+with expansion:
+  101.01 != Approx( 100.0 )
+
+-------------------------------------------------------------------------------
+Equality checks that should fail
+-------------------------------------------------------------------------------
+Condition.tests.cpp:<line number>
+...............................................................................
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK( data.int_seven == 6 )
+with expansion:
+  7 == 6
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK( data.int_seven == 8 )
+with expansion:
+  7 == 8
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK( data.int_seven == 0 )
+with expansion:
+  7 == 0
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK( data.float_nine_point_one == Approx( 9.11f ) )
+with expansion:
+  9.1f == Approx( 9.1099996567 )
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK( data.float_nine_point_one == Approx( 9.0f ) )
+with expansion:
+  9.1f == Approx( 9.0 )
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK( data.float_nine_point_one == Approx( 1 ) )
+with expansion:
+  9.1f == Approx( 1.0 )
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK( data.float_nine_point_one == Approx( 0 ) )
+with expansion:
+  9.1f == Approx( 0.0 )
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK( data.double_pi == Approx( 3.1415 ) )
+with expansion:
+  3.1415926535 == Approx( 3.1415 )
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK( data.str_hello == "goodbye" )
+with expansion:
+  "hello" == "goodbye"
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK( data.str_hello == "hell" )
+with expansion:
+  "hello" == "hell"
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK( data.str_hello == "hello1" )
+with expansion:
+  "hello" == "hello1"
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK( data.str_hello.size() == 6 )
+with expansion:
+  5 == 6
+
+Condition.tests.cpp:<line number>: FAILED:
+  CHECK( x == Approx( 1.301 ) )
+with expansion:
+  1.3 == Approx( 1.301 )
+
+-------------------------------------------------------------------------------
+Equality checks that should succeed
+-------------------------------------------------------------------------------
+Condition.tests.cpp:<line number>
+...............................................................................
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( data.int_seven == 7 )
+with expansion:
+  7 == 7
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( data.float_nine_point_one == Approx( 9.1f ) )
+with expansion:
+  9.1f == Approx( 9.1000003815 )
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( data.double_pi == Approx( 3.1415926535 ) )
+with expansion:
+  3.1415926535 == Approx( 3.1415926535 )
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( data.str_hello == "hello" )
+with expansion:
+  "hello" == "hello"
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( "hello" == data.str_hello )
+with expansion:
+  "hello" == "hello"
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( data.str_hello.size() == 5 )
+with expansion:
+  5 == 5
+
+Condition.tests.cpp:<line number>: PASSED:
+  REQUIRE( x == Approx( 1.3 ) )
+with expansion:
+  1.3 == Approx( 1.3 )
+
+-------------------------------------------------------------------------------
+Equals
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  CHECK_THAT( testStringForMatching(), Equals( "this string contains 'abc' as a substring" ) )
+with expansion:
+  "this string contains 'abc' as a substring" equals: "this string contains
+  'abc' as a substring"
+
+Matchers.tests.cpp:<line number>: PASSED:
+  CHECK_THAT( testStringForMatching(), Equals( "this string contains 'ABC' as a substring", Catch::CaseSensitive::No ) )
+with expansion:
+  "this string contains 'abc' as a substring" equals: "this string contains
+  'abc' as a substring" (case insensitive)
+
+-------------------------------------------------------------------------------
+Equals string matcher
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: FAILED:
+  CHECK_THAT( testStringForMatching(), Equals( "this string contains 'ABC' as a substring" ) )
+with expansion:
+  "this string contains 'abc' as a substring" equals: "this string contains
+  'ABC' as a substring"
+
+Matchers.tests.cpp:<line number>: FAILED:
+  CHECK_THAT( testStringForMatching(), Equals( "something else", Catch::CaseSensitive::No ) )
+with expansion:
+  "this string contains 'abc' as a substring" equals: "something else" (case
+  insensitive)
+
+-------------------------------------------------------------------------------
+Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified
+-------------------------------------------------------------------------------
+ToStringGeneral.tests.cpp:<line number>
+...............................................................................
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+  REQUIRE( ::Catch::Detail::stringify(WhatException{}) == "This exception has overridden what() method" )
+with expansion:
+  "This exception has overridden what() method"
+  ==
+  "This exception has overridden what() method"
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+  REQUIRE( ::Catch::Detail::stringify(OperatorException{}) == "OperatorException" )
+with expansion:
+  "OperatorException" == "OperatorException"
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+  REQUIRE( ::Catch::Detail::stringify(StringMakerException{}) == "StringMakerException" )
+with expansion:
+  "StringMakerException"
+  ==
+  "StringMakerException"
+
+-------------------------------------------------------------------------------
+Exception matchers that fail
+  No exception
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: FAILED:
+  CHECK_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )
+because no exception was thrown where one was expected:
+
+Matchers.tests.cpp:<line number>: FAILED:
+  REQUIRE_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )
+because no exception was thrown where one was expected:
+
+-------------------------------------------------------------------------------
+Exception matchers that fail
+  Type mismatch
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: FAILED:
+  CHECK_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )
+due to unexpected exception with message:
+  Unknown exception
+
+Matchers.tests.cpp:<line number>: FAILED:
+  REQUIRE_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )
+due to unexpected exception with message:
+  Unknown exception
+
+-------------------------------------------------------------------------------
+Exception matchers that fail
+  Contents are wrong
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: FAILED:
+  CHECK_THROWS_MATCHES( throwsSpecialException( 3 ), SpecialException, ExceptionMatcher{ 1 } )
+with expansion:
+  SpecialException::what special exception has value of 1
+
+Matchers.tests.cpp:<line number>: FAILED:
+  REQUIRE_THROWS_MATCHES( throwsSpecialException( 4 ), SpecialException, ExceptionMatcher{ 1 } )
+with expansion:
+  SpecialException::what special exception has value of 1
+
+-------------------------------------------------------------------------------
+Exception matchers that succeed
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  CHECK_THROWS_MATCHES( throwsSpecialException( 1 ), SpecialException, ExceptionMatcher{ 1 } )
+with expansion:
+  SpecialException::what special exception has value of 1
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_MATCHES( throwsSpecialException( 2 ), SpecialException, ExceptionMatcher{ 2 } )
+with expansion:
+  SpecialException::what special exception has value of 2
+
+-------------------------------------------------------------------------------
+Exception messages can be tested for
+  exact match
+-------------------------------------------------------------------------------
+Exception.tests.cpp:<line number>
+...............................................................................
+
+Exception.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_WITH( thisThrows(), "expected exception" )
+with expansion:
+  "expected exception" equals: "expected exception"
+
+-------------------------------------------------------------------------------
+Exception messages can be tested for
+  different case
+-------------------------------------------------------------------------------
+Exception.tests.cpp:<line number>
+...............................................................................
+
+Exception.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_WITH( thisThrows(), Equals( "expecteD Exception", Catch::CaseSensitive::No ) )
+with expansion:
+  "expected exception" equals: "expected exception" (case insensitive)
+
+-------------------------------------------------------------------------------
+Exception messages can be tested for
+  wildcarded
+-------------------------------------------------------------------------------
+Exception.tests.cpp:<line number>
+...............................................................................
+
+Exception.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_WITH( thisThrows(), StartsWith( "expected" ) )
+with expansion:
+  "expected exception" starts with: "expected"
+
+Exception.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_WITH( thisThrows(), EndsWith( "exception" ) )
+with expansion:
+  "expected exception" ends with: "exception"
+
+Exception.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_WITH( thisThrows(), ContainsSubstring( "except" ) )
+with expansion:
+  "expected exception" contains: "except"
+
+Exception.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_WITH( thisThrows(), ContainsSubstring( "exCept", Catch::CaseSensitive::No ) )
+with expansion:
+  "expected exception" contains: "except" (case insensitive)
+
+-------------------------------------------------------------------------------
+Exceptions matchers
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_MATCHES( throwsDerivedException(), DerivedException, Message( "DerivedException::what" ) )
+with expansion:
+  DerivedException::what exception message matches "DerivedException::what"
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_MATCHES( throwsDerivedException(), DerivedException, !Message( "derivedexception::what" ) )
+with expansion:
+  DerivedException::what not exception message matches "derivedexception::what"
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_MATCHES( throwsSpecialException( 2 ), SpecialException, !Message( "DerivedException::what" ) )
+with expansion:
+  SpecialException::what not exception message matches "DerivedException::what"
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_MATCHES( throwsSpecialException( 2 ), SpecialException, Message( "SpecialException::what" ) )
+with expansion:
+  SpecialException::what exception message matches "SpecialException::what"
+
+-------------------------------------------------------------------------------
+Expected exceptions that don't throw or unexpected exceptions fail the test
+-------------------------------------------------------------------------------
+Exception.tests.cpp:<line number>
+...............................................................................
+
+Exception.tests.cpp:<line number>: FAILED:
+  CHECK_THROWS_AS( thisThrows(), std::string )
+due to unexpected exception with message:
+  expected exception
+
+Exception.tests.cpp:<line number>: FAILED:
+  CHECK_THROWS_AS( thisDoesntThrow(), std::domain_error )
+because no exception was thrown where one was expected:
+
+Exception.tests.cpp:<line number>: FAILED:
+  CHECK_NOTHROW( thisThrows() )
+due to unexpected exception with message:
+  expected exception
+
+-------------------------------------------------------------------------------
+FAIL aborts the test
+-------------------------------------------------------------------------------
+Message.tests.cpp:<line number>
+...............................................................................
+
+Message.tests.cpp:<line number>: FAILED:
+explicitly with message:
+  This is a failure
+
+-------------------------------------------------------------------------------
+FAIL does not require an argument
+-------------------------------------------------------------------------------
+Message.tests.cpp:<line number>
+...............................................................................
+
+Message.tests.cpp:<line number>: FAILED:
+
+-------------------------------------------------------------------------------
+FAIL_CHECK does not abort the test
+-------------------------------------------------------------------------------
+Message.tests.cpp:<line number>
+...............................................................................
+
+Message.tests.cpp:<line number>: FAILED:
+explicitly with message:
+  This is a failure
+
+Message.tests.cpp:<line number>: warning:
+  This message appears in the output
+
+-------------------------------------------------------------------------------
+Factorials are computed
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+  REQUIRE( Factorial(0) == 1 )
+with expansion:
+  1 == 1
+
+Misc.tests.cpp:<line number>: PASSED:
+  REQUIRE( Factorial(1) == 1 )
+with expansion:
+  1 == 1
+
+Misc.tests.cpp:<line number>: PASSED:
+  REQUIRE( Factorial(2) == 2 )
+with expansion:
+  2 == 2
+
+Misc.tests.cpp:<line number>: PASSED:
+  REQUIRE( Factorial(3) == 6 )
+with expansion:
+  6 == 6
+
+Misc.tests.cpp:<line number>: PASSED:
+  REQUIRE( Factorial(10) == 3628800 )
+with expansion:
+  3628800 (0x<hex digits>) == 3628800 (0x<hex digits>)
+
+-------------------------------------------------------------------------------
+Floating point matchers: double
+  Relative
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 10., WithinRel( 11.1, 0.1 ) )
+with expansion:
+  10.0 and 11.1 are within 10% of each other
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 10., !WithinRel( 11.2, 0.1 ) )
+with expansion:
+  10.0 not and 11.2 are within 10% of each other
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1., !WithinRel( 0., 0.99 ) )
+with expansion:
+  1.0 not and 0 are within 99% of each other
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( -0., WithinRel( 0. ) )
+with expansion:
+  -0.0 and 0 are within 2.22045e-12% of each other
+
+-------------------------------------------------------------------------------
+Floating point matchers: double
+  Relative
+  Some subnormal values
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( v1, WithinRel( v2 ) )
+with expansion:
+  0.0 and 2.22507e-308 are within 2.22045e-12% of each other
+
+-------------------------------------------------------------------------------
+Floating point matchers: double
+  Margin
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1., WithinAbs( 1., 0 ) )
+with expansion:
+  1.0 is within 0.0 of 1.0
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 0., WithinAbs( 1., 1 ) )
+with expansion:
+  0.0 is within 1.0 of 1.0
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 0., !WithinAbs( 1., 0.99 ) )
+with expansion:
+  0.0 not is within 0.99 of 1.0
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 0., !WithinAbs( 1., 0.99 ) )
+with expansion:
+  0.0 not is within 0.99 of 1.0
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 11., !WithinAbs( 10., 0.5 ) )
+with expansion:
+  11.0 not is within 0.5 of 10.0
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 10., !WithinAbs( 11., 0.5 ) )
+with expansion:
+  10.0 not is within 0.5 of 11.0
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( -10., WithinAbs( -10., 0.5 ) )
+with expansion:
+  -10.0 is within 0.5 of -10.0
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( -10., WithinAbs( -9.6, 0.5 ) )
+with expansion:
+  -10.0 is within 0.5 of -9.6
+
+-------------------------------------------------------------------------------
+Floating point matchers: double
+  ULPs
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1., WithinULP( 1., 0 ) )
+with expansion:
+  1.0 is within 0 ULPs of 1.0000000000000000e+00 ([1.0000000000000000e+00, 1.
+  0000000000000000e+00])
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( nextafter( 1., 2. ), WithinULP( 1., 1 ) )
+with expansion:
+  1.0 is within 1 ULPs of 1.0000000000000000e+00 ([9.9999999999999989e-01, 1.
+  0000000000000002e+00])
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 0., WithinULP( nextafter( 0., 1. ), 1 ) )
+with expansion:
+  0.0 is within 1 ULPs of 4.9406564584124654e-324 ([0.0000000000000000e+00, 9.
+  8813129168249309e-324])
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1., WithinULP( nextafter( 1., 0. ), 1 ) )
+with expansion:
+  1.0 is within 1 ULPs of 9.9999999999999989e-01 ([9.9999999999999978e-01, 1.
+  0000000000000000e+00])
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1., !WithinULP( nextafter( 1., 2. ), 0 ) )
+with expansion:
+  1.0 not is within 0 ULPs of 1.0000000000000002e+00 ([1.0000000000000002e+00,
+  1.0000000000000002e+00])
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1., WithinULP( 1., 0 ) )
+with expansion:
+  1.0 is within 0 ULPs of 1.0000000000000000e+00 ([1.0000000000000000e+00, 1.
+  0000000000000000e+00])
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( -0., WithinULP( 0., 0 ) )
+with expansion:
+  -0.0 is within 0 ULPs of 0.0000000000000000e+00 ([0.0000000000000000e+00, 0.
+  0000000000000000e+00])
+
+-------------------------------------------------------------------------------
+Floating point matchers: double
+  Composed
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1., WithinAbs( 1., 0.5 ) || WithinULP( 2., 1 ) )
+with expansion:
+  1.0 ( is within 0.5 of 1.0 or is within 1 ULPs of 2.0000000000000000e+00 ([1.
+  9999999999999998e+00, 2.0000000000000004e+00]) )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1., WithinAbs( 2., 0.5 ) || WithinULP( 1., 0 ) )
+with expansion:
+  1.0 ( is within 0.5 of 2.0 or is within 0 ULPs of 1.0000000000000000e+00 ([1.
+  0000000000000000e+00, 1.0000000000000000e+00]) )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 0.0001, WithinAbs( 0., 0.001 ) || WithinRel( 0., 0.1 ) )
+with expansion:
+  0.0001 ( is within 0.001 of 0.0 or and 0 are within 10% of each other )
+
+-------------------------------------------------------------------------------
+Floating point matchers: double
+  Constructor validation
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_NOTHROW( WithinAbs( 1., 0. ) )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_AS( WithinAbs( 1., -1. ), std::domain_error )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_NOTHROW( WithinULP( 1., 0 ) )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_NOTHROW( WithinRel( 1., 0. ) )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_AS( WithinRel( 1., -0.2 ), std::domain_error )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_AS( WithinRel( 1., 1. ), std::domain_error )
+
+-------------------------------------------------------------------------------
+Floating point matchers: float
+  Relative
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 10.f, WithinRel( 11.1f, 0.1f ) )
+with expansion:
+  10.0f and 11.1 are within 10% of each other
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 10.f, !WithinRel( 11.2f, 0.1f ) )
+with expansion:
+  10.0f not and 11.2 are within 10% of each other
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1.f, !WithinRel( 0.f, 0.99f ) )
+with expansion:
+  1.0f not and 0 are within 99% of each other
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( -0.f, WithinRel( 0.f ) )
+with expansion:
+  -0.0f and 0 are within 0.00119209% of each other
+
+-------------------------------------------------------------------------------
+Floating point matchers: float
+  Relative
+  Some subnormal values
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( v1, WithinRel( v2 ) )
+with expansion:
+  0.0f and 1.17549e-38 are within 0.00119209% of each other
+
+-------------------------------------------------------------------------------
+Floating point matchers: float
+  Margin
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1.f, WithinAbs( 1.f, 0 ) )
+with expansion:
+  1.0f is within 0.0 of 1.0
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 0.f, WithinAbs( 1.f, 1 ) )
+with expansion:
+  0.0f is within 1.0 of 1.0
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 0.f, !WithinAbs( 1.f, 0.99f ) )
+with expansion:
+  0.0f not is within 0.9900000095 of 1.0
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 0.f, !WithinAbs( 1.f, 0.99f ) )
+with expansion:
+  0.0f not is within 0.9900000095 of 1.0
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 0.f, WithinAbs( -0.f, 0 ) )
+with expansion:
+  0.0f is within 0.0 of -0.0
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 11.f, !WithinAbs( 10.f, 0.5f ) )
+with expansion:
+  11.0f not is within 0.5 of 10.0
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 10.f, !WithinAbs( 11.f, 0.5f ) )
+with expansion:
+  10.0f not is within 0.5 of 11.0
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( -10.f, WithinAbs( -10.f, 0.5f ) )
+with expansion:
+  -10.0f is within 0.5 of -10.0
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( -10.f, WithinAbs( -9.6f, 0.5f ) )
+with expansion:
+  -10.0f is within 0.5 of -9.6000003815
+
+-------------------------------------------------------------------------------
+Floating point matchers: float
+  ULPs
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1.f, WithinULP( 1.f, 0 ) )
+with expansion:
+  1.0f is within 0 ULPs of 1.00000000e+00f ([1.00000000e+00, 1.00000000e+00])
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( -1.f, WithinULP( -1.f, 0 ) )
+with expansion:
+  -1.0f is within 0 ULPs of -1.00000000e+00f ([-1.00000000e+00, -1.00000000e+
+  00])
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( nextafter( 1.f, 2.f ), WithinULP( 1.f, 1 ) )
+with expansion:
+  1.0f is within 1 ULPs of 1.00000000e+00f ([9.99999940e-01, 1.00000012e+00])
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 0.f, WithinULP( nextafter( 0.f, 1.f ), 1 ) )
+with expansion:
+  0.0f is within 1 ULPs of 1.40129846e-45f ([0.00000000e+00, 2.80259693e-45])
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1.f, WithinULP( nextafter( 1.f, 0.f ), 1 ) )
+with expansion:
+  1.0f is within 1 ULPs of 9.99999940e-01f ([9.99999881e-01, 1.00000000e+00])
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1.f, !WithinULP( nextafter( 1.f, 2.f ), 0 ) )
+with expansion:
+  1.0f not is within 0 ULPs of 1.00000012e+00f ([1.00000012e+00, 1.00000012e+
+  00])
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1.f, WithinULP( 1.f, 0 ) )
+with expansion:
+  1.0f is within 0 ULPs of 1.00000000e+00f ([1.00000000e+00, 1.00000000e+00])
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( -0.f, WithinULP( 0.f, 0 ) )
+with expansion:
+  -0.0f is within 0 ULPs of 0.00000000e+00f ([0.00000000e+00, 0.00000000e+00])
+
+-------------------------------------------------------------------------------
+Floating point matchers: float
+  Composed
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1.f, WithinAbs( 1.f, 0.5 ) || WithinULP( 1.f, 1 ) )
+with expansion:
+  1.0f ( is within 0.5 of 1.0 or is within 1 ULPs of 1.00000000e+00f ([9.
+  99999940e-01, 1.00000012e+00]) )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 1.f, WithinAbs( 2.f, 0.5 ) || WithinULP( 1.f, 0 ) )
+with expansion:
+  1.0f ( is within 0.5 of 2.0 or is within 0 ULPs of 1.00000000e+00f ([1.
+  00000000e+00, 1.00000000e+00]) )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( 0.0001f, WithinAbs( 0.f, 0.001f ) || WithinRel( 0.f, 0.1f ) )
+with expansion:
+  0.0001f ( is within 0.001 of 0.0 or and 0 are within 10% of each other )
+
+-------------------------------------------------------------------------------
+Floating point matchers: float
+  Constructor validation
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_NOTHROW( WithinAbs( 1.f, 0.f ) )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_AS( WithinAbs( 1.f, -1.f ), std::domain_error )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_NOTHROW( WithinULP( 1.f, 0 ) )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_AS( WithinULP( 1.f, static_cast<uint64_t>( -1 ) ), std::domain_error )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_NOTHROW( WithinRel( 1.f, 0.f ) )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_AS( WithinRel( 1.f, -0.2f ), std::domain_error )
+
+Matchers.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_AS( WithinRel( 1.f, 1.f ), std::domain_error )
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Filtering by predicate
+  Basic usage
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( i % 2 == 0 )
+with expansion:
+  0 == 0
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Filtering by predicate
+  Basic usage
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( i % 2 == 0 )
+with expansion:
+  0 == 0
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Filtering by predicate
+  Basic usage
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( i % 2 == 0 )
+with expansion:
+  0 == 0
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Filtering by predicate
+  Throws if there are no matching values
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_AS( filter([] (int) {return false; }, value(1)), Catch::GeneratorException )
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Shortening a range
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( i < 4 )
+with expansion:
+  1 < 4
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Shortening a range
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( i < 4 )
+with expansion:
+  2 < 4
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Shortening a range
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( i < 4 )
+with expansion:
+  3 < 4
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Transforming elements
+  Same type
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( i % 2 == 0 )
+with expansion:
+  0 == 0
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Transforming elements
+  Same type
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( i % 2 == 0 )
+with expansion:
+  0 == 0
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Transforming elements
+  Same type
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( i % 2 == 0 )
+with expansion:
+  0 == 0
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Transforming elements
+  Different type
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( i.size() == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Transforming elements
+  Different type
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( i.size() == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Transforming elements
+  Different type
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( i.size() == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Transforming elements
+  Different deduced type
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( i.size() == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Transforming elements
+  Different deduced type
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( i.size() == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Transforming elements
+  Different deduced type
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( i.size() == 1 )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Repeating a generator
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( j > 0 )
+with expansion:
+  1 > 0
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Repeating a generator
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( j > 0 )
+with expansion:
+  2 > 0
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Repeating a generator
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( j > 0 )
+with expansion:
+  3 > 0
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Repeating a generator
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( j > 0 )
+with expansion:
+  1 > 0
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Repeating a generator
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( j > 0 )
+with expansion:
+  2 > 0
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Repeating a generator
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( j > 0 )
+with expansion:
+  3 > 0
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Chunking a generator into sized pieces
+  Number of elements in source is divisible by chunk size
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( chunk2.size() == 2 )
+with expansion:
+  2 == 2
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( chunk2.front() == chunk2.back() )
+with expansion:
+  1 == 1
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Chunking a generator into sized pieces
+  Number of elements in source is divisible by chunk size
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( chunk2.size() == 2 )
+with expansion:
+  2 == 2
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( chunk2.front() == chunk2.back() )
+with expansion:
+  2 == 2
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Chunking a generator into sized pieces
+  Number of elements in source is divisible by chunk size
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( chunk2.size() == 2 )
+with expansion:
+  2 == 2
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( chunk2.front() == chunk2.back() )
+with expansion:
+  3 == 3
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Chunking a generator into sized pieces
+  Number of elements in source is not divisible by chunk size
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( chunk2.size() == 2 )
+with expansion:
+  2 == 2
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( chunk2.front() == chunk2.back() )
+with expansion:
+  1 == 1
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( chunk2.front() < 3 )
+with expansion:
+  1 < 3
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Chunking a generator into sized pieces
+  Number of elements in source is not divisible by chunk size
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( chunk2.size() == 2 )
+with expansion:
+  2 == 2
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( chunk2.front() == chunk2.back() )
+with expansion:
+  2 == 2
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( chunk2.front() < 3 )
+with expansion:
+  2 < 3
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Chunking a generator into sized pieces
+  Chunk size of zero
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( chunk2.size() == 0 )
+with expansion:
+  0 == 0
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Chunking a generator into sized pieces
+  Chunk size of zero
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( chunk2.size() == 0 )
+with expansion:
+  0 == 0
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Chunking a generator into sized pieces
+  Chunk size of zero
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( chunk2.size() == 0 )
+with expansion:
+  0 == 0
+
+-------------------------------------------------------------------------------
+Generators -- adapters
+  Chunking a generator into sized pieces
+  Throws on too small generators
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_AS( chunk(2, value(1)), Catch::GeneratorException )
+
+-------------------------------------------------------------------------------
+Generators -- simple
+  one
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( j < i )
+with expansion:
+  -3 < 1
+
+-------------------------------------------------------------------------------
+Generators -- simple
+  one
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( j < i )
+with expansion:
+  -2 < 1
+
+-------------------------------------------------------------------------------
+Generators -- simple
+  one
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( j < i )
+with expansion:
+  -1 < 1
+
+-------------------------------------------------------------------------------
+Generators -- simple
+  two
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( 4u * i > str.size() )
+with expansion:
+  4 > 1
+
+-------------------------------------------------------------------------------
+Generators -- simple
+  two
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( 4u * i > str.size() )
+with expansion:
+  4 > 2
+
+-------------------------------------------------------------------------------
+Generators -- simple
+  two
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( 4u * i > str.size() )
+with expansion:
+  4 > 3
+
+-------------------------------------------------------------------------------
+Generators -- simple
+  one
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( j < i )
+with expansion:
+  -3 < 2
+
+-------------------------------------------------------------------------------
+Generators -- simple
+  one
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( j < i )
+with expansion:
+  -2 < 2
+
+-------------------------------------------------------------------------------
+Generators -- simple
+  one
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( j < i )
+with expansion:
+  -1 < 2
+
+-------------------------------------------------------------------------------
+Generators -- simple
+  two
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( 4u * i > str.size() )
+with expansion:
+  8 > 1
+
+-------------------------------------------------------------------------------
+Generators -- simple
+  two
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( 4u * i > str.size() )
+with expansion:
+  8 > 2
+
+-------------------------------------------------------------------------------
+Generators -- simple
+  two
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( 4u * i > str.size() )
+with expansion:
+  8 > 3
+
+-------------------------------------------------------------------------------
+Generators -- simple
+  one
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( j < i )
+with expansion:
+  -3 < 3
+
+-------------------------------------------------------------------------------
+Generators -- simple
+  one
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( j < i )
+with expansion:
+  -2 < 3
+
+-------------------------------------------------------------------------------
+Generators -- simple
+  one
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( j < i )
+with expansion:
+  -1 < 3
+
+-------------------------------------------------------------------------------
+Generators -- simple
+  two
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( 4u * i > str.size() )
+with expansion:
+  12 > 1
+
+-------------------------------------------------------------------------------
+Generators -- simple
+  two
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( 4u * i > str.size() )
+with expansion:
+  12 > 2
+
+-------------------------------------------------------------------------------
+Generators -- simple
+  two
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: PASSED:
+  REQUIRE( 4u * i > str.size() )
+with expansion:
+  12 > 3
+
+-------------------------------------------------------------------------------
+Generators internals
+  Single value
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 123 )
+with expansion:
+  123 == 123
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Preset values
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 1 )
+with expansion:
+  1 == 1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 3 )
+with expansion:
+  3 == 3
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 5 )
+with expansion:
+  5 == 5
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Generator combinator
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 1 )
+with expansion:
+  1 == 1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 5 )
+with expansion:
+  5 == 5
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 2 )
+with expansion:
+  2 == 2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 4 )
+with expansion:
+  4 == 4
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 0 )
+with expansion:
+  0 == 0
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Explicitly typed generator sequence
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get().size() == 2 )
+with expansion:
+  2 == 2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == "aa" )
+with expansion:
+  "aa" == "aa"
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == "bb" )
+with expansion:
+  "bb" == "bb"
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == "cc" )
+with expansion:
+  "cc" == "cc"
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Filter generator
+  Simple filtering
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 1 )
+with expansion:
+  1 == 1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 3 )
+with expansion:
+  3 == 3
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Filter generator
+  Filter out multiple elements at the start and end
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 1 )
+with expansion:
+  1 == 1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 3 )
+with expansion:
+  3 == 3
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Filter generator
+  Throws on construction if it can't get initial element
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_AS( filter([](int) { return false; }, value(1)), Catch::GeneratorException )
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_THROWS_AS( filter([](int) { return false; }, values({ 1, 2, 3 })), Catch::GeneratorException )
+
+-------------------------------------------------------------------------------
+Generators internals
+  Take generator
+  Take less
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 1 )
+with expansion:
+  1 == 1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 2 )
+with expansion:
+  2 == 2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Take generator
+  Take more
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 1 )
+with expansion:
+  1 == 1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Map with explicit return type
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 2.0 )
+with expansion:
+  2.0 == 2.0
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 4.0 )
+with expansion:
+  4.0 == 4.0
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 6.0 )
+with expansion:
+  6.0 == 6.0
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Map with deduced return type
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 2.0 )
+with expansion:
+  2.0 == 2.0
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 4.0 )
+with expansion:
+  4.0 == 4.0
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 6.0 )
+with expansion:
+  6.0 == 6.0
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Repeat
+  Singular repeat
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 3 )
+with expansion:
+  3 == 3
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Repeat
+  Actual repeat
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 1 )
+with expansion:
+  1 == 1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 2 )
+with expansion:
+  2 == 2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 3 )
+with expansion:
+  3 == 3
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 1 )
+with expansion:
+  1 == 1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 2 )
+with expansion:
+  2 == 2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 3 )
+with expansion:
+  3 == 3
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Range
+  Positive auto step
+  Integer
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == -2 )
+with expansion:
+  -2 == -2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == -1 )
+with expansion:
+  -1 == -1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 0 )
+with expansion:
+  0 == 0
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 1 )
+with expansion:
+  1 == 1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Range
+  Negative auto step
+  Integer
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 2 )
+with expansion:
+  2 == 2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 1 )
+with expansion:
+  1 == 1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 0 )
+with expansion:
+  0 == 0
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == -1 )
+with expansion:
+  -1 == -1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Range
+  Positive manual step
+  Integer
+  Exact
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == -7 )
+with expansion:
+  -7 == -7
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == -4 )
+with expansion:
+  -4 == -4
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == -1 )
+with expansion:
+  -1 == -1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 2 )
+with expansion:
+  2 == 2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Range
+  Positive manual step
+  Integer
+  Slightly over end
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == -7 )
+with expansion:
+  -7 == -7
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == -4 )
+with expansion:
+  -4 == -4
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == -1 )
+with expansion:
+  -1 == -1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 2 )
+with expansion:
+  2 == 2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Range
+  Positive manual step
+  Integer
+  Slightly under end
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == -7 )
+with expansion:
+  -7 == -7
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == -4 )
+with expansion:
+  -4 == -4
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == -1 )
+with expansion:
+  -1 == -1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 2 )
+with expansion:
+  2 == 2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 5 )
+with expansion:
+  5 == 5
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Range
+  Positive manual step
+  Floating Point
+  Exact
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  -1.0 == Approx( -1.0 )
+with message:
+  Current expected value is -1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is -1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  -0.9 == Approx( -0.9 )
+with message:
+  Current expected value is -0.9
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is -0.9
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  -0.8 == Approx( -0.8 )
+with message:
+  Current expected value is -0.8
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is -0.8
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  -0.7 == Approx( -0.7 )
+with message:
+  Current expected value is -0.7
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is -0.7
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  -0.6 == Approx( -0.6 )
+with message:
+  Current expected value is -0.6
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is -0.6
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  -0.5 == Approx( -0.5 )
+with message:
+  Current expected value is -0.5
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is -0.5
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  -0.4 == Approx( -0.4 )
+with message:
+  Current expected value is -0.4
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is -0.4
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  -0.3 == Approx( -0.3 )
+with message:
+  Current expected value is -0.3
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is -0.3
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  -0.2 == Approx( -0.2 )
+with message:
+  Current expected value is -0.2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is -0.2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  -0.1 == Approx( -0.1 )
+with message:
+  Current expected value is -0.1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is -0.1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  -0.0 == Approx( -0.0 )
+with message:
+  Current expected value is -1.38778e-16
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is -1.38778e-16
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  0.1 == Approx( 0.1 )
+with message:
+  Current expected value is 0.1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is 0.1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  0.2 == Approx( 0.2 )
+with message:
+  Current expected value is 0.2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is 0.2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  0.3 == Approx( 0.3 )
+with message:
+  Current expected value is 0.3
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is 0.3
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  0.4 == Approx( 0.4 )
+with message:
+  Current expected value is 0.4
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is 0.4
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  0.5 == Approx( 0.5 )
+with message:
+  Current expected value is 0.5
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is 0.5
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  0.6 == Approx( 0.6 )
+with message:
+  Current expected value is 0.6
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is 0.6
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  0.7 == Approx( 0.7 )
+with message:
+  Current expected value is 0.7
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is 0.7
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  0.8 == Approx( 0.8 )
+with message:
+  Current expected value is 0.8
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is 0.8
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  0.9 == Approx( 0.9 )
+with message:
+  Current expected value is 0.9
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is 0.9
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx( rangeEnd ) )
+with expansion:
+  1.0 == Approx( 1.0 )
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Range
+  Positive manual step
+  Floating Point
+  Slightly over end
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  -1.0 == Approx( -1.0 )
+with message:
+  Current expected value is -1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is -1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  -0.7 == Approx( -0.7 )
+with message:
+  Current expected value is -0.7
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is -0.7
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  -0.4 == Approx( -0.4 )
+with message:
+  Current expected value is -0.4
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is -0.4
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  -0.1 == Approx( -0.1 )
+with message:
+  Current expected value is -0.1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is -0.1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  0.2 == Approx( 0.2 )
+with message:
+  Current expected value is 0.2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is 0.2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  0.5 == Approx( 0.5 )
+with message:
+  Current expected value is 0.5
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is 0.5
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Range
+  Positive manual step
+  Floating Point
+  Slightly under end
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  -1.0 == Approx( -1.0 )
+with message:
+  Current expected value is -1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is -1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  -0.7 == Approx( -0.7 )
+with message:
+  Current expected value is -0.7
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is -0.7
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  -0.4 == Approx( -0.4 )
+with message:
+  Current expected value is -0.4
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is -0.4
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  -0.1 == Approx( -0.1 )
+with message:
+  Current expected value is -0.1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is -0.1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  0.2 == Approx( 0.2 )
+with message:
+  Current expected value is 0.2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is 0.2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == Approx(expected) )
+with expansion:
+  0.5 == Approx( 0.5 )
+with message:
+  Current expected value is 0.5
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+with message:
+  Current expected value is 0.5
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Range
+  Negative manual step
+  Integer
+  Exact
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 5 )
+with expansion:
+  5 == 5
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 2 )
+with expansion:
+  2 == 2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == -1 )
+with expansion:
+  -1 == -1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == -4 )
+with expansion:
+  -4 == -4
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Range
+  Negative manual step
+  Integer
+  Slightly over end
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 5 )
+with expansion:
+  5 == 5
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 2 )
+with expansion:
+  2 == 2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == -1 )
+with expansion:
+  -1 == -1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == -4 )
+with expansion:
+  -4 == -4
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( gen.next() )
+with expansion:
+  !false
+
+-------------------------------------------------------------------------------
+Generators internals
+  Range
+  Negative manual step
+  Integer
+  Slightly under end
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 5 )
+with expansion:
+  5 == 5
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == 2 )
+with expansion:
+  2 == 2
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == -1 )
+with expansion:
+  -1 == -1
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.get() == -4 )
+with expansion:
+  -4 == -4
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+  REQUIRE( gen.next() )
+with expansion:
+  true
+
+GeneratorsImpl.tests.cpp:<lin

The changes are longer than what is shown.