OpenCppCoverage skips coverage of non-source directories

Previously, we would collect coverage data for all source files in
Catch2's directory, including tests and examples, and we would then
ask codecov.io to ignore those. With this change, OpenCppCoverage
only collects coverage data for source files in the `src/` directory.
This cuts the size of the coverage report in half, and also speeds
up the coverage collection.

appveyor.yml

@@ -56,15 +56,10 @@ environment:
       platform: x64
       configuration: Release
 
-    - FLAVOR: VS 2019 x64 Debug Coverage
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      coverage: 1
-      platform: x64
-      configuration: Debug
-
-    - FLAVOR: VS 2019 x64 Debug Examples
+    - FLAVOR: VS 2019 x64 Debug Coverage Examples
       APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
       examples: 1
+      coverage: 1
       platform: x64
       configuration: Debug
 

codecov.yml

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

examples/300-Gen-OwnGenerator.cpp

@@ -40,7 +40,9 @@ int const& RandomIntGenerator::get() const {
 // Notice that it returns an instance of GeneratorWrapper<int>, which
 // is a value-wrapper around std::unique_ptr<IGenerator<int>>.
 Catch::Generators::GeneratorWrapper<int> random(int low, int high) {
-    return Catch::Generators::GeneratorWrapper<int>(std::unique_ptr<Catch::Generators::IGenerator<int>>(new RandomIntGenerator(low, high)));
+    return Catch::Generators::GeneratorWrapper<int>(
+        std::make_unique<RandomIntGenerator>(low, high)
+    );
 }
 
 // The two sections in this test case are equivalent, but the first one

examples/301-Gen-MapTypeConversion.cpp

@@ -38,9 +38,7 @@ std::string const& LineGenerator::get() const {
 // is a value-wrapper around std::unique_ptr<IGenerator<std::string>>.
 Catch::Generators::GeneratorWrapper<std::string> lines(std::string /* ignored for example */) {
     return Catch::Generators::GeneratorWrapper<std::string>(
-        std::unique_ptr<Catch::Generators::IGenerator<std::string>>(
-            new LineGenerator()
-        )
+        std::make_unique<LineGenerator>()
     );
 }
 

src/catch2/catch_approx.h

@@ -32,7 +32,7 @@ namespace Detail {
 
         Approx operator-() const;
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         Approx operator()( T const& value ) {
             Approx approx( static_cast<double>(value) );
             approx.m_epsilon = m_epsilon;
@@ -41,67 +41,67 @@ namespace Detail {
             return approx;
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         explicit Approx( T const& value ): Approx(static_cast<double>(value))
         {}
 
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         friend bool operator == ( const T& lhs, Approx const& rhs ) {
             auto lhs_v = static_cast<double>(lhs);
             return rhs.equalityComparisonImpl(lhs_v);
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         friend bool operator == ( Approx const& lhs, const T& rhs ) {
             return operator==( rhs, lhs );
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         friend bool operator != ( T const& lhs, Approx const& rhs ) {
             return !operator==( lhs, rhs );
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         friend bool operator != ( Approx const& lhs, T const& rhs ) {
             return !operator==( rhs, lhs );
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         friend bool operator <= ( T const& lhs, Approx const& rhs ) {
             return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         friend bool operator <= ( Approx const& lhs, T const& rhs ) {
             return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         friend bool operator >= ( T const& lhs, Approx const& rhs ) {
             return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         friend bool operator >= ( Approx const& lhs, T const& rhs ) {
             return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         Approx& epsilon( T const& newEpsilon ) {
             double epsilonAsDouble = static_cast<double>(newEpsilon);
             setEpsilon(epsilonAsDouble);
             return *this;
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         Approx& margin( T const& newMargin ) {
             double marginAsDouble = static_cast<double>(newMargin);
             setMargin(marginAsDouble);
             return *this;
         }
 
-        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+        template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
         Approx& scale( T const& newScale ) {
             m_scale = static_cast<double>(newScale);
             return *this;

src/catch2/catch_config.cpp

@@ -7,6 +7,7 @@
 
 #include <catch2/catch_config.hpp>
 #include <catch2/catch_enforce.h>
+#include <catch2/catch_stream.h>
 #include <catch2/catch_stringref.h>
 
 namespace Catch {
@@ -36,6 +37,9 @@ namespace Catch {
         m_testSpec = parser.testSpec();
     }
 
+    Config::~Config() = default;
+
+
     std::string const& Config::getFilename() const {
         return m_data.outputFilename ;
     }

src/catch2/catch_config.hpp

@@ -11,9 +11,6 @@
 #include <catch2/catch_test_spec_parser.h>
 #include <catch2/catch_interfaces_config.h>
 
-// Libstdc++ doesn't like incomplete classes for unique_ptr
-#include <catch2/catch_stream.h>
-
 #include <memory>
 #include <vector>
 #include <string>
@@ -73,7 +70,7 @@ namespace Catch {
 
         Config() = default;
         Config( ConfigData const& data );
-        virtual ~Config() = default;
+        ~Config() override; // = default in the cpp file
 
         std::string const& getFilename() const;
 

src/catch2/catch_enum_values_registry.cpp

@@ -52,7 +52,7 @@ namespace Catch {
         }
 
         std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
-            std::unique_ptr<EnumInfo> enumInfo( new EnumInfo );
+            auto enumInfo = std::make_unique<EnumInfo>();
             enumInfo->m_name = enumName;
             enumInfo->m_values.reserve( values.size() );
 

src/catch2/catch_generators.hpp

@@ -33,14 +33,6 @@ public:
 
 namespace Generators {
 
-    // !TBD move this into its own location?
-    namespace pf{
-        template<typename T, typename... Args>
-        std::unique_ptr<T> make_unique( Args&&... args ) {
-            return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-        }
-    }
-
     template<typename T>
     struct IGenerator : GeneratorUntypedBase {
         virtual ~IGenerator() = default;
@@ -104,11 +96,11 @@ namespace Generators {
 
     template <typename T>
     GeneratorWrapper<T> value(T&& value) {
-        return GeneratorWrapper<T>(pf::make_unique<SingleValueGenerator<T>>(std::forward<T>(value)));
+        return GeneratorWrapper<T>(std::make_unique<SingleValueGenerator<T>>(std::forward<T>(value)));
     }
     template <typename T>
     GeneratorWrapper<T> values(std::initializer_list<T> values) {
-        return GeneratorWrapper<T>(pf::make_unique<FixedValuesGenerator<T>>(values));
+        return GeneratorWrapper<T>(std::make_unique<FixedValuesGenerator<T>>(values));
     }
 
     template<typename T>
@@ -157,7 +149,7 @@ namespace Generators {
 
 
     template<typename... Ts>
-    GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std::tuple<typename std::decay<Ts>::type...>> tuples ) {
+    GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std::tuple<std::decay_t<Ts>...>> tuples ) {
         return values<std::tuple<Ts...>>( tuples );
     }
 
@@ -193,7 +185,7 @@ namespace Generators {
 
         IGeneratorTracker& tracker = acquireGeneratorTracker( lineInfo );
         if (!tracker.hasGenerator()) {
-            tracker.setGenerator(pf::make_unique<Generators<UnderlyingType>>(generatorExpression()));
+            tracker.setGenerator(std::make_unique<Generators<UnderlyingType>>(generatorExpression()));
         }
 
         auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker.getGenerator() );

src/catch2/catch_generators_generic.hpp

@@ -46,7 +46,7 @@ namespace Generators {
 
     template <typename T>
     GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(pf::make_unique<TakeGenerator<T>>(target, std::move(generator)));
+        return GeneratorWrapper<T>(std::make_unique<TakeGenerator<T>>(target, std::move(generator)));
     }
 
 
@@ -87,7 +87,7 @@ namespace Generators {
 
     template <typename T, typename Predicate>
     GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(std::unique_ptr<IGenerator<T>>(pf::make_unique<FilterGenerator<T, Predicate>>(std::forward<Predicate>(pred), std::move(generator))));
+        return GeneratorWrapper<T>(std::unique_ptr<IGenerator<T>>(std::make_unique<FilterGenerator<T, Predicate>>(std::forward<Predicate>(pred), std::move(generator))));
     }
 
     template <typename T>
@@ -143,7 +143,7 @@ namespace Generators {
 
     template <typename T>
     GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
-        return GeneratorWrapper<T>(pf::make_unique<RepeatGenerator<T>>(repeats, std::move(generator)));
+        return GeneratorWrapper<T>(std::make_unique<RepeatGenerator<T>>(repeats, std::move(generator)));
     }
 
     template <typename T, typename U, typename Func>
@@ -176,14 +176,14 @@ namespace Generators {
     template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
     GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
         return GeneratorWrapper<T>(
-            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
+            std::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
         );
     }
 
     template <typename T, typename U, typename Func>
     GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
         return GeneratorWrapper<T>(
-            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
+            std::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
         );
     }
 
@@ -226,7 +226,7 @@ namespace Generators {
     template <typename T>
     GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
         return GeneratorWrapper<std::vector<T>>(
-            pf::make_unique<ChunkGenerator<T>>(size, std::move(generator))
+            std::make_unique<ChunkGenerator<T>>(size, std::move(generator))
         );
     }
 

src/catch2/catch_generators_specific.hpp

@@ -64,20 +64,20 @@ public:
 // TODO: Ideally this would be also constrained against the various char types,
 //       but I don't expect users to run into that in practice.
 template <typename T>
-typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value,
-GeneratorWrapper<T>>::type
+std::enable_if_t<std::is_integral<T>::value && !std::is_same<T, bool>::value,
+GeneratorWrapper<T>>
 random(T a, T b) {
     return GeneratorWrapper<T>(
-        pf::make_unique<RandomIntegerGenerator<T>>(a, b)
+        std::make_unique<RandomIntegerGenerator<T>>(a, b)
     );
 }
 
 template <typename T>
-typename std::enable_if<std::is_floating_point<T>::value,
-GeneratorWrapper<T>>::type
+std::enable_if_t<std::is_floating_point<T>::value,
+GeneratorWrapper<T>>
 random(T a, T b) {
     return GeneratorWrapper<T>(
-        pf::make_unique<RandomFloatingGenerator<T>>(a, b)
+        std::make_unique<RandomFloatingGenerator<T>>(a, b)
     );
 }
 
@@ -118,13 +118,13 @@ public:
 template <typename T>
 GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
     static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
-    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end, step));
+    return GeneratorWrapper<T>(std::make_unique<RangeGenerator<T>>(start, end, step));
 }
 
 template <typename T>
 GeneratorWrapper<T> range(T const& start, T const& end) {
     static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
-    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end));
+    return GeneratorWrapper<T>(std::make_unique<RangeGenerator<T>>(start, end));
 }
 
 
@@ -158,13 +158,13 @@ template <typename InputIterator,
           typename InputSentinel,
           typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
 GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
-    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(from, to));
+    return GeneratorWrapper<ResultType>(std::make_unique<IteratorGenerator<ResultType>>(from, to));
 }
 
 template <typename Container,
           typename ResultType = typename Container::value_type>
 GeneratorWrapper<ResultType> from_range(Container const& cnt) {
-    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(cnt.begin(), cnt.end()));
+    return GeneratorWrapper<ResultType>(std::make_unique<IteratorGenerator<ResultType>>(cnt.begin(), cnt.end()));
 }
 
 

src/catch2/catch_matchers_vector.h

@@ -107,17 +107,17 @@ namespace Matchers {
             std::string describe() const override {
                 return "is approx: " + ::Catch::Detail::stringify( m_comparator );
             }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
             ApproxMatcher& epsilon( T const& newEpsilon ) {
                 approx.epsilon(newEpsilon);
                 return *this;
             }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
             ApproxMatcher& margin( T const& newMargin ) {
                 approx.margin(newMargin);
                 return *this;
             }
-            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
             ApproxMatcher& scale( T const& newScale ) {
                 approx.scale(newScale);
                 return *this;

src/catch2/catch_meta.hpp

@@ -38,7 +38,7 @@ namespace Catch {
     using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U>>>;
 #else
     template <typename Func, typename U>
-    using FunctionReturnType = typename std::remove_reference<typename std::remove_cv<typename std::result_of<Func(U)>::type>::type>::type;
+    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::result_of_t<Func(U)>>>;
 #endif
 
 } // namespace Catch

src/catch2/catch_reporter_registrars.hpp

@@ -40,7 +40,7 @@ namespace Catch {
         class ListenerFactory : public IReporterFactory {
 
             IStreamingReporterPtr create( ReporterConfig const& config ) const override {
-                return std::unique_ptr<T>( new T( config ) );
+                return std::make_unique<T>(config);
             }
             std::string getDescription() const override {
                 return std::string();

src/catch2/catch_stream.cpp

@@ -108,7 +108,7 @@ namespace Catch {
             mutable std::ostream m_os;
         public:
             DebugOutStream()
-            :   m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
+            :   m_streamBuf( std::make_unique<StreamBufImpl<OutputDebugWriter>>() ),
                 m_os( m_streamBuf.get() )
             {}
 

src/catch2/catch_tostring.h

@@ -59,23 +59,23 @@ namespace Catch {
         std::string convertUnknownEnumToString( E e );
 
         template<typename T>
-        typename std::enable_if<
+        std::enable_if_t<
             !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
-        std::string>::type convertUnstreamable( T const& ) {
+        std::string> convertUnstreamable( T const& ) {
             return Detail::unprintableString;
         }
         template<typename T>
-        typename std::enable_if<
+        std::enable_if_t<
             !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
-         std::string>::type convertUnstreamable(T const& ex) {
+         std::string> convertUnstreamable(T const& ex) {
             return ex.what();
         }
 
 
         template<typename T>
-        typename std::enable_if<
-            std::is_enum<T>::value
-        , std::string>::type convertUnstreamable( T const& value ) {
+        std::enable_if_t<
+            std::is_enum<T>::value,
+        std::string> convertUnstreamable( T const& value ) {
             return convertUnknownEnumToString( value );
         }
 
@@ -99,7 +99,7 @@ namespace Catch {
     struct StringMaker {
         template <typename Fake = T>
         static
-        typename std::enable_if<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
+        std::enable_if_t<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>
             convert(const Fake& value) {
                 ReusableStringStream rss;
                 // NB: call using the function-like syntax to avoid ambiguity with
@@ -110,7 +110,7 @@ namespace Catch {
 
         template <typename Fake = T>
         static
-        typename std::enable_if<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
+        std::enable_if_t<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>
             convert( const Fake& value ) {
 #if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
             return Detail::convertUnstreamable(value);
@@ -126,12 +126,12 @@ namespace Catch {
         // Should be preferably called fully qualified, like ::Catch::Detail::stringify
         template <typename T>
         std::string stringify(const T& e) {
-            return ::Catch::StringMaker<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::convert(e);
+            return ::Catch::StringMaker<std::remove_cv_t<std::remove_reference_t<T>>>::convert(e);
         }
 
         template<typename E>
         std::string convertUnknownEnumToString( E e ) {
-            return ::Catch::Detail::stringify(static_cast<typename std::underlying_type<E>::type>(e));
+            return ::Catch::Detail::stringify(static_cast<std::underlying_type_t<E>>(e));
         }
 
 #if defined(_MANAGED)
@@ -515,7 +515,7 @@ namespace Catch {
     }
 
     template<typename R>
-    struct StringMaker<R, typename std::enable_if<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>::type> {
+    struct StringMaker<R, std::enable_if_t<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>> {
         static std::string convert( R const& range ) {
             return rangeToString( range );
         }

src/catch2/catch_xmlwriter.cpp

@@ -53,26 +53,26 @@ namespace {
     }
 
     bool shouldNewline(XmlFormatting fmt) {
-        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Newline));
+        return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Newline));
     }
 
     bool shouldIndent(XmlFormatting fmt) {
-        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Indent));
+        return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Indent));
     }
 
 } // anonymous namespace
 
     XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
         return static_cast<XmlFormatting>(
-            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) |
-            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
+            static_cast<std::underlying_type_t<XmlFormatting>>(lhs) |
+            static_cast<std::underlying_type_t<XmlFormatting>>(rhs)
         );
     }
 
     XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
         return static_cast<XmlFormatting>(
-            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) &
-            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
+            static_cast<std::underlying_type_t<XmlFormatting>>(lhs) &
+            static_cast<std::underlying_type_t<XmlFormatting>>(rhs)
         );
     }
 

tests/SelfTest/Baselines/automake.sw.approved.txt

@@ -0,0 +1,313 @@
+: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
+: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
+This would not be caught previously
+Nor would this
+:test-result: FAIL #1514: stderr/stdout is not captured in tests aborted by an exception
+:test-result: PASS #1548
+: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 Assertions then sections
+: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 Character pretty printing
+: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: 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: 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 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: 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 Parse test names and tags
+: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: FAIL Reconstruction should be based on stringification: #914
+:test-result: FAIL Regex string matcher
+:test-result: PASS Regression test #1
+: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
+A string sent directly to stdout
+A string sent directly to stderr
+A string sent to stderr via clog
+:test-result: FAIL Sends stuff to stdout and stderr
+:test-result: PASS Some simple comparisons between doubles
+Message from section one
+Message from section two
+: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 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 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 one argument
+:test-result: PASS Test enum bit values
+:test-result: PASS Test with special, characters "in name
+:test-result: FAIL The NO_FAIL macro reports a failure but does not fail the test
+: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 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: FAIL Where the LHS is not a simple value
+:test-result: FAIL Where there is more to the expression after the RHS
+: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 array<int, N> -> toString
+:test-result: PASS atomic if
+: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 comparisons between const int variables
+:test-result: PASS comparisons between int variables
+:test-result: PASS even more nested SECTION tests
+:test-result: FAIL first tag
+loose text artifact
+:test-result: FAIL has printf
+: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: 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 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: 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 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: FAIL string literals of different sizes can be compared
+: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: 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 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 xmlentitycheck

tests/SelfTest/Baselines/teamcity.sw.approved.txt

@@ -0,0 +1,770 @@
+##teamcity[testSuiteStarted name='<exe-name>']
+##teamcity[testStarted name='# A test name that starts with a #']
+##teamcity[testFinished name='# A test name that starts with a #' duration="{duration}"]
+##teamcity[testStarted name='#1005: Comparing pointer to int and long (NULL can be either on various systems)']
+##teamcity[testFinished name='#1005: Comparing pointer to int and long (NULL can be either on various systems)' duration="{duration}"]
+##teamcity[testStarted name='#1027']
+##teamcity[testFinished name='#1027' duration="{duration}"]
+##teamcity[testStarted name='#1027: Bitfields can be captured']
+##teamcity[testFinished name='#1027: Bitfields can be captured' duration="{duration}"]
+##teamcity[testStarted name='#1147']
+##teamcity[testFinished name='#1147' duration="{duration}"]
+##teamcity[testStarted name='#1175 - Hidden Test']
+##teamcity[testFinished name='#1175 - Hidden Test' duration="{duration}"]
+##teamcity[testStarted name='#1238']
+##teamcity[testFinished name='#1238' duration="{duration}"]
+##teamcity[testStarted name='#1245']
+##teamcity[testFinished name='#1245' duration="{duration}"]
+##teamcity[testStarted name='#1319: Sections can have description (even if it is not saved']
+##teamcity[testFinished name='#1319: Sections can have description (even if it is not saved' duration="{duration}"]
+##teamcity[testStarted name='#1403']
+##teamcity[testFinished name='#1403' duration="{duration}"]
+##teamcity[testStarted name='#1455 - INFO and WARN can start with a linebreak']
+##teamcity[testFinished name='#1455 - INFO and WARN can start with a linebreak' duration="{duration}"]
+##teamcity[testStarted name='#1514: stderr/stdout is not captured in tests aborted by an exception']
+Tricky.tests.cpp:<line number>|nexplicit failure with message:|n  "1514"']
+##teamcity[testStdOut name='#1514: stderr/stdout is not captured in tests aborted by an exception' out='This would not be caught previously|n']
+##teamcity[testStdErr name='#1514: stderr/stdout is not captured in tests aborted by an exception' out='Nor would this|n']
+##teamcity[testFinished name='#1514: stderr/stdout is not captured in tests aborted by an exception' duration="{duration}"]
+##teamcity[testStarted name='#1548']
+##teamcity[testFinished name='#1548' duration="{duration}"]
+##teamcity[testStarted name='#748 - captures with unexpected exceptions']
+Exception.tests.cpp:<line number>|nunexpected exception with messages:|n  "answer := 42"|n  "expected exception"- failure ignore as test marked as |'ok to fail|'|n']
+Exception.tests.cpp:<line number>|nunexpected exception with messages:|n  "answer := 42"|n  "expected exception"|n  REQUIRE_NOTHROW( thisThrows() )|nwith expansion:|n  thisThrows()|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testFinished name='#748 - captures with unexpected exceptions' duration="{duration}"]
+##teamcity[testStarted name='#809']
+##teamcity[testFinished name='#809' duration="{duration}"]
+##teamcity[testStarted name='#833']
+##teamcity[testFinished name='#833' duration="{duration}"]
+##teamcity[testStarted name='#835 -- errno should not be touched by Catch']
+Misc.tests.cpp:<line number>|nexpression failed|n  CHECK( f() == 0 )|nwith expansion:|n  1 == 0|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testFinished name='#835 -- errno should not be touched by Catch' duration="{duration}"]
+##teamcity[testStarted name='#872']
+##teamcity[testFinished name='#872' duration="{duration}"]
+##teamcity[testStarted name='#961 -- Dynamically created sections should all be reported']
+##teamcity[testFinished name='#961 -- Dynamically created sections should all be reported' duration="{duration}"]
+##teamcity[testStarted name='|'Not|' checks that should fail']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( false != false )|nwith expansion:|n  false != false|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( true != true )|nwith expansion:|n  true != true|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( !true )|nwith expansion:|n  false|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK_FALSE( true )|nwith expansion:|n  !true|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( !trueValue )|nwith expansion:|n  false|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK_FALSE( trueValue )|nwith expansion:|n  !true|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( !(1 == 1) )|nwith expansion:|n  false|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK_FALSE( 1 == 1 )|nwith expansion:|n  !(1 == 1)|n']
+##teamcity[testFinished name='|'Not|' checks that should fail' duration="{duration}"]
+##teamcity[testStarted name='|'Not|' checks that should succeed']
+##teamcity[testFinished name='|'Not|' checks that should succeed' duration="{duration}"]
+##teamcity[testStarted name='(unimplemented) static bools can be evaluated']
+##teamcity[testFinished name='(unimplemented) static bools can be evaluated' duration="{duration}"]
+##teamcity[testStarted name='3x3x3 ints']
+##teamcity[testFinished name='3x3x3 ints' duration="{duration}"]
+##teamcity[testStarted name='A METHOD_AS_TEST_CASE based test run that fails']
+Class.tests.cpp:<line number>|nexpression failed|n  REQUIRE( s == "world" )|nwith expansion:|n  "hello" == "world"|n']
+##teamcity[testFinished name='A METHOD_AS_TEST_CASE based test run that fails' duration="{duration}"]
+##teamcity[testStarted name='A METHOD_AS_TEST_CASE based test run that succeeds']
+##teamcity[testFinished name='A METHOD_AS_TEST_CASE based test run that succeeds' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<float>']
+Class.tests.cpp:<line number>|nexpression failed|n  REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n  0 == 1|n']
+##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<float>' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>']
+Class.tests.cpp:<line number>|nexpression failed|n  REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n  0 == 1|n']
+##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>']
+Class.tests.cpp:<line number>|nexpression failed|n  REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n  0 == 1|n']
+##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>']
+Class.tests.cpp:<line number>|nexpression failed|n  REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n  0 == 1|n']
+##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<float>']
+##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<float>' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<int>']
+##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<int>' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<float>']
+##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<float>' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<int>']
+##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<int>' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<float, 6>']
+Class.tests.cpp:<line number>|nexpression failed|n  REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n  6 < 2|n']
+##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<float, 6>' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>']
+Class.tests.cpp:<line number>|nexpression failed|n  REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n  2 < 2|n']
+##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>']
+Class.tests.cpp:<line number>|nexpression failed|n  REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n  6 < 2|n']
+##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>']
+Class.tests.cpp:<line number>|nexpression failed|n  REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n  2 < 2|n']
+##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<float,6>']
+##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<float,6>' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<int,2>']
+##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<int,2>' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<float,6>']
+##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<float,6>' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<int,2>']
+##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<int,2>' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - double']
+Class.tests.cpp:<line number>|nexpression failed|n  REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n  1.0 == 2|n']
+##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - double' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - float']
+Class.tests.cpp:<line number>|nexpression failed|n  REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n  1.0f == 2|n']
+##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - float' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - int']
+Class.tests.cpp:<line number>|nexpression failed|n  REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n  1 == 2|n']
+##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - int' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double']
+##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - float']
+##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - float' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - int']
+##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - int' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1']
+Class.tests.cpp:<line number>|nexpression failed|n  REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n  1 == 0|n']
+##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3']
+Class.tests.cpp:<line number>|nexpression failed|n  REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n  3 == 0|n']
+##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6']
+Class.tests.cpp:<line number>|nexpression failed|n  REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n  6 == 0|n']
+##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1']
+##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 3']
+##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 3' duration="{duration}"]
+##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 6']
+##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 6' duration="{duration}"]
+##teamcity[testStarted name='A TEST_CASE_METHOD based test run that fails']
+Class.tests.cpp:<line number>|nexpression failed|n  REQUIRE( m_a == 2 )|nwith expansion:|n  1 == 2|n']
+##teamcity[testFinished name='A TEST_CASE_METHOD based test run that fails' duration="{duration}"]
+##teamcity[testStarted name='A TEST_CASE_METHOD based test run that succeeds']
+##teamcity[testFinished name='A TEST_CASE_METHOD based test run that succeeds' duration="{duration}"]
+##teamcity[testStarted name='A Template product test case - Foo<float>']
+##teamcity[testFinished name='A Template product test case - Foo<float>' duration="{duration}"]
+##teamcity[testStarted name='A Template product test case - Foo<int>']
+##teamcity[testFinished name='A Template product test case - Foo<int>' duration="{duration}"]
+##teamcity[testStarted name='A Template product test case - std::vector<float>']
+##teamcity[testFinished name='A Template product test case - std::vector<float>' duration="{duration}"]
+##teamcity[testStarted name='A Template product test case - std::vector<int>']
+##teamcity[testFinished name='A Template product test case - std::vector<int>' duration="{duration}"]
+##teamcity[testStarted name='A Template product test case with array signature - Bar<float, 42>']
+##teamcity[testFinished name='A Template product test case with array signature - Bar<float, 42>' duration="{duration}"]
+##teamcity[testStarted name='A Template product test case with array signature - Bar<int, 9>']
+##teamcity[testFinished name='A Template product test case with array signature - Bar<int, 9>' duration="{duration}"]
+##teamcity[testStarted name='A Template product test case with array signature - std::array<float, 42>']
+##teamcity[testFinished name='A Template product test case with array signature - std::array<float, 42>' duration="{duration}"]
+##teamcity[testStarted name='A Template product test case with array signature - std::array<int, 9>']
+##teamcity[testFinished name='A Template product test case with array signature - std::array<int, 9>' duration="{duration}"]
+##teamcity[testStarted name='A comparison that uses literals instead of the normal constructor']
+##teamcity[testFinished name='A comparison that uses literals instead of the normal constructor' duration="{duration}"]
+##teamcity[testStarted name='A couple of nested sections followed by a failure']
+Misc.tests.cpp:<line number>|nexplicit failure with message:|n  "to infinity and beyond"']
+##teamcity[testFinished name='A couple of nested sections followed by a failure' duration="{duration}"]
+##teamcity[testStarted name='A failing expression with a non streamable type is still captured']
+Tricky.tests.cpp:<line number>|nexpression failed|n  CHECK( &o1 == &o2 )|nwith expansion:|n  0x<hex digits> == 0x<hex digits>|n']
+Tricky.tests.cpp:<line number>|nexpression failed|n  CHECK( o1 == o2 )|nwith expansion:|n  {?} == {?}|n']
+##teamcity[testFinished name='A failing expression with a non streamable type is still captured' duration="{duration}"]
+##teamcity[testStarted name='Absolute margin']
+##teamcity[testFinished name='Absolute margin' duration="{duration}"]
+##teamcity[testStarted name='An empty test with no assertions']
+##teamcity[testFinished name='An empty test with no assertions' duration="{duration}"]
+##teamcity[testStarted name='An expression with side-effects should only be evaluated once']
+##teamcity[testFinished name='An expression with side-effects should only be evaluated once' duration="{duration}"]
+##teamcity[testStarted name='An unchecked exception reports the line of the last assertion']
+Exception.tests.cpp:<line number>|nunexpected exception with message:|n  "unexpected exception"|n  {Unknown expression after the reported line}|nwith expansion:|n  {Unknown expression after the reported line}|n']
+##teamcity[testFinished name='An unchecked exception reports the line of the last assertion' duration="{duration}"]
+##teamcity[testStarted name='Anonymous test case 1']
+##teamcity[testFinished name='Anonymous test case 1' duration="{duration}"]
+##teamcity[testStarted name='Approx setters validate their arguments']
+##teamcity[testFinished name='Approx setters validate their arguments' duration="{duration}"]
+##teamcity[testStarted name='Approx with exactly-representable margin']
+##teamcity[testFinished name='Approx with exactly-representable margin' duration="{duration}"]
+##teamcity[testStarted name='Approximate PI']
+##teamcity[testFinished name='Approximate PI' duration="{duration}"]
+##teamcity[testStarted name='Approximate comparisons with different epsilons']
+##teamcity[testFinished name='Approximate comparisons with different epsilons' duration="{duration}"]
+##teamcity[testStarted name='Approximate comparisons with floats']
+##teamcity[testFinished name='Approximate comparisons with floats' duration="{duration}"]
+##teamcity[testStarted name='Approximate comparisons with ints']
+##teamcity[testFinished name='Approximate comparisons with ints' duration="{duration}"]
+##teamcity[testStarted name='Approximate comparisons with mixed numeric types']
+##teamcity[testFinished name='Approximate comparisons with mixed numeric types' duration="{duration}"]
+##teamcity[testStarted name='Arbitrary predicate matcher']
+##teamcity[testFinished name='Arbitrary predicate matcher' duration="{duration}"]
+##teamcity[testStarted name='Assertions then sections']
+##teamcity[testFinished name='Assertions then sections' duration="{duration}"]
+##teamcity[testStarted name='CAPTURE can deal with complex expressions']
+##teamcity[testFinished name='CAPTURE can deal with complex expressions' duration="{duration}"]
+##teamcity[testStarted name='CAPTURE can deal with complex expressions involving commas']
+##teamcity[testFinished name='CAPTURE can deal with complex expressions involving commas' duration="{duration}"]
+##teamcity[testStarted name='CAPTURE parses string and character constants']
+##teamcity[testFinished name='CAPTURE parses string and character constants' duration="{duration}"]
+##teamcity[testStarted name='Capture and info messages']
+##teamcity[testFinished name='Capture and info messages' duration="{duration}"]
+##teamcity[testStarted name='Character pretty printing']
+##teamcity[testFinished name='Character pretty printing' duration="{duration}"]
+##teamcity[testStarted name='Commas in various macros are allowed']
+##teamcity[testFinished name='Commas in various macros are allowed' duration="{duration}"]
+##teamcity[testStarted name='Comparing function pointers']
+##teamcity[testFinished name='Comparing function pointers' duration="{duration}"]
+##teamcity[testStarted name='Comparison ops']
+##teamcity[testFinished name='Comparison ops' duration="{duration}"]
+##teamcity[testStarted name='Comparison with explicitly convertible types']
+##teamcity[testFinished name='Comparison with explicitly convertible types' duration="{duration}"]
+##teamcity[testStarted name='Comparisons between ints where one side is computed']
+##teamcity[testFinished name='Comparisons between ints where one side is computed' duration="{duration}"]
+##teamcity[testStarted name='Comparisons between unsigned ints and negative signed ints match c++ standard behaviour']
+##teamcity[testFinished name='Comparisons between unsigned ints and negative signed ints match c++ standard behaviour' duration="{duration}"]
+##teamcity[testStarted name='Comparisons with int literals don|'t warn when mixing signed/ unsigned']
+##teamcity[testFinished name='Comparisons with int literals don|'t warn when mixing signed/ unsigned' duration="{duration}"]
+##teamcity[testStarted name='Contains string matcher']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( testStringForMatching(), Contains("not there", Catch::CaseSensitive::No) )|nwith expansion:|n  "this string contains |'abc|' as a substring" contains: "not there" (case insensitive)|n']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( testStringForMatching(), Contains("STRING") )|nwith expansion:|n  "this string contains |'abc|' as a substring" contains: "STRING"|n']
+##teamcity[testFinished name='Contains string matcher' duration="{duration}"]
+##teamcity[testStarted name='Copy and then generate a range']
+##teamcity[testFinished name='Copy and then generate a range' duration="{duration}"]
+##teamcity[testStarted name='Custom exceptions can be translated when testing for nothrow']
+Exception.tests.cpp:<line number>|nunexpected exception with message:|n  "custom exception - not std"|n  REQUIRE_NOTHROW( throwCustom() )|nwith expansion:|n  throwCustom()|n']
+##teamcity[testFinished name='Custom exceptions can be translated when testing for nothrow' duration="{duration}"]
+##teamcity[testStarted name='Custom exceptions can be translated when testing for throwing as something else']
+Exception.tests.cpp:<line number>|nunexpected exception with message:|n  "custom exception - not std"|n  REQUIRE_THROWS_AS( throwCustom(), std::exception )|nwith expansion:|n  throwCustom(), std::exception|n']
+##teamcity[testFinished name='Custom exceptions can be translated when testing for throwing as something else' duration="{duration}"]
+##teamcity[testStarted name='Custom std-exceptions can be custom translated']
+Exception.tests.cpp:<line number>|nunexpected exception with message:|n  "custom std exception"']
+##teamcity[testFinished name='Custom std-exceptions can be custom translated' duration="{duration}"]
+##teamcity[testStarted name='Default scale is invisible to comparison']
+##teamcity[testFinished name='Default scale is invisible to comparison' duration="{duration}"]
+##teamcity[testStarted name='Directly creating an EnumInfo']
+##teamcity[testFinished name='Directly creating an EnumInfo' duration="{duration}"]
+##teamcity[testStarted name='EndsWith string matcher']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( testStringForMatching(), EndsWith("Substring") )|nwith expansion:|n  "this string contains |'abc|' as a substring" ends with: "Substring"|n']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( testStringForMatching(), EndsWith("this", Catch::CaseSensitive::No) )|nwith expansion:|n  "this string contains |'abc|' as a substring" ends with: "this" (case insensitive)|n']
+##teamcity[testFinished name='EndsWith string matcher' duration="{duration}"]
+##teamcity[testStarted name='Enums can quickly have stringification enabled using REGISTER_ENUM']
+##teamcity[testFinished name='Enums can quickly have stringification enabled using REGISTER_ENUM' duration="{duration}"]
+##teamcity[testStarted name='Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM']
+##teamcity[testFinished name='Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM' duration="{duration}"]
+##teamcity[testStarted name='Epsilon only applies to Approx|'s value']
+##teamcity[testFinished name='Epsilon only applies to Approx|'s value' duration="{duration}"]
+##teamcity[testStarted name='Equality checks that should fail']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven == 6 )|nwith expansion:|n  7 == 6|n- failure ignore as test marked as |'ok to fail|'|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven == 8 )|nwith expansion:|n  7 == 8|n- failure ignore as test marked as |'ok to fail|'|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven == 0 )|nwith expansion:|n  7 == 0|n- failure ignore as test marked as |'ok to fail|'|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one == Approx( 9.11f ) )|nwith expansion:|n  9.1f == Approx( 9.1099996567 )|n- failure ignore as test marked as |'ok to fail|'|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one == Approx( 9.0f ) )|nwith expansion:|n  9.1f == Approx( 9.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one == Approx( 1 ) )|nwith expansion:|n  9.1f == Approx( 1.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one == Approx( 0 ) )|nwith expansion:|n  9.1f == Approx( 0.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.double_pi == Approx( 3.1415 ) )|nwith expansion:|n  3.1415926535 == Approx( 3.1415 )|n- failure ignore as test marked as |'ok to fail|'|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello == "goodbye" )|nwith expansion:|n  "hello" == "goodbye"|n- failure ignore as test marked as |'ok to fail|'|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello == "hell" )|nwith expansion:|n  "hello" == "hell"|n- failure ignore as test marked as |'ok to fail|'|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello == "hello1" )|nwith expansion:|n  "hello" == "hello1"|n- failure ignore as test marked as |'ok to fail|'|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello.size() == 6 )|nwith expansion:|n  5 == 6|n- failure ignore as test marked as |'ok to fail|'|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( x == Approx( 1.301 ) )|nwith expansion:|n  1.3 == Approx( 1.301 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testFinished name='Equality checks that should fail' duration="{duration}"]
+##teamcity[testStarted name='Equality checks that should succeed']
+##teamcity[testFinished name='Equality checks that should succeed' duration="{duration}"]
+##teamcity[testStarted name='Equals']
+##teamcity[testFinished name='Equals' duration="{duration}"]
+##teamcity[testStarted name='Equals string matcher']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( testStringForMatching(), Equals("this string contains |'ABC|' as a substring") )|nwith expansion:|n  "this string contains |'abc|' as a substring" equals: "this string contains |'ABC|' as a substring"|n']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( testStringForMatching(), Equals("something else", Catch::CaseSensitive::No) )|nwith expansion:|n  "this string contains |'abc|' as a substring" equals: "something else" (case insensitive)|n']
+##teamcity[testFinished name='Equals string matcher' duration="{duration}"]
+##teamcity[testStarted name='Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified']
+##teamcity[testFinished name='Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified' duration="{duration}"]
+##teamcity[testStarted name='Exception matchers that fail']
+Matchers.tests.cpp:<line number>|nno exception was thrown where one was expected|n  CHECK_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{1} )|nwith expansion:|n  doesNotThrow(), SpecialException, ExceptionMatcher{1}|n']
+Matchers.tests.cpp:<line number>|nno exception was thrown where one was expected|n  REQUIRE_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{1} )|nwith expansion:|n  doesNotThrow(), SpecialException, ExceptionMatcher{1}|n']
+Matchers.tests.cpp:<line number>|nunexpected exception with message:|n  "Unknown exception"|n  CHECK_THROWS_MATCHES( throwsAsInt(1), SpecialException, ExceptionMatcher{1} )|nwith expansion:|n  throwsAsInt(1), SpecialException, ExceptionMatcher{1}|n']
+Matchers.tests.cpp:<line number>|nunexpected exception with message:|n  "Unknown exception"|n  REQUIRE_THROWS_MATCHES( throwsAsInt(1), SpecialException, ExceptionMatcher{1} )|nwith expansion:|n  throwsAsInt(1), SpecialException, ExceptionMatcher{1}|n']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THROWS_MATCHES( throwsSpecialException(3), SpecialException, ExceptionMatcher{1} )|nwith expansion:|n  SpecialException::what special exception has value of 1|n']
+Matchers.tests.cpp:<line number>|nexpression failed|n  REQUIRE_THROWS_MATCHES( throwsSpecialException(4), SpecialException, ExceptionMatcher{1} )|nwith expansion:|n  SpecialException::what special exception has value of 1|n']
+##teamcity[testFinished name='Exception matchers that fail' duration="{duration}"]
+##teamcity[testStarted name='Exception matchers that succeed']
+##teamcity[testFinished name='Exception matchers that succeed' duration="{duration}"]
+##teamcity[testStarted name='Exception messages can be tested for']
+##teamcity[testFinished name='Exception messages can be tested for' duration="{duration}"]
+##teamcity[testStarted name='Exceptions matchers']
+##teamcity[testFinished name='Exceptions matchers' duration="{duration}"]
+##teamcity[testStarted name='Expected exceptions that don|'t throw or unexpected exceptions fail the test']
+Exception.tests.cpp:<line number>|nunexpected exception with message:|n  "expected exception"|n  CHECK_THROWS_AS( thisThrows(), std::string )|nwith expansion:|n  thisThrows(), std::string|n']
+Exception.tests.cpp:<line number>|nno exception was thrown where one was expected|n  CHECK_THROWS_AS( thisDoesntThrow(), std::domain_error )|nwith expansion:|n  thisDoesntThrow(), std::domain_error|n']
+Exception.tests.cpp:<line number>|nunexpected exception with message:|n  "expected exception"|n  CHECK_NOTHROW( thisThrows() )|nwith expansion:|n  thisThrows()|n']
+##teamcity[testFinished name='Expected exceptions that don|'t throw or unexpected exceptions fail the test' duration="{duration}"]
+##teamcity[testStarted name='FAIL aborts the test']
+Message.tests.cpp:<line number>|nexplicit failure with message:|n  "This is a failure"']
+##teamcity[testFinished name='FAIL aborts the test' duration="{duration}"]
+##teamcity[testStarted name='FAIL does not require an argument']
+Message.tests.cpp:<line number>|nexplicit failure']
+##teamcity[testFinished name='FAIL does not require an argument' duration="{duration}"]
+##teamcity[testStarted name='FAIL_CHECK does not abort the test']
+Message.tests.cpp:<line number>|nexplicit failure with message:|n  "This is a failure"']
+##teamcity[testFinished name='FAIL_CHECK does not abort the test' duration="{duration}"]
+##teamcity[testStarted name='Factorials are computed']
+##teamcity[testFinished name='Factorials are computed' duration="{duration}"]
+##teamcity[testStarted name='Floating point matchers: double']
+##teamcity[testFinished name='Floating point matchers: double' duration="{duration}"]
+##teamcity[testStarted name='Floating point matchers: float']
+##teamcity[testFinished name='Floating point matchers: float' duration="{duration}"]
+##teamcity[testStarted name='Generators -- adapters']
+##teamcity[testFinished name='Generators -- adapters' duration="{duration}"]
+##teamcity[testStarted name='Generators -- simple']
+##teamcity[testFinished name='Generators -- simple' duration="{duration}"]
+##teamcity[testStarted name='Generators internals']
+##teamcity[testFinished name='Generators internals' duration="{duration}"]
+##teamcity[testStarted name='Greater-than inequalities with different epsilons']
+##teamcity[testFinished name='Greater-than inequalities with different epsilons' duration="{duration}"]
+##teamcity[testStarted name='INFO and WARN do not abort tests']
+##teamcity[testFinished name='INFO and WARN do not abort tests' duration="{duration}"]
+##teamcity[testStarted name='INFO gets logged on failure']
+Message.tests.cpp:<line number>|nexpression failed with messages:|n  "this message should be logged"|n  "so should this"|n  REQUIRE( a == 1 )|nwith expansion:|n  2 == 1|n']
+##teamcity[testFinished name='INFO gets logged on failure' duration="{duration}"]
+##teamcity[testStarted name='INFO gets logged on failure, even if captured before successful assertions']
+Message.tests.cpp:<line number>|nexpression failed with messages:|n  "this message may be logged later"|n  "this message should be logged"|n  CHECK( a == 1 )|nwith expansion:|n  2 == 1|n']
+Message.tests.cpp:<line number>|nexpression failed with messages:|n  "this message may be logged later"|n  "this message should be logged"|n  "and this, but later"|n  CHECK( a == 0 )|nwith expansion:|n  2 == 0|n']
+##teamcity[testFinished name='INFO gets logged on failure, even if captured before successful assertions' duration="{duration}"]
+##teamcity[testStarted name='INFO is reset for each loop']
+Message.tests.cpp:<line number>|nexpression failed with messages:|n  "current counter 10"|n  "i := 10"|n  REQUIRE( i < 10 )|nwith expansion:|n  10 < 10|n']
+##teamcity[testFinished name='INFO is reset for each loop' duration="{duration}"]
+##teamcity[testStarted name='Inequality checks that should fail']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven != 7 )|nwith expansion:|n  7 != 7|n- failure ignore as test marked as |'ok to fail|'|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one != Approx( 9.1f ) )|nwith expansion:|n  9.1f != Approx( 9.1000003815 )|n- failure ignore as test marked as |'ok to fail|'|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.double_pi != Approx( 3.1415926535 ) )|nwith expansion:|n  3.1415926535 != Approx( 3.1415926535 )|n- failure ignore as test marked as |'ok to fail|'|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello != "hello" )|nwith expansion:|n  "hello" != "hello"|n- failure ignore as test marked as |'ok to fail|'|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello.size() != 5 )|nwith expansion:|n  5 != 5|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testFinished name='Inequality checks that should fail' duration="{duration}"]
+##teamcity[testStarted name='Inequality checks that should succeed']
+##teamcity[testFinished name='Inequality checks that should succeed' duration="{duration}"]
+##teamcity[testStarted name='Less-than inequalities with different epsilons']
+##teamcity[testFinished name='Less-than inequalities with different epsilons' duration="{duration}"]
+##teamcity[testStarted name='ManuallyRegistered']
+##teamcity[testFinished name='ManuallyRegistered' duration="{duration}"]
+##teamcity[testStarted name='Matchers can be (AllOf) composed with the && operator']
+##teamcity[testFinished name='Matchers can be (AllOf) composed with the && operator' duration="{duration}"]
+##teamcity[testStarted name='Matchers can be (AnyOf) composed with the |||| operator']
+##teamcity[testFinished name='Matchers can be (AnyOf) composed with the |||| operator' duration="{duration}"]
+##teamcity[testStarted name='Matchers can be composed with both && and ||||']
+##teamcity[testFinished name='Matchers can be composed with both && and ||||' duration="{duration}"]
+##teamcity[testStarted name='Matchers can be composed with both && and |||| - failing']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( testStringForMatching(), (Contains("string") |||| Contains("different")) && Contains("random") )|nwith expansion:|n  "this string contains |'abc|' as a substring" ( ( contains: "string" or contains: "different" ) and contains: "random" )|n']
+##teamcity[testFinished name='Matchers can be composed with both && and |||| - failing' duration="{duration}"]
+##teamcity[testStarted name='Matchers can be negated (Not) with the ! operator']
+##teamcity[testFinished name='Matchers can be negated (Not) with the ! operator' duration="{duration}"]
+##teamcity[testStarted name='Matchers can be negated (Not) with the ! operator - failing']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( testStringForMatching(), !Contains("substring") )|nwith expansion:|n  "this string contains |'abc|' as a substring" not contains: "substring"|n']
+##teamcity[testFinished name='Matchers can be negated (Not) with the ! operator - failing' duration="{duration}"]
+##teamcity[testStarted name='Mismatching exception messages failing the test']
+Exception.tests.cpp:<line number>|nexpression failed|n  REQUIRE_THROWS_WITH( thisThrows(), "should fail" )|nwith expansion:|n  "expected exception" equals: "should fail"|n']
+##teamcity[testFinished name='Mismatching exception messages failing the test' duration="{duration}"]
+##teamcity[testStarted name='Nested generators and captured variables']
+##teamcity[testFinished name='Nested generators and captured variables' duration="{duration}"]
+##teamcity[testStarted name='Nice descriptive name']
+##teamcity[testFinished name='Nice descriptive name' duration="{duration}"]
+##teamcity[testStarted name='Non-std exceptions can be translated']
+Exception.tests.cpp:<line number>|nunexpected exception with message:|n  "custom exception"']
+##teamcity[testFinished name='Non-std exceptions can be translated' duration="{duration}"]
+##teamcity[testStarted name='Objects that evaluated in boolean contexts can be checked']
+##teamcity[testFinished name='Objects that evaluated in boolean contexts can be checked' duration="{duration}"]
+##teamcity[testStarted name='Optionally static assertions']
+##teamcity[testFinished name='Optionally static assertions' duration="{duration}"]
+##teamcity[testStarted name='Ordering comparison checks that should fail']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven > 7 )|nwith expansion:|n  7 > 7|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven < 7 )|nwith expansion:|n  7 < 7|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven > 8 )|nwith expansion:|n  7 > 8|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven < 6 )|nwith expansion:|n  7 < 6|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven < 0 )|nwith expansion:|n  7 < 0|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven < -1 )|nwith expansion:|n  7 < -1|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven >= 8 )|nwith expansion:|n  7 >= 8|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.int_seven <= 6 )|nwith expansion:|n  7 <= 6|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one < 9 )|nwith expansion:|n  9.1f < 9|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one > 10 )|nwith expansion:|n  9.1f > 10|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.float_nine_point_one > 9.2 )|nwith expansion:|n  9.1f > 9.2|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello > "hello" )|nwith expansion:|n  "hello" > "hello"|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello < "hello" )|nwith expansion:|n  "hello" < "hello"|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello > "hellp" )|nwith expansion:|n  "hello" > "hellp"|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello > "z" )|nwith expansion:|n  "hello" > "z"|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello < "hellm" )|nwith expansion:|n  "hello" < "hellm"|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello < "a" )|nwith expansion:|n  "hello" < "a"|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello >= "z" )|nwith expansion:|n  "hello" >= "z"|n']
+Condition.tests.cpp:<line number>|nexpression failed|n  CHECK( data.str_hello <= "a" )|nwith expansion:|n  "hello" <= "a"|n']
+##teamcity[testFinished name='Ordering comparison checks that should fail' duration="{duration}"]
+##teamcity[testStarted name='Ordering comparison checks that should succeed']
+##teamcity[testFinished name='Ordering comparison checks that should succeed' duration="{duration}"]
+##teamcity[testStarted name='Our PCG implementation provides expected results for known seeds']
+##teamcity[testFinished name='Our PCG implementation provides expected results for known seeds' duration="{duration}"]
+##teamcity[testStarted name='Output from all sections is reported']
+Message.tests.cpp:<line number>|nexplicit failure with message:|n  "Message from section one"']
+Message.tests.cpp:<line number>|nexplicit failure with message:|n  "Message from section two"']
+##teamcity[testFinished name='Output from all sections is reported' duration="{duration}"]
+##teamcity[testStarted name='Parse test names and tags']
+##teamcity[testFinished name='Parse test names and tags' duration="{duration}"]
+##teamcity[testStarted name='Pointers can be compared to null']
+##teamcity[testFinished name='Pointers can be compared to null' duration="{duration}"]
+##teamcity[testStarted name='Precision of floating point stringification can be set']
+##teamcity[testFinished name='Precision of floating point stringification can be set' duration="{duration}"]
+##teamcity[testStarted name='Predicate matcher can accept const char*']
+##teamcity[testFinished name='Predicate matcher can accept const char*' duration="{duration}"]
+##teamcity[testStarted name='Process can be configured on command line']
+##teamcity[testFinished name='Process can be configured on command line' duration="{duration}"]
+##teamcity[testStarted name='Product with differing arities - std::tuple<int, double, float>']
+##teamcity[testFinished name='Product with differing arities - std::tuple<int, double, float>' duration="{duration}"]
+##teamcity[testStarted name='Product with differing arities - std::tuple<int, double>']
+##teamcity[testFinished name='Product with differing arities - std::tuple<int, double>' duration="{duration}"]
+##teamcity[testStarted name='Product with differing arities - std::tuple<int>']
+##teamcity[testFinished name='Product with differing arities - std::tuple<int>' duration="{duration}"]
+##teamcity[testStarted name='Reconstruction should be based on stringification: #914']
+Decomposition.tests.cpp:<line number>|nexpression failed|n  CHECK( truthy(false) )|nwith expansion:|n  Hey, its truthy!|n']
+##teamcity[testFinished name='Reconstruction should be based on stringification: #914' duration="{duration}"]
+##teamcity[testStarted name='Regex string matcher']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( testStringForMatching(), Matches("this STRING contains |'abc|' as a substring") )|nwith expansion:|n  "this string contains |'abc|' as a substring" matches "this STRING contains |'abc|' as a substring" case sensitively|n']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( testStringForMatching(), Matches("contains |'abc|' as a substring") )|nwith expansion:|n  "this string contains |'abc|' as a substring" matches "contains |'abc|' as a substring" case sensitively|n']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( testStringForMatching(), Matches("this string contains |'abc|' as a") )|nwith expansion:|n  "this string contains |'abc|' as a substring" matches "this string contains |'abc|' as a" case sensitively|n']
+##teamcity[testFinished name='Regex string matcher' duration="{duration}"]
+##teamcity[testStarted name='Regression test #1']
+##teamcity[testFinished name='Regression test #1' duration="{duration}"]
+##teamcity[testStarted name='SUCCEED counts as a test pass']
+##teamcity[testFinished name='SUCCEED counts as a test pass' duration="{duration}"]
+##teamcity[testStarted name='SUCCEED does not require an argument']
+##teamcity[testFinished name='SUCCEED does not require an argument' duration="{duration}"]
+##teamcity[testStarted name='Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods']
+##teamcity[testFinished name='Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods' duration="{duration}"]
+##teamcity[testStarted name='Scenario: Do that thing with the thing']
+##teamcity[testFinished name='Scenario: Do that thing with the thing' duration="{duration}"]
+##teamcity[testStarted name='Scenario: This is a really long scenario name to see how the list command deals with wrapping']
+##teamcity[testFinished name='Scenario: This is a really long scenario name to see how the list command deals with wrapping' duration="{duration}"]
+##teamcity[testStarted name='Scenario: Vector resizing affects size and capacity']
+##teamcity[testFinished name='Scenario: Vector resizing affects size and capacity' duration="{duration}"]
+##teamcity[testStarted name='Sends stuff to stdout and stderr']
+##teamcity[testStdOut name='Sends stuff to stdout and stderr' out='A string sent directly to stdout|n']
+##teamcity[testStdErr name='Sends stuff to stdout and stderr' out='A string sent directly to stderr|nA string sent to stderr via clog|n']
+##teamcity[testFinished name='Sends stuff to stdout and stderr' duration="{duration}"]
+##teamcity[testStarted name='Some simple comparisons between doubles']
+##teamcity[testFinished name='Some simple comparisons between doubles' duration="{duration}"]
+##teamcity[testStarted name='Standard output from all sections is reported']
+##teamcity[testStdOut name='Standard output from all sections is reported' out='Message from section one|nMessage from section two|n']
+##teamcity[testFinished name='Standard output from all sections is reported' duration="{duration}"]
+##teamcity[testStarted name='StartsWith string matcher']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( testStringForMatching(), StartsWith("This String") )|nwith expansion:|n  "this string contains |'abc|' as a substring" starts with: "This String"|n']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( testStringForMatching(), StartsWith("string", Catch::CaseSensitive::No) )|nwith expansion:|n  "this string contains |'abc|' as a substring" starts with: "string" (case insensitive)|n']
+##teamcity[testFinished name='StartsWith string matcher' duration="{duration}"]
+##teamcity[testStarted name='Static arrays are convertible to string']
+##teamcity[testFinished name='Static arrays are convertible to string' duration="{duration}"]
+##teamcity[testStarted name='String matchers']
+##teamcity[testFinished name='String matchers' duration="{duration}"]
+##teamcity[testStarted name='StringRef']
+##teamcity[testFinished name='StringRef' duration="{duration}"]
+##teamcity[testStarted name='StringRef at compilation time']
+##teamcity[testFinished name='StringRef at compilation time' duration="{duration}"]
+##teamcity[testStarted name='Stringifying std::chrono::duration helpers']
+##teamcity[testFinished name='Stringifying std::chrono::duration helpers' duration="{duration}"]
+##teamcity[testStarted name='Stringifying std::chrono::duration with weird ratios']
+##teamcity[testFinished name='Stringifying std::chrono::duration with weird ratios' duration="{duration}"]
+##teamcity[testStarted name='Stringifying std::chrono::time_point<system_clock>']
+##teamcity[testFinished name='Stringifying std::chrono::time_point<system_clock>' duration="{duration}"]
+##teamcity[testStarted name='Tabs and newlines show in output']
+Misc.tests.cpp:<line number>|nexpression failed|n  CHECK( s1 == s2 )|nwith expansion:|n  "if ($b == 10) {|n		$a	= 20;|n}"|n==|n"if ($b == 10) {|n	$a = 20;|n}|n"|n']
+##teamcity[testFinished name='Tabs and newlines show in output' duration="{duration}"]
+##teamcity[testStarted name='Tag alias can be registered against tag patterns']
+##teamcity[testFinished name='Tag alias can be registered against tag patterns' duration="{duration}"]
+##teamcity[testStarted name='Template test case method with test types specified inside std::tuple - MyTypes - 0']
+##teamcity[testFinished name='Template test case method with test types specified inside std::tuple - MyTypes - 0' duration="{duration}"]
+##teamcity[testStarted name='Template test case method with test types specified inside std::tuple - MyTypes - 1']
+##teamcity[testFinished name='Template test case method with test types specified inside std::tuple - MyTypes - 1' duration="{duration}"]
+##teamcity[testStarted name='Template test case method with test types specified inside std::tuple - MyTypes - 2']
+##teamcity[testFinished name='Template test case method with test types specified inside std::tuple - MyTypes - 2' duration="{duration}"]
+##teamcity[testStarted name='Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 0']
+##teamcity[testFinished name='Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 0' duration="{duration}"]
+##teamcity[testStarted name='Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 1']
+##teamcity[testFinished name='Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 1' duration="{duration}"]
+##teamcity[testStarted name='Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 0']
+##teamcity[testFinished name='Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 0' duration="{duration}"]
+##teamcity[testStarted name='Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 1']
+##teamcity[testFinished name='Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 1' duration="{duration}"]
+##teamcity[testStarted name='Template test case with test types specified inside std::tuple - MyTypes - 0']
+##teamcity[testFinished name='Template test case with test types specified inside std::tuple - MyTypes - 0' duration="{duration}"]
+##teamcity[testStarted name='Template test case with test types specified inside std::tuple - MyTypes - 1']
+##teamcity[testFinished name='Template test case with test types specified inside std::tuple - MyTypes - 1' duration="{duration}"]
+##teamcity[testStarted name='Template test case with test types specified inside std::tuple - MyTypes - 2']
+##teamcity[testFinished name='Template test case with test types specified inside std::tuple - MyTypes - 2' duration="{duration}"]
+##teamcity[testStarted name='TemplateTest: vectors can be sized and resized - float']
+##teamcity[testFinished name='TemplateTest: vectors can be sized and resized - float' duration="{duration}"]
+##teamcity[testStarted name='TemplateTest: vectors can be sized and resized - int']
+##teamcity[testFinished name='TemplateTest: vectors can be sized and resized - int' duration="{duration}"]
+##teamcity[testStarted name='TemplateTest: vectors can be sized and resized - std::string']
+##teamcity[testFinished name='TemplateTest: vectors can be sized and resized - std::string' duration="{duration}"]
+##teamcity[testStarted name='TemplateTest: vectors can be sized and resized - std::tuple<int,float>']
+##teamcity[testFinished name='TemplateTest: vectors can be sized and resized - std::tuple<int,float>' duration="{duration}"]
+##teamcity[testStarted name='TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6']
+##teamcity[testFinished name='TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6' duration="{duration}"]
+##teamcity[testStarted name='TemplateTestSig: vectors can be sized and resized - float,4']
+##teamcity[testFinished name='TemplateTestSig: vectors can be sized and resized - float,4' duration="{duration}"]
+##teamcity[testStarted name='TemplateTestSig: vectors can be sized and resized - int,5']
+##teamcity[testFinished name='TemplateTestSig: vectors can be sized and resized - int,5' duration="{duration}"]
+##teamcity[testStarted name='TemplateTestSig: vectors can be sized and resized - std::string,15']
+##teamcity[testFinished name='TemplateTestSig: vectors can be sized and resized - std::string,15' duration="{duration}"]
+##teamcity[testStarted name='Test case with one argument']
+##teamcity[testFinished name='Test case with one argument' duration="{duration}"]
+##teamcity[testStarted name='Test enum bit values']
+##teamcity[testFinished name='Test enum bit values' duration="{duration}"]
+##teamcity[testStarted name='Test with special, characters "in name']
+##teamcity[testFinished name='Test with special, characters "in name' duration="{duration}"]
+##teamcity[testStarted name='The NO_FAIL macro reports a failure but does not fail the test']
+##teamcity[testFinished name='The NO_FAIL macro reports a failure but does not fail the test' duration="{duration}"]
+##teamcity[testStarted name='This test |'should|' fail but doesn|'t']
+##teamcity[testFinished name='This test |'should|' fail but doesn|'t' duration="{duration}"]
+##teamcity[testStarted name='Thrown string literals are translated']
+Exception.tests.cpp:<line number>|nunexpected exception with message:|n  "For some reason someone is throwing a string literal!"']
+##teamcity[testFinished name='Thrown string literals are translated' duration="{duration}"]
+##teamcity[testStarted name='Tracker']
+##teamcity[testFinished name='Tracker' duration="{duration}"]
+##teamcity[testStarted name='Trim strings']
+##teamcity[testFinished name='Trim strings' duration="{duration}"]
+##teamcity[testStarted name='Unexpected exceptions can be translated']
+Exception.tests.cpp:<line number>|nunexpected exception with message:|n  "3.14"']
+##teamcity[testFinished name='Unexpected exceptions can be translated' duration="{duration}"]
+##teamcity[testStarted name='Use a custom approx']
+##teamcity[testFinished name='Use a custom approx' duration="{duration}"]
+##teamcity[testStarted name='Variadic macros']
+##teamcity[testFinished name='Variadic macros' duration="{duration}"]
+##teamcity[testStarted name='Vector Approx matcher']
+##teamcity[testFinished name='Vector Approx matcher' duration="{duration}"]
+##teamcity[testStarted name='Vector Approx matcher -- failing']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( empty, Approx(t1) )|nwith expansion:|n  {  } is approx: { 1.0, 2.0 }|n']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( v1, Approx(v2) )|nwith expansion:|n  { 2.0, 4.0, 6.0 } is approx: { 1.0, 3.0, 5.0 }|n']
+##teamcity[testFinished name='Vector Approx matcher -- failing' duration="{duration}"]
+##teamcity[testStarted name='Vector matchers']
+##teamcity[testFinished name='Vector matchers' duration="{duration}"]
+##teamcity[testStarted name='Vector matchers that fail']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( v, VectorContains(-1) )|nwith expansion:|n  { 1, 2, 3 } Contains: -1|n']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( empty, VectorContains(1) )|nwith expansion:|n  {  } Contains: 1|n']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( empty, Contains(v) )|nwith expansion:|n  {  } Contains: { 1, 2, 3 }|n']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( v, Contains(v2) )|nwith expansion:|n  { 1, 2, 3 } Contains: { 1, 2, 4 }|n']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( v, Equals(v2) )|nwith expansion:|n  { 1, 2, 3 } Equals: { 1, 2 }|n']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( v2, Equals(v) )|nwith expansion:|n  { 1, 2 } Equals: { 1, 2, 3 }|n']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( empty, Equals(v) )|nwith expansion:|n  {  } Equals: { 1, 2, 3 }|n']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( v, Equals(empty) )|nwith expansion:|n  { 1, 2, 3 } Equals: {  }|n']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( v, UnorderedEquals(empty) )|nwith expansion:|n  { 1, 2, 3 } UnorderedEquals: {  }|n']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( empty, UnorderedEquals(v) )|nwith expansion:|n  {  } UnorderedEquals: { 1, 2, 3 }|n']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( permuted, UnorderedEquals(v) )|nwith expansion:|n  { 1, 3 } UnorderedEquals: { 1, 2, 3 }|n']
+Matchers.tests.cpp:<line number>|nexpression failed|n  CHECK_THAT( permuted, UnorderedEquals(v) )|nwith expansion:|n  { 3, 1 } UnorderedEquals: { 1, 2, 3 }|n']
+##teamcity[testFinished name='Vector matchers that fail' duration="{duration}"]
+##teamcity[testStarted name='When checked exceptions are thrown they can be expected or unexpected']
+##teamcity[testFinished name='When checked exceptions are thrown they can be expected or unexpected' duration="{duration}"]
+##teamcity[testStarted name='When unchecked exceptions are thrown directly they are always failures']
+Exception.tests.cpp:<line number>|nunexpected exception with message:|n  "unexpected exception"']
+##teamcity[testFinished name='When unchecked exceptions are thrown directly they are always failures' duration="{duration}"]
+##teamcity[testStarted name='When unchecked exceptions are thrown during a CHECK the test should continue']
+Exception.tests.cpp:<line number>|nunexpected exception with message:|n  "expected exception"|n  CHECK( thisThrows() == 0 )|nwith expansion:|n  thisThrows() == 0|n']
+##teamcity[testFinished name='When unchecked exceptions are thrown during a CHECK the test should continue' duration="{duration}"]
+##teamcity[testStarted name='When unchecked exceptions are thrown during a REQUIRE the test should abort fail']
+Exception.tests.cpp:<line number>|nunexpected exception with message:|n  "expected exception"|n  REQUIRE( thisThrows() == 0 )|nwith expansion:|n  thisThrows() == 0|n']
+##teamcity[testFinished name='When unchecked exceptions are thrown during a REQUIRE the test should abort fail' duration="{duration}"]
+##teamcity[testStarted name='When unchecked exceptions are thrown from functions they are always failures']
+Exception.tests.cpp:<line number>|nunexpected exception with message:|n  "expected exception"|n  CHECK( thisThrows() == 0 )|nwith expansion:|n  thisThrows() == 0|n']
+##teamcity[testFinished name='When unchecked exceptions are thrown from functions they are always failures' duration="{duration}"]
+##teamcity[testStarted name='When unchecked exceptions are thrown from sections they are always failures']
+Exception.tests.cpp:<line number>|nunexpected exception with message:|n  "unexpected exception"']
+##teamcity[testFinished name='When unchecked exceptions are thrown from sections they are always failures' duration="{duration}"]
+##teamcity[testStarted name='When unchecked exceptions are thrown, but caught, they do not affect the test']
+##teamcity[testFinished name='When unchecked exceptions are thrown, but caught, they do not affect the test' duration="{duration}"]
+##teamcity[testStarted name='Where the LHS is not a simple value']
+##teamcity[testFinished name='Where the LHS is not a simple value' duration="{duration}"]
+##teamcity[testStarted name='Where there is more to the expression after the RHS']
+##teamcity[testFinished name='Where there is more to the expression after the RHS' duration="{duration}"]
+##teamcity[testStarted name='X/level/0/a']
+##teamcity[testFinished name='X/level/0/a' duration="{duration}"]
+##teamcity[testStarted name='X/level/0/b']
+##teamcity[testFinished name='X/level/0/b' duration="{duration}"]
+##teamcity[testStarted name='X/level/1/a']
+##teamcity[testFinished name='X/level/1/a' duration="{duration}"]
+##teamcity[testStarted name='X/level/1/b']
+##teamcity[testFinished name='X/level/1/b' duration="{duration}"]
+##teamcity[testStarted name='XmlEncode']
+##teamcity[testFinished name='XmlEncode' duration="{duration}"]
+##teamcity[testStarted name='array<int, N> -> toString']
+##teamcity[testFinished name='array<int, N> -> toString' duration="{duration}"]
+##teamcity[testStarted name='atomic if']
+##teamcity[testFinished name='atomic if' duration="{duration}"]
+##teamcity[testStarted name='boolean member']
+##teamcity[testFinished name='boolean member' duration="{duration}"]
+##teamcity[testStarted name='checkedElse']
+##teamcity[testFinished name='checkedElse' duration="{duration}"]
+##teamcity[testStarted name='checkedElse, failing']
+Misc.tests.cpp:<line number>|nexpression failed|n  CHECKED_ELSE( flag )|nwith expansion:|n  false|n']
+Misc.tests.cpp:<line number>|nexpression failed|n  REQUIRE( testCheckedElse( false ) )|nwith expansion:|n  false|n']
+##teamcity[testFinished name='checkedElse, failing' duration="{duration}"]
+##teamcity[testStarted name='checkedIf']
+##teamcity[testFinished name='checkedIf' duration="{duration}"]
+##teamcity[testStarted name='checkedIf, failing']
+Misc.tests.cpp:<line number>|nexpression failed|n  CHECKED_IF( flag )|nwith expansion:|n  false|n']
+Misc.tests.cpp:<line number>|nexpression failed|n  REQUIRE( testCheckedIf( false ) )|nwith expansion:|n  false|n']
+##teamcity[testFinished name='checkedIf, failing' duration="{duration}"]
+##teamcity[testStarted name='comparisons between const int variables']
+##teamcity[testFinished name='comparisons between const int variables' duration="{duration}"]
+##teamcity[testStarted name='comparisons between int variables']
+##teamcity[testFinished name='comparisons between int variables' duration="{duration}"]
+##teamcity[testStarted name='even more nested SECTION tests']
+##teamcity[testFinished name='even more nested SECTION tests' duration="{duration}"]
+##teamcity[testStarted name='first tag']
+##teamcity[testFinished name='first tag' duration="{duration}"]
+##teamcity[testStarted name='has printf']
+loose text artifact
+##teamcity[testFinished name='has printf' duration="{duration}"]
+##teamcity[testStarted name='just failure']
+Message.tests.cpp:<line number>|nexplicit failure with message:|n  "Previous info should not be seen"']
+##teamcity[testFinished name='just failure' duration="{duration}"]
+##teamcity[testStarted name='just failure after unscoped info']
+Message.tests.cpp:<line number>|nexplicit failure with message:|n  "previous unscoped info SHOULD not be seen"']
+##teamcity[testFinished name='just failure after unscoped info' duration="{duration}"]
+##teamcity[testStarted name='just info']
+##teamcity[testFinished name='just info' duration="{duration}"]
+##teamcity[testStarted name='just unscoped info']
+##teamcity[testFinished name='just unscoped info' duration="{duration}"]
+##teamcity[testStarted name='long long']
+##teamcity[testFinished name='long long' duration="{duration}"]
+##teamcity[testStarted name='looped SECTION tests']
+Misc.tests.cpp:<line number>|nexpression failed|n  CHECK( b > a )|nwith expansion:|n  0 > 1|n']
+Misc.tests.cpp:<line number>|nexpression failed|n  CHECK( b > a )|nwith expansion:|n  1 > 1|n']
+##teamcity[testFinished name='looped SECTION tests' duration="{duration}"]
+##teamcity[testStarted name='looped tests']
+Misc.tests.cpp:<line number>|nexpression failed with message:|n  "Testing if fib|[0|] (1) is even"|n  CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n  1 == 0|n']
+Misc.tests.cpp:<line number>|nexpression failed with message:|n  "Testing if fib|[1|] (1) is even"|n  CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n  1 == 0|n']
+Misc.tests.cpp:<line number>|nexpression failed with message:|n  "Testing if fib|[3|] (3) is even"|n  CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n  1 == 0|n']
+Misc.tests.cpp:<line number>|nexpression failed with message:|n  "Testing if fib|[4|] (5) is even"|n  CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n  1 == 0|n']
+Misc.tests.cpp:<line number>|nexpression failed with message:|n  "Testing if fib|[6|] (13) is even"|n  CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n  1 == 0|n']
+Misc.tests.cpp:<line number>|nexpression failed with message:|n  "Testing if fib|[7|] (21) is even"|n  CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n  1 == 0|n']
+##teamcity[testFinished name='looped tests' duration="{duration}"]
+##teamcity[testStarted name='mix info, unscoped info and warning']
+##teamcity[testFinished name='mix info, unscoped info and warning' duration="{duration}"]
+##teamcity[testStarted name='more nested SECTION tests']
+Misc.tests.cpp:<line number>|nexpression failed|n  REQUIRE( a == b )|nwith expansion:|n  1 == 2|n']
+##teamcity[testFinished name='more nested SECTION tests' duration="{duration}"]
+##teamcity[testStarted name='nested SECTION tests']
+##teamcity[testFinished name='nested SECTION tests' duration="{duration}"]
+##teamcity[testStarted name='non streamable - with conv. op']
+##teamcity[testFinished name='non streamable - with conv. op' duration="{duration}"]
+##teamcity[testStarted name='non-copyable objects']
+##teamcity[testFinished name='non-copyable objects' duration="{duration}"]
+##teamcity[testStarted name='not allowed']
+##teamcity[testFinished name='not allowed' duration="{duration}"]
+##teamcity[testStarted name='not prints unscoped info from previous failures']
+Message.tests.cpp:<line number>|nexpression failed with message:|n  "this SHOULD be seen"|n  REQUIRE( false )|nwith expansion:|n  false|n']
+##teamcity[testFinished name='not prints unscoped info from previous failures' duration="{duration}"]
+##teamcity[testStarted name='null strings']
+##teamcity[testFinished name='null strings' duration="{duration}"]
+##teamcity[testStarted name='null_ptr']
+##teamcity[testFinished name='null_ptr' duration="{duration}"]
+##teamcity[testStarted name='pair<pair<int,const char *,pair<std::string,int> > -> toString']
+##teamcity[testFinished name='pair<pair<int,const char *,pair<std::string,int> > -> toString' duration="{duration}"]
+##teamcity[testStarted name='parseEnums']
+##teamcity[testFinished name='parseEnums' duration="{duration}"]
+##teamcity[testStarted name='pointer to class']
+##teamcity[testFinished name='pointer to class' duration="{duration}"]
+##teamcity[testStarted name='print unscoped info if passing unscoped info is printed']
+##teamcity[testFinished name='print unscoped info if passing unscoped info is printed' duration="{duration}"]
+##teamcity[testStarted name='prints unscoped info on failure']
+Message.tests.cpp:<line number>|nexpression failed with messages:|n  "this SHOULD be seen"|n  "this SHOULD also be seen"|n  REQUIRE( false )|nwith expansion:|n  false|n']
+##teamcity[testFinished name='prints unscoped info on failure' duration="{duration}"]
+##teamcity[testStarted name='prints unscoped info only for the first assertion']
+Message.tests.cpp:<line number>|nexpression failed with message:|n  "this SHOULD be seen only ONCE"|n  CHECK( false )|nwith expansion:|n  false|n']
+##teamcity[testFinished name='prints unscoped info only for the first assertion' duration="{duration}"]
+##teamcity[testStarted name='random SECTION tests']
+##teamcity[testFinished name='random SECTION tests' duration="{duration}"]
+##teamcity[testStarted name='replaceInPlace']
+##teamcity[testFinished name='replaceInPlace' duration="{duration}"]
+##teamcity[testStarted name='second tag']
+##teamcity[testFinished name='second tag' duration="{duration}"]
+##teamcity[testStarted name='send a single char to INFO']
+Misc.tests.cpp:<line number>|nexpression failed with message:|n  "3"|n  REQUIRE( false )|nwith expansion:|n  false|n']
+##teamcity[testFinished name='send a single char to INFO' duration="{duration}"]
+##teamcity[testStarted name='sends information to INFO']
+Message.tests.cpp:<line number>|nexpression failed with messages:|n  "hi"|n  "i := 7"|n  REQUIRE( false )|nwith expansion:|n  false|n']
+##teamcity[testFinished name='sends information to INFO' duration="{duration}"]
+##teamcity[testStarted name='shortened hide tags are split apart']
+##teamcity[testFinished name='shortened hide tags are split apart' duration="{duration}"]
+##teamcity[testStarted name='splitString']
+##teamcity[testFinished name='splitString' duration="{duration}"]
+##teamcity[testStarted name='stacks unscoped info in loops']
+Message.tests.cpp:<line number>|nexpression failed with messages:|n  "Count 1 to 3..."|n  "1"|n  "2"|n  "3"|n  CHECK( false )|nwith expansion:|n  false|n']
+Message.tests.cpp:<line number>|nexpression failed with messages:|n  "Count 4 to 6..."|n  "4"|n  "5"|n  "6"|n  CHECK( false )|nwith expansion:|n  false|n']
+##teamcity[testFinished name='stacks unscoped info in loops' duration="{duration}"]
+##teamcity[testStarted name='std::map is convertible string']
+##teamcity[testFinished name='std::map is convertible string' duration="{duration}"]
+##teamcity[testStarted name='std::pair<int,const std::string> -> toString']
+##teamcity[testFinished name='std::pair<int,const std::string> -> toString' duration="{duration}"]
+##teamcity[testStarted name='std::pair<int,std::string> -> toString']
+##teamcity[testFinished name='std::pair<int,std::string> -> toString' duration="{duration}"]
+##teamcity[testStarted name='std::set is convertible string']
+##teamcity[testFinished name='std::set is convertible string' duration="{duration}"]
+##teamcity[testStarted name='std::vector<std::pair<std::string,int> > -> toString']
+##teamcity[testFinished name='std::vector<std::pair<std::string,int> > -> toString' duration="{duration}"]
+##teamcity[testStarted name='string literals of different sizes can be compared']
+Tricky.tests.cpp:<line number>|nexpression failed|n  REQUIRE( std::string( "first" ) == "second" )|nwith expansion:|n  "first" == "second"|n']
+##teamcity[testFinished name='string literals of different sizes can be compared' duration="{duration}"]
+##teamcity[testStarted name='stringify ranges']
+##teamcity[testFinished name='stringify ranges' duration="{duration}"]
+##teamcity[testStarted name='stringify( has_maker )']
+##teamcity[testFinished name='stringify( has_maker )' duration="{duration}"]
+##teamcity[testStarted name='stringify( has_maker_and_operator )']
+##teamcity[testFinished name='stringify( has_maker_and_operator )' duration="{duration}"]
+##teamcity[testStarted name='stringify( has_neither )']
+##teamcity[testFinished name='stringify( has_neither )' duration="{duration}"]
+##teamcity[testStarted name='stringify( has_operator )']
+##teamcity[testFinished name='stringify( has_operator )' duration="{duration}"]
+##teamcity[testStarted name='stringify( has_template_operator )']
+##teamcity[testFinished name='stringify( has_template_operator )' duration="{duration}"]
+##teamcity[testStarted name='stringify( vectors<has_maker> )']
+##teamcity[testFinished name='stringify( vectors<has_maker> )' duration="{duration}"]
+##teamcity[testStarted name='stringify( vectors<has_maker_and_operator> )']
+##teamcity[testFinished name='stringify( vectors<has_maker_and_operator> )' duration="{duration}"]
+##teamcity[testStarted name='stringify( vectors<has_operator> )']
+##teamcity[testFinished name='stringify( vectors<has_operator> )' duration="{duration}"]
+##teamcity[testStarted name='strlen3']
+##teamcity[testFinished name='strlen3' duration="{duration}"]
+##teamcity[testStarted name='tables']
+##teamcity[testFinished name='tables' duration="{duration}"]
+##teamcity[testStarted name='thrown std::strings are translated']
+Exception.tests.cpp:<line number>|nunexpected exception with message:|n  "Why would you throw a std::string?"']
+##teamcity[testFinished name='thrown std::strings are translated' duration="{duration}"]
+##teamcity[testStarted name='toString on const wchar_t const pointer returns the string contents']
+##teamcity[testFinished name='toString on const wchar_t const pointer returns the string contents' duration="{duration}"]
+##teamcity[testStarted name='toString on const wchar_t pointer returns the string contents']
+##teamcity[testFinished name='toString on const wchar_t pointer returns the string contents' duration="{duration}"]
+##teamcity[testStarted name='toString on wchar_t const pointer returns the string contents']
+##teamcity[testFinished name='toString on wchar_t const pointer returns the string contents' duration="{duration}"]
+##teamcity[testStarted name='toString on wchar_t returns the string contents']
+##teamcity[testFinished name='toString on wchar_t returns the string contents' duration="{duration}"]
+##teamcity[testStarted name='toString(enum class w/operator<<)']
+##teamcity[testFinished name='toString(enum class w/operator<<)' duration="{duration}"]
+##teamcity[testStarted name='toString(enum class)']
+##teamcity[testFinished name='toString(enum class)' duration="{duration}"]
+##teamcity[testStarted name='toString(enum w/operator<<)']
+##teamcity[testFinished name='toString(enum w/operator<<)' duration="{duration}"]
+##teamcity[testStarted name='toString(enum)']
+##teamcity[testFinished name='toString(enum)' duration="{duration}"]
+##teamcity[testStarted name='tuple<>']
+##teamcity[testFinished name='tuple<>' duration="{duration}"]
+##teamcity[testStarted name='tuple<float,int>']
+##teamcity[testFinished name='tuple<float,int>' duration="{duration}"]
+##teamcity[testStarted name='tuple<int>']
+##teamcity[testFinished name='tuple<int>' duration="{duration}"]
+##teamcity[testStarted name='tuple<0,int,const char *>']
+##teamcity[testFinished name='tuple<0,int,const char *>' duration="{duration}"]
+##teamcity[testStarted name='tuple<string,string>']
+##teamcity[testFinished name='tuple<string,string>' duration="{duration}"]
+##teamcity[testStarted name='tuple<tuple<int>,tuple<>,float>']
+##teamcity[testFinished name='tuple<tuple<int>,tuple<>,float>' duration="{duration}"]
+##teamcity[testStarted name='vec<vec<string,alloc>> -> toString']
+##teamcity[testFinished name='vec<vec<string,alloc>> -> toString' duration="{duration}"]
+##teamcity[testStarted name='vector<bool> -> toString']
+##teamcity[testFinished name='vector<bool> -> toString' duration="{duration}"]
+##teamcity[testStarted name='vector<int,allocator> -> toString']
+##teamcity[testFinished name='vector<int,allocator> -> toString' duration="{duration}"]
+##teamcity[testStarted name='vector<int> -> toString']
+##teamcity[testFinished name='vector<int> -> toString' duration="{duration}"]
+##teamcity[testStarted name='vector<string> -> toString']
+##teamcity[testFinished name='vector<string> -> toString' duration="{duration}"]
+##teamcity[testStarted name='vectors can be sized and resized']
+##teamcity[testFinished name='vectors can be sized and resized' duration="{duration}"]
+##teamcity[testStarted name='xmlentitycheck']
+##teamcity[testFinished name='xmlentitycheck' duration="{duration}"]
+##teamcity[testSuiteFinished name='<exe-name>']

tools/misc/appveyorBuildConfigurationScript.bat

@@ -10,7 +10,7 @@ if "%CONFIGURATION%"=="Debug" (
     @REM # coverage needs to build the special helper as well as the main
     cmake -Htools/misc -Bbuild-misc -A%PLATFORM% || exit /b !ERRORLEVEL!
     cmake --build build-misc || exit /b !ERRORLEVEL!
-    cmake -H. -BBuild -A%PLATFORM% -DUSE_WMAIN=%wmain% -DMEMORYCHECK_COMMAND=build-misc\Debug\CoverageHelper.exe -DMEMORYCHECK_COMMAND_OPTIONS=--sep-- -DMEMORYCHECK_TYPE=Valgrind || exit /b !ERRORLEVEL! || exit /b !ERRORLEVEL!
+    cmake -H. -BBuild -A%PLATFORM% -DUSE_WMAIN=%wmain% -DMEMORYCHECK_COMMAND=build-misc\Debug\CoverageHelper.exe -DMEMORYCHECK_COMMAND_OPTIONS=--sep-- -DMEMORYCHECK_TYPE=Valgrind -DCATCH_BUILD_EXAMPLES=%examples% -DCATCH_BUILD_EXTRA_TESTS=%examples% || exit /b !ERRORLEVEL!
   ) else (
     @REM # We know that coverage is 0
     cmake -H. -BBuild -A%PLATFORM% -DUSE_WMAIN=%wmain% -DCATCH_BUILD_EXAMPLES=%examples% -DCATCH_BUILD_EXTRA_TESTS=%examples% || exit /b !ERRORLEVEL!

tools/misc/coverage-helper.cpp

@@ -95,7 +95,7 @@ int exec_cmd(std::string const& cmd, int log_num, std::string const& path) {
 
     // cmd has already been escaped outside this function.
     auto real_cmd = "OpenCppCoverage --export_type binary:cov-report" + std::to_string(log_num)
-        + ".bin --quiet " + "--sources " + escape_arg(path) + " --cover_children -- " + cmd;
+        + ".bin --quiet " + "--sources " + escape_arg(path) + "\\src" + " --cover_children -- " + cmd;
     std::cout << "=== Marker ===: Cmd: " << real_cmd << '\n';
     auto pipe = _popen(real_cmd.c_str(), "r");
 

tools/scripts/approvalTests.py

@@ -29,7 +29,7 @@ filelocParser = re.compile(r'''
 lineNumberParser = re.compile(r' line="[0-9]*"')
 hexParser = re.compile(r'\b(0[xX][0-9a-fA-F]+)\b')
 durationsParser = re.compile(r' time="[0-9]*\.[0-9]*"')
-sonarqubeDurationParser = re.compile(r' duration="[0-9]+"')
+sonarqubeDurationParser = re.compile(r''' duration=["'][0-9]+["']''')
 timestampsParser = re.compile(r'\d{4}-\d{2}-\d{2}T\d{2}\:\d{2}\:\d{2}Z')
 versionParser = re.compile(r'Catch v[0-9]+\.[0-9]+\.[0-9]+(-\w*\.[0-9]+)?')
 nullParser = re.compile(r'\b(__null|nullptr)\b')
@@ -193,21 +193,19 @@ print("Running approvals against executable:")
 print("  " + cmdPath)
 
 
-# ## Keep default reporters here ##
+## special cases first:
 # Standard console reporter
 approve("console.std", ["~[!nonportable]~[!benchmark]~[approvals] *", "--order", "lex", "--rng-seed", "1"])
-# console reporter, include passes, warn about No Assertions
-approve("console.sw", ["~[!nonportable]~[!benchmark]~[approvals] *", "-s", "-w", "NoAssertions", "--order", "lex", "--rng-seed", "1"])
 # console reporter, include passes, warn about No Assertions, limit failures to first 4
 approve("console.swa4", ["~[!nonportable]~[!benchmark]~[approvals] *", "-s", "-w", "NoAssertions", "-x", "4", "--order", "lex", "--rng-seed", "1"])
-# junit reporter, include passes, warn about No Assertions
-approve("junit.sw", ["~[!nonportable]~[!benchmark]~[approvals] *", "-s", "-w", "NoAssertions", "-r", "junit", "--order", "lex", "--rng-seed", "1"])
-# xml reporter, include passes, warn about No Assertions
-approve("xml.sw", ["~[!nonportable]~[!benchmark]~[approvals] *", "-s", "-w", "NoAssertions", "-r", "xml", "--order", "lex", "--rng-seed", "1"])
-# compact reporter, include passes, warn about No Assertions
-approve('compact.sw', ['~[!nonportable]~[!benchmark]~[approvals] *', '-s', '-w', 'NoAssertions', '-r', 'compact', '--order', 'lex', "--rng-seed", "1"])
-# sonarqube reporter, include passes, warn about No Assertions
-approve("sonarqube.sw", ["~[!nonportable]~[!benchmark]~[approvals] *", "-s", "-w", "NoAssertions", "-r", "sonarqube", "--order", "lex", "--rng-seed", "1"])
+
+## Common reporter checks: include passes, warn about No Assertions
+reporters = ('console', 'junit', 'xml', 'compact', 'sonarqube', 'tap', 'teamcity', 'automake')
+for reporter in reporters:
+    filename = '{}.sw'.format(reporter)
+    common_args = ["~[!nonportable]~[!benchmark]~[approvals] *", "-s", "-w", "NoAssertions", "--order", "lex", "--rng-seed", "1"]
+    reporter_args = ['-r', reporter]
+    approve(filename, common_args + reporter_args)
 
 
 if overallResult != 0: