Progmasoft Git

catch3

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

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

Revert "Fixed issue #101, missing space in end of section message"

This reverts commit 1ad971ea2b77a2df0bb560ce61f7eca4cb353eb1.
Commit
a0c496fefc493566d3cf73aa4763845f8061d653
Author
Martin Moene ·
Parents
14f1c094f487

Files · Download .tar.gz

Changes

 include/reporters/catch_reporter_basic.hpp | 666 ++++++++++++++---------------
 1 file changed, 333 insertions(+), 333 deletions(-)

diff --git a/include/reporters/catch_reporter_basic.hpp b/include/reporters/catch_reporter_basic.hpp
index b620544e..f5fc6ee1 100644
--- a/include/reporters/catch_reporter_basic.hpp
+++ b/include/reporters/catch_reporter_basic.hpp
@@ -1,333 +1,333 @@
-/*

- *  Created by Phil on 28/10/2010.

- *  Copyright 2010 Two Blue Cubes Ltd. All rights reserved.

- *

- *  Distributed under the Boost Software License, Version 1.0. (See accompanying

- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

- */

-#ifndef TWOBLUECUBES_CATCH_REPORTER_BASIC_HPP_INCLUDED

-#define TWOBLUECUBES_CATCH_REPORTER_BASIC_HPP_INCLUDED

-

-#include "../internal/catch_capture.hpp"

-#include "../internal/catch_interfaces_reporter.h"

-#include "../internal/catch_reporter_registrars.hpp"

-#include "../internal/catch_console_colour.hpp"

-

-namespace Catch {

-

-    struct pluralise {

-        pluralise( std::size_t count, const std::string& label )

-        :   m_count( count ),

-            m_label( label )

-        {}

-

-        friend std::ostream& operator << ( std::ostream& os, const pluralise& pluraliser ) {

-            os << pluraliser.m_count << " " << pluraliser.m_label;

-            if( pluraliser.m_count != 1 )

-                os << "s";

-            return os;

-        }

-

-        std::size_t m_count;

-        std::string m_label;

-    };

-

-    class BasicReporter : public SharedImpl<IReporter> {

-    

-        struct SpanInfo {

-        

-            SpanInfo() 

-            :   emitted( false )

-            {}

-            

-            SpanInfo( const std::string& spanName ) 

-            :   name( spanName ),

-                emitted( false )

-            {}

-            

-            SpanInfo( const SpanInfo& other ) 

-            :   name( other.name ),

-                emitted( other.emitted )

-            {}

-            

-            std::string name;

-            bool emitted;

-        };

-

-    public:

-        BasicReporter( const IReporterConfig& config )

-        :   m_config( config ),

-            m_firstSectionInTestCase( true ),

-            m_aborted( false )

-        {}

-        

-        static std::string getDescription() {

-            return "Reports test results as lines of text";

-        }

-

-    private:

-

-        void ReportCounts( const std::string& label, const Counts& counts, const std::string& allPrefix = "All " ) {

-            if( counts.passed )

-                m_config.stream() << counts.failed << " of " << counts.total() << " " << label << "s failed";

-            else

-                m_config.stream() << ( counts.failed > 1 ? allPrefix : "" ) << pluralise( counts.failed, label ) << " failed";

-        }

-

-        void ReportCounts( const Totals& totals, const std::string& allPrefix = "All " ) {

-            if( totals.assertions.total() == 0 ) {

-                m_config.stream() << "No tests ran";

-            }

-            else if( totals.assertions.failed ) {

-                TextColour colour( TextColour::ResultError );

-                ReportCounts( "test case", totals.testCases, allPrefix );

-                if( totals.testCases.failed > 0 ) {

-                    m_config.stream() << " (";

-                    ReportCounts( "assertion", totals.assertions, allPrefix );

-                    m_config.stream() << ")";

-                }

-            }

-            else {

-                TextColour colour( TextColour::ResultSuccess );

-                m_config.stream()   << allPrefix << "tests passed ("

-                                    << pluralise( totals.assertions.passed, "assertion" ) << " in " 

-                                    << pluralise( totals.testCases.passed, "test case" ) << ")";

-            }

-        }

-

-    private: // IReporter

-        

-        virtual bool shouldRedirectStdout() const {

-            return false;

-        }        

-

-        virtual void StartTesting() {

-            m_testingSpan = SpanInfo();

-        }

-

-        virtual void Aborted() {

-            m_aborted = true;

-        }

-

-        virtual void EndTesting( const Totals& totals ) {

-            // Output the overall test results even if "Started Testing" was not emitted

-            if( m_aborted ) {

-                m_config.stream() << "\n[Testing aborted. ";

-                ReportCounts( totals, "The first " );

-            }

-            else {

-                m_config.stream() << "\n[Testing completed. ";

-                ReportCounts( totals );

-            }

-            m_config.stream() << "]\n" << std::endl;

-        }

-

-        virtual void StartGroup( const std::string& groupName ) {

-            m_groupSpan = groupName;

-        }

-

-        virtual void EndGroup( const std::string& groupName, const Totals& totals ) {

-            if( m_groupSpan.emitted && !groupName.empty() ) {

-                m_config.stream() << "[End of group: '" << groupName << "'. ";

-                ReportCounts( totals );

-                m_config.stream() << "]\n" << std::endl;

-                m_groupSpan = SpanInfo();

-            }

-        }

-        

-        virtual void StartTestCase( const TestCaseInfo& testInfo ) {

-            m_testSpan = testInfo.getName();

-        }

-        

-        virtual void StartSection( const std::string& sectionName, const std::string& ) {

-            m_sectionSpans.push_back( SpanInfo( sectionName ) );

-        }

-        

-        virtual void EndSection( const std::string& sectionName, const Counts& assertions ) {

-            SpanInfo& sectionSpan = m_sectionSpans.back();

-            if( sectionSpan.emitted && !sectionSpan.name.empty() ) {

-                m_config.stream() << "[End of section: '" << sectionName << "' ";

-                

-                if( assertions.failed ) {

-                    TextColour colour( TextColour::ResultError );

-                    ReportCounts( "assertion", assertions);

-                }

-                else {

-                    TextColour colour( TextColour::ResultSuccess );

-                    m_config.stream()   << ( assertions.passed > 1 ? "All " : "" ) 

-                                        << pluralise( assertions.passed, "assertion" ) << " passed" ;

-                }

-                m_config.stream() << "]\n" << std::endl;

-            }

-            m_sectionSpans.pop_back();

-        }

-        

-        virtual void Result( const ResultInfo& resultInfo ) {

-            if( !m_config.includeSuccessfulResults() && resultInfo.getResultType() == ResultWas::Ok )

-                return;

-            

-            StartSpansLazily();

-            

-            if( !resultInfo.getFilename().empty() ) {

-                TextColour colour( TextColour::FileName );

-                m_config.stream() << SourceLineInfo( resultInfo.getFilename(), resultInfo.getLine() );

-            }

-            

-            if( resultInfo.hasExpression() ) {

-                TextColour colour( TextColour::OriginalExpression );

-                m_config.stream() << resultInfo.getExpression();

-                if( resultInfo.ok() ) {

-                    TextColour successColour( TextColour::Success );

-                    m_config.stream() << " succeeded";

-                }

-                else {

-                    TextColour errorColour( TextColour::Error );

-                    m_config.stream() << " failed";

-                }

-            }

-            switch( resultInfo.getResultType() ) {

-                case ResultWas::ThrewException:

-                {

-                    TextColour colour( TextColour::Error );

-                    if( resultInfo.hasExpression() )

-                        m_config.stream() << " with unexpected";

-                    else

-                        m_config.stream() << "Unexpected";

-                    m_config.stream() << " exception with message: '" << resultInfo.getMessage() << "'";

-                }

-                    break;

-                case ResultWas::DidntThrowException:

-                {

-                    TextColour colour( TextColour::Error );

-                    if( resultInfo.hasExpression() )

-                        m_config.stream() << " because no exception was thrown where one was expected";

-                    else

-                        m_config.stream() << "No exception thrown where one was expected";

-                }

-                    break;

-                case ResultWas::Info:

-                    streamVariableLengthText( "info", resultInfo.getMessage() );

-                    break;

-                case ResultWas::Warning:

-                    m_config.stream() << "warning:\n'" << resultInfo.getMessage() << "'";

-                    break;

-                case ResultWas::ExplicitFailure:

-                {

-                    TextColour colour( TextColour::Error );

-                    m_config.stream() << "failed with message: '" << resultInfo.getMessage() << "'";

-                }

-                    break;

-                case ResultWas::Unknown: // These cases are here to prevent compiler warnings

-                case ResultWas::Ok:

-                case ResultWas::FailureBit:

-                case ResultWas::ExpressionFailed:

-                case ResultWas::Exception:

-                default:

-                    if( !resultInfo.hasExpression() ) {

-                        if( resultInfo.ok() ) {

-                            TextColour colour( TextColour::Success );

-                            m_config.stream() << " succeeded";

-                        }

-                        else {

-                            TextColour colour( TextColour::Error );

-                            m_config.stream() << " failed";

-                        }

-                    }

-                    break;

-            }

-            

-            if( resultInfo.hasExpandedExpression() ) {

-                m_config.stream() << " for: ";

-                TextColour colour( TextColour::ReconstructedExpression );

-                m_config.stream() << resultInfo.getExpandedExpression();

-            }

-            m_config.stream() << std::endl;        

-        }

-        

-        virtual void EndTestCase(   const TestCaseInfo& testInfo, 

-                                    const Totals& totals,

-                                    const std::string& stdOut, 

-                                    const std::string& stdErr ) {

-            if( !stdOut.empty() ) {

-                StartSpansLazily();

-                streamVariableLengthText( "stdout", stdOut );

-            }

-            

-            if( !stdErr.empty() ) {

-                StartSpansLazily();

-                streamVariableLengthText( "stderr", stdErr );

-            }

-            

-            if( m_testSpan.emitted ) {

-                m_config.stream() << "[Finished: '" << testInfo.getName() << "' ";

-                ReportCounts( totals );

-                m_config.stream() << "]" << std::endl;

-            }

-        }    

-        

-    private: // helpers

-        

-        void StartSpansLazily() {

-            if( !m_testingSpan.emitted ) {

-                if( m_config.getName().empty() )

-                    m_config.stream() << "[Started testing]" << std::endl;

-                else

-                    m_config.stream() << "[Started testing: " << m_config.getName() << "]" << std::endl;

-                m_testingSpan.emitted = true;

-            }

-            

-            if( !m_groupSpan.emitted && !m_groupSpan.name.empty() ) {

-                m_config.stream() << "[Started group: '" << m_groupSpan.name << "']" << std::endl;

-                m_groupSpan.emitted = true;

-            }

-            

-            if( !m_testSpan.emitted ) {

-                m_config.stream() << std::endl << "[Running: " << m_testSpan.name << "]" << std::endl;

-                m_testSpan.emitted = true;

-            }

-            

-            if( !m_sectionSpans.empty() ) {

-                SpanInfo& sectionSpan = m_sectionSpans.back();

-                if( !sectionSpan.emitted && !sectionSpan.name.empty() ) {

-                    if( m_firstSectionInTestCase ) {

-                        m_config.stream() << "\n";

-                        m_firstSectionInTestCase = false;

-                    }

-                    std::vector<SpanInfo>::iterator it = m_sectionSpans.begin();

-                    std::vector<SpanInfo>::iterator itEnd = m_sectionSpans.end();

-                    for(; it != itEnd; ++it ) {

-                        SpanInfo& prevSpan = *it;

-                        if( !prevSpan.emitted && !prevSpan.name.empty() ) {

-                            m_config.stream() << "[Started section: '" << prevSpan.name << "']" << std::endl;

-                            prevSpan.emitted = true;

-                        }                        

-                    }

-                }

-            }

-        }

-        

-        void streamVariableLengthText( const std::string& prefix, const std::string& text ) {

-            std::string trimmed = trim( text );

-            if( trimmed.find_first_of( "\r\n" ) == std::string::npos ) {

-                m_config.stream() << "[" << prefix << ": " << trimmed << "]\n";

-            }

-            else {

-                m_config.stream() << "\n[" << prefix << "] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n" << trimmed 

-                << "\n[end of " << prefix << "] <<<<<<<<<<<<<<<<<<<<<<<<\n";

-            }

-        }

-        

-    private:

-        const IReporterConfig& m_config;

-        bool m_firstSectionInTestCase;

-        

-        SpanInfo m_testingSpan;

-        SpanInfo m_groupSpan;

-        SpanInfo m_testSpan;

-        std::vector<SpanInfo> m_sectionSpans;

-        bool m_aborted;

-    };

-        

-} // end namespace Catch

-

-#endif // TWOBLUECUBES_CATCH_REPORTER_BASIC_HPP_INCLUDED

+/*
+ *  Created by Phil on 28/10/2010.
+ *  Copyright 2010 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_CATCH_REPORTER_BASIC_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_BASIC_HPP_INCLUDED
+
+#include "../internal/catch_capture.hpp"
+#include "../internal/catch_interfaces_reporter.h"
+#include "../internal/catch_reporter_registrars.hpp"
+#include "../internal/catch_console_colour.hpp"
+
+namespace Catch {
+
+    struct pluralise {
+        pluralise( std::size_t count, const std::string& label )
+        :   m_count( count ),
+            m_label( label )
+        {}
+
+        friend std::ostream& operator << ( std::ostream& os, const pluralise& pluraliser ) {
+            os << pluraliser.m_count << " " << pluraliser.m_label;
+            if( pluraliser.m_count != 1 )
+                os << "s";
+            return os;
+        }
+
+        std::size_t m_count;
+        std::string m_label;
+    };
+
+    class BasicReporter : public SharedImpl<IReporter> {
+    
+        struct SpanInfo {
+        
+            SpanInfo() 
+            :   emitted( false )
+            {}
+            
+            SpanInfo( const std::string& spanName ) 
+            :   name( spanName ),
+                emitted( false )
+            {}
+            
+            SpanInfo( const SpanInfo& other ) 
+            :   name( other.name ),
+                emitted( other.emitted )
+            {}
+            
+            std::string name;
+            bool emitted;
+        };
+
+    public:
+        BasicReporter( const IReporterConfig& config )
+        :   m_config( config ),
+            m_firstSectionInTestCase( true ),
+            m_aborted( false )
+        {}
+        
+        static std::string getDescription() {
+            return "Reports test results as lines of text";
+        }
+
+    private:
+
+        void ReportCounts( const std::string& label, const Counts& counts, const std::string& allPrefix = "All " ) {
+            if( counts.passed )
+                m_config.stream() << counts.failed << " of " << counts.total() << " " << label << "s failed";
+            else
+                m_config.stream() << ( counts.failed > 1 ? allPrefix : "" ) << pluralise( counts.failed, label ) << " failed";
+        }
+
+        void ReportCounts( const Totals& totals, const std::string& allPrefix = "All " ) {
+            if( totals.assertions.total() == 0 ) {
+                m_config.stream() << "No tests ran";
+            }
+            else if( totals.assertions.failed ) {
+                TextColour colour( TextColour::ResultError );
+                ReportCounts( "test case", totals.testCases, allPrefix );
+                if( totals.testCases.failed > 0 ) {
+                    m_config.stream() << " (";
+                    ReportCounts( "assertion", totals.assertions, allPrefix );
+                    m_config.stream() << ")";
+                }
+            }
+            else {
+                TextColour colour( TextColour::ResultSuccess );
+                m_config.stream()   << allPrefix << "tests passed ("
+                                    << pluralise( totals.assertions.passed, "assertion" ) << " in " 
+                                    << pluralise( totals.testCases.passed, "test case" ) << ")";
+            }
+        }
+
+    private: // IReporter
+        
+        virtual bool shouldRedirectStdout() const {
+            return false;
+        }        
+
+        virtual void StartTesting() {
+            m_testingSpan = SpanInfo();
+        }
+
+        virtual void Aborted() {
+            m_aborted = true;
+        }
+
+        virtual void EndTesting( const Totals& totals ) {
+            // Output the overall test results even if "Started Testing" was not emitted
+            if( m_aborted ) {
+                m_config.stream() << "\n[Testing aborted. ";
+                ReportCounts( totals, "The first " );
+            }
+            else {
+                m_config.stream() << "\n[Testing completed. ";
+                ReportCounts( totals );
+            }
+            m_config.stream() << "]\n" << std::endl;
+        }
+
+        virtual void StartGroup( const std::string& groupName ) {
+            m_groupSpan = groupName;
+        }
+
+        virtual void EndGroup( const std::string& groupName, const Totals& totals ) {
+            if( m_groupSpan.emitted && !groupName.empty() ) {
+                m_config.stream() << "[End of group: '" << groupName << "'. ";
+                ReportCounts( totals );
+                m_config.stream() << "]\n" << std::endl;
+                m_groupSpan = SpanInfo();
+            }
+        }
+        
+        virtual void StartTestCase( const TestCaseInfo& testInfo ) {
+            m_testSpan = testInfo.getName();
+        }
+        
+        virtual void StartSection( const std::string& sectionName, const std::string& ) {
+            m_sectionSpans.push_back( SpanInfo( sectionName ) );
+        }
+        
+        virtual void EndSection( const std::string& sectionName, const Counts& assertions ) {
+            SpanInfo& sectionSpan = m_sectionSpans.back();
+            if( sectionSpan.emitted && !sectionSpan.name.empty() ) {
+                m_config.stream() << "[End of section: '" << sectionName << "' ";
+                
+                if( assertions.failed ) {
+                    TextColour colour( TextColour::ResultError );
+                    ReportCounts( "assertion", assertions);
+                }
+                else {
+                    TextColour colour( TextColour::ResultSuccess );
+                    m_config.stream()   << ( assertions.passed > 1 ? "All " : "" ) 
+                                        << pluralise( assertions.passed, "assertion" ) << "passed" ;
+                }
+                m_config.stream() << "]\n" << std::endl;
+            }
+            m_sectionSpans.pop_back();
+        }
+        
+        virtual void Result( const ResultInfo& resultInfo ) {
+            if( !m_config.includeSuccessfulResults() && resultInfo.getResultType() == ResultWas::Ok )
+                return;
+            
+            StartSpansLazily();
+            
+            if( !resultInfo.getFilename().empty() ) {
+                TextColour colour( TextColour::FileName );
+                m_config.stream() << SourceLineInfo( resultInfo.getFilename(), resultInfo.getLine() );
+            }
+            
+            if( resultInfo.hasExpression() ) {
+                TextColour colour( TextColour::OriginalExpression );
+                m_config.stream() << resultInfo.getExpression();
+                if( resultInfo.ok() ) {
+                    TextColour successColour( TextColour::Success );
+                    m_config.stream() << " succeeded";
+                }
+                else {
+                    TextColour errorColour( TextColour::Error );
+                    m_config.stream() << " failed";
+                }
+            }
+            switch( resultInfo.getResultType() ) {
+                case ResultWas::ThrewException:
+                {
+                    TextColour colour( TextColour::Error );
+                    if( resultInfo.hasExpression() )
+                        m_config.stream() << " with unexpected";
+                    else
+                        m_config.stream() << "Unexpected";
+                    m_config.stream() << " exception with message: '" << resultInfo.getMessage() << "'";
+                }
+                    break;
+                case ResultWas::DidntThrowException:
+                {
+                    TextColour colour( TextColour::Error );
+                    if( resultInfo.hasExpression() )
+                        m_config.stream() << " because no exception was thrown where one was expected";
+                    else
+                        m_config.stream() << "No exception thrown where one was expected";
+                }
+                    break;
+                case ResultWas::Info:
+                    streamVariableLengthText( "info", resultInfo.getMessage() );
+                    break;
+                case ResultWas::Warning:
+                    m_config.stream() << "warning:\n'" << resultInfo.getMessage() << "'";
+                    break;
+                case ResultWas::ExplicitFailure:
+                {
+                    TextColour colour( TextColour::Error );
+                    m_config.stream() << "failed with message: '" << resultInfo.getMessage() << "'";
+                }
+                    break;
+                case ResultWas::Unknown: // These cases are here to prevent compiler warnings
+                case ResultWas::Ok:
+                case ResultWas::FailureBit:
+                case ResultWas::ExpressionFailed:
+                case ResultWas::Exception:
+                default:
+                    if( !resultInfo.hasExpression() ) {
+                        if( resultInfo.ok() ) {
+                            TextColour colour( TextColour::Success );
+                            m_config.stream() << " succeeded";
+                        }
+                        else {
+                            TextColour colour( TextColour::Error );
+                            m_config.stream() << " failed";
+                        }
+                    }
+                    break;
+            }
+            
+            if( resultInfo.hasExpandedExpression() ) {
+                m_config.stream() << " for: ";
+                TextColour colour( TextColour::ReconstructedExpression );
+                m_config.stream() << resultInfo.getExpandedExpression();
+            }
+            m_config.stream() << std::endl;        
+        }
+        
+        virtual void EndTestCase(   const TestCaseInfo& testInfo, 
+                                    const Totals& totals,
+                                    const std::string& stdOut, 
+                                    const std::string& stdErr ) {
+            if( !stdOut.empty() ) {
+                StartSpansLazily();
+                streamVariableLengthText( "stdout", stdOut );
+            }
+            
+            if( !stdErr.empty() ) {
+                StartSpansLazily();
+                streamVariableLengthText( "stderr", stdErr );
+            }
+            
+            if( m_testSpan.emitted ) {
+                m_config.stream() << "[Finished: '" << testInfo.getName() << "' ";
+                ReportCounts( totals );
+                m_config.stream() << "]" << std::endl;
+            }
+        }    
+        
+    private: // helpers
+        
+        void StartSpansLazily() {
+            if( !m_testingSpan.emitted ) {
+                if( m_config.getName().empty() )
+                    m_config.stream() << "[Started testing]" << std::endl;
+                else
+                    m_config.stream() << "[Started testing: " << m_config.getName() << "]" << std::endl;
+                m_testingSpan.emitted = true;
+            }
+            
+            if( !m_groupSpan.emitted && !m_groupSpan.name.empty() ) {
+                m_config.stream() << "[Started group: '" << m_groupSpan.name << "']" << std::endl;
+                m_groupSpan.emitted = true;
+            }
+            
+            if( !m_testSpan.emitted ) {
+                m_config.stream() << std::endl << "[Running: " << m_testSpan.name << "]" << std::endl;
+                m_testSpan.emitted = true;
+            }
+            
+            if( !m_sectionSpans.empty() ) {
+                SpanInfo& sectionSpan = m_sectionSpans.back();
+                if( !sectionSpan.emitted && !sectionSpan.name.empty() ) {
+                    if( m_firstSectionInTestCase ) {
+                        m_config.stream() << "\n";
+                        m_firstSectionInTestCase = false;
+                    }
+                    std::vector<SpanInfo>::iterator it = m_sectionSpans.begin();
+                    std::vector<SpanInfo>::iterator itEnd = m_sectionSpans.end();
+                    for(; it != itEnd; ++it ) {
+                        SpanInfo& prevSpan = *it;
+                        if( !prevSpan.emitted && !prevSpan.name.empty() ) {
+                            m_config.stream() << "[Started section: '" << prevSpan.name << "']" << std::endl;
+                            prevSpan.emitted = true;
+                        }                        
+                    }
+                }
+            }
+        }
+        
+        void streamVariableLengthText( const std::string& prefix, const std::string& text ) {
+            std::string trimmed = trim( text );
+            if( trimmed.find_first_of( "\r\n" ) == std::string::npos ) {
+                m_config.stream() << "[" << prefix << ": " << trimmed << "]\n";
+            }
+            else {
+                m_config.stream() << "\n[" << prefix << "] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n" << trimmed 
+                << "\n[end of " << prefix << "] <<<<<<<<<<<<<<<<<<<<<<<<\n";
+            }
+        }
+        
+    private:
+        const IReporterConfig& m_config;
+        bool m_firstSectionInTestCase;
+        
+        SpanInfo m_testingSpan;
+        SpanInfo m_groupSpan;
+        SpanInfo m_testSpan;
+        std::vector<SpanInfo> m_sectionSpans;
+        bool m_aborted;
+    };
+        
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_REPORTER_BASIC_HPP_INCLUDED