redsnow 0.3.1 → 0.3.2

data/ext/snowcrash/test/vendor/Catch/include/reporters/catch_reporter_basic.hpp

@@ -0,0 +1,353 @@
+/*
+ *  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 {
+
+    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 ReporterConfig& config )
+        :   m_config( config ),
+            m_firstSectionInTestCase( true ),
+            m_aborted( false )
+        {}
+
+        virtual ~BasicReporter();
+
+        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 ) {
+                Colour colour( Colour::ResultError );
+                ReportCounts( "test case", totals.testCases, allPrefix );
+                if( totals.testCases.failed > 0 ) {
+                    m_config.stream() << " (";
+                    ReportCounts( "assertion", totals.assertions, allPrefix );
+                    m_config.stream() << ")";
+                }
+            }
+            else {
+                Colour colour( Colour::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.name;
+        }
+
+        virtual void StartSection( const std::string& sectionName, const std::string& ) {
+            m_sectionSpans.push_back( SpanInfo( sectionName ) );
+        }
+
+        virtual void NoAssertionsInSection( const std::string& sectionName ) {
+            startSpansLazily();
+            Colour colour( Colour::ResultError );
+            m_config.stream() << "\nNo assertions in section, '" << sectionName << "'\n" << std::endl;
+        }
+        virtual void NoAssertionsInTestCase( const std::string& testName ) {
+            startSpansLazily();
+            Colour colour( Colour::ResultError );
+            m_config.stream() << "\nNo assertions in test case, '" << testName << "'\n" << std::endl;
+        }
+
+        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 ) {
+                    Colour colour( Colour::ResultError );
+                    ReportCounts( "assertion", assertions);
+                }
+                else {
+                    Colour colour( Colour::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 AssertionResult& assertionResult ) {
+            if( !m_config.fullConfig()->includeSuccessfulResults() && assertionResult.getResultType() == ResultWas::Ok )
+                return;
+
+            startSpansLazily();
+
+            if( !assertionResult.getSourceInfo().empty() ) {
+                Colour colour( Colour::FileName );
+                m_config.stream() << assertionResult.getSourceInfo() << ": ";
+            }
+
+            if( assertionResult.hasExpression() ) {
+                Colour colour( Colour::OriginalExpression );
+                m_config.stream() << assertionResult.getExpression();
+                if( assertionResult.succeeded() ) {
+                    Colour successColour( Colour::Success );
+                    m_config.stream() << " succeeded";
+                }
+                else {
+                    Colour errorColour( Colour::Error );
+                    m_config.stream() << " failed";
+                    if( assertionResult.isOk() ) {
+                        Colour okAnywayColour( Colour::Success );
+                        m_config.stream() << " - but was ok";
+                    }
+                }
+            }
+            switch( assertionResult.getResultType() ) {
+                case ResultWas::ThrewException:
+                    {
+                        Colour colour( Colour::Error );
+                        if( assertionResult.hasExpression() )
+                            m_config.stream() << " with unexpected";
+                        else
+                            m_config.stream() << "Unexpected";
+                        m_config.stream() << " exception with message: '" << assertionResult.getMessage() << "'";
+                    }
+                    break;
+                case ResultWas::DidntThrowException:
+                    {
+                        Colour colour( Colour::Error );
+                        if( assertionResult.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:
+                    {
+                        Colour colour( Colour::ReconstructedExpression );
+                        streamVariableLengthText( "info", assertionResult.getMessage() );
+                    }
+                    break;
+                case ResultWas::Warning:
+                    {
+                        Colour colour( Colour::ReconstructedExpression );
+                        streamVariableLengthText( "warning", assertionResult.getMessage() );
+                    }
+                    break;
+                case ResultWas::ExplicitFailure:
+                    {
+                        Colour colour( Colour::Error );
+                        m_config.stream() << "failed with message: '" << assertionResult.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:
+                    if( !assertionResult.hasExpression() ) {
+                        if( assertionResult.succeeded() ) {
+                            Colour colour( Colour::Success );
+                            m_config.stream() << " succeeded";
+                        }
+                        else {
+                            Colour colour( Colour::Error );
+                            m_config.stream() << " failed";
+                            if( assertionResult.isOk() ) {
+                                Colour okAnywayColour( Colour::Success );
+                                m_config.stream() << " - but was ok";
+                            }
+                        }
+                    }
+                    if( assertionResult.hasMessage() ) {
+                        m_config.stream() << "\n";
+                        Colour colour( Colour::ReconstructedExpression );
+                        streamVariableLengthText( "with message", assertionResult.getMessage() );
+                    }
+                    break;
+            }
+
+            if( assertionResult.hasExpandedExpression() ) {
+                m_config.stream() << " for: ";
+                if( assertionResult.getExpandedExpression().size() > 40 ) {
+                    m_config.stream() << "\n";
+                    if( assertionResult.getExpandedExpression().size() < 70 )
+                        m_config.stream() << "\t";
+                }
+                Colour colour( Colour::ReconstructedExpression );
+                m_config.stream() << assertionResult.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.name << "' ";
+                ReportCounts( totals );
+                m_config.stream() << "]" << std::endl;
+            }
+        }
+
+    private: // helpers
+
+        void startSpansLazily() {
+            if( !m_testingSpan.emitted ) {
+                if( m_config.fullConfig()->name().empty() )
+                    m_config.stream() << "[Started testing]" << std::endl;
+                else
+                    m_config.stream() << "[Started testing: " << m_config.fullConfig()->name() << "]" << 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 << "]";
+            }
+            else {
+                m_config.stream() << "\n[" << prefix << "] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n" << trimmed
+                << "\n[end of " << prefix << "] <<<<<<<<<<<<<<<<<<<<<<<<\n";
+            }
+        }
+
+    private:
+        ReporterConfig 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

data/ext/snowcrash/test/vendor/Catch/include/reporters/catch_reporter_console.hpp

@@ -0,0 +1,397 @@
+/*
+ *  Created by Phil on 5/12/2012.
+ *  Copyright 2012 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_CONSOLE_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+
+#include "../internal/catch_interfaces_reporter.h"
+#include "../internal/catch_reporter_registrars.hpp"
+#include "../internal/catch_console_colour.hpp"
+
+namespace Catch {
+
+    struct ConsoleReporter : StreamingReporterBase {
+        ConsoleReporter( ReporterConfig const& _config )
+        :   StreamingReporterBase( _config ),
+            m_headerPrinted( false ),
+            m_atLeastOneTestCasePrinted( false )
+        {}
+
+        virtual ~ConsoleReporter();
+        static std::string getDescription() {
+            return "Reports test results as plain lines of text";
+        }
+        virtual ReporterPreferences getPreferences() const {
+            ReporterPreferences prefs;
+            prefs.shouldRedirectStdOut = false;
+            return prefs;
+
+        }
+
+        virtual void noMatchingTestCases( std::string const& spec ) {
+            stream << "No test cases matched '" << spec << "'" << std::endl;
+        }
+
+        virtual void assertionStarting( AssertionInfo const& ) {
+        }
+
+        virtual bool assertionEnded( AssertionStats const& _assertionStats ) {
+            AssertionResult const& result = _assertionStats.assertionResult;
+
+            // Drop out if result was successful and we're not printing those
+            if( !m_config->includeSuccessfulResults() && result.isOk() )
+                return false;
+
+            lazyPrint();
+
+            AssertionPrinter printer( stream, _assertionStats );
+            printer.print();
+            stream << std::endl;
+            return true;
+        }
+
+        virtual void sectionStarting( SectionInfo const& _sectionInfo ) {
+            m_headerPrinted = false;
+            StreamingReporterBase::sectionStarting( _sectionInfo );
+        }
+        virtual void sectionEnded( SectionStats const& _sectionStats ) {
+            if( _sectionStats.missingAssertions ) {
+                lazyPrint();
+                Colour colour( Colour::ResultError );
+                stream << "\nNo assertions in section, '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
+            }
+            m_headerPrinted = false;
+            StreamingReporterBase::sectionEnded( _sectionStats );
+        }
+
+        virtual void testCaseEnded( TestCaseStats const& _testCaseStats ) {
+
+            if( _testCaseStats.missingAssertions ) {
+                lazyPrint();
+                Colour colour( Colour::ResultError );
+                stream << "\nNo assertions in test case, '" << _testCaseStats.testInfo.name << "'\n" << std::endl;
+            }
+            StreamingReporterBase::testCaseEnded( _testCaseStats );
+            m_headerPrinted = false;
+        }
+        virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) {
+            if( !unusedGroupInfo ) {
+                printSummaryDivider();
+                stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
+                printTotals( _testGroupStats.totals );
+                stream << "\n" << std::endl;
+            }
+            StreamingReporterBase::testGroupEnded( _testGroupStats );
+        }
+        virtual void testRunEnded( TestRunStats const& _testRunStats ) {
+            if( m_atLeastOneTestCasePrinted )
+                printTotalsDivider();
+            printTotals( _testRunStats.totals );
+            stream << "\n" << std::endl;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+    private:
+
+        class AssertionPrinter {
+            void operator= ( AssertionPrinter const& );
+        public:
+            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats )
+            :   stream( _stream ),
+                stats( _stats ),
+                result( _stats.assertionResult ),
+                colour( Colour::None ),
+                message( result.getMessage() ),
+                messages( _stats.infoMessages )
+            {
+                switch( result.getResultType() ) {
+                    case ResultWas::Ok:
+                        colour = Colour::Success;
+                        passOrFail = "PASSED";
+                        //if( result.hasMessage() )
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "with messages";
+                        break;
+                    case ResultWas::ExpressionFailed:
+                        if( result.isOk() ) {
+                            colour = Colour::Success;
+                            passOrFail = "FAILED - but was ok";
+                        }
+                        else {
+                            colour = Colour::Error;
+                            passOrFail = "FAILED";
+                        }
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "with messages";
+                        break;
+                    case ResultWas::ThrewException:
+                        colour = Colour::Error;
+                        passOrFail = "FAILED";
+                        messageLabel = "due to unexpected exception with message";
+                        break;
+                    case ResultWas::DidntThrowException:
+                        colour = Colour::Error;
+                        passOrFail = "FAILED";
+                        messageLabel = "because no exception was thrown where one was expected";
+                        break;
+                    case ResultWas::Info:
+                        messageLabel = "info";
+                        break;
+                    case ResultWas::Warning:
+                        messageLabel = "warning";
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        passOrFail = "FAILED";
+                        colour = Colour::Error;
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "explicitly with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "explicitly with messages";
+                        break;
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        passOrFail = "** internal error **";
+                        colour = Colour::Error;
+                        break;
+                }
+            }
+
+            void print() const {
+                printSourceInfo();
+                if( stats.totals.assertions.total() > 0 ) {
+                    if( result.isOk() )
+                        stream << "\n";
+                    printResultType();
+                    printOriginalExpression();
+                    printReconstructedExpression();
+                }
+                else {
+                    stream << "\n";
+                }
+                printMessage();
+            }
+
+        private:
+            void printResultType() const {
+                if( !passOrFail.empty() ) {
+                    Colour colourGuard( colour );
+                    stream << passOrFail << ":\n";
+                }
+            }
+            void printOriginalExpression() const {
+                if( result.hasExpression() ) {
+                    Colour colourGuard( Colour::OriginalExpression );
+                    stream  << "  ";
+                    stream << result.getExpressionInMacro();
+                    stream << "\n";
+                }
+            }
+            void printReconstructedExpression() const {
+                if( result.hasExpandedExpression() ) {
+                    stream << "with expansion:\n";
+                    Colour colourGuard( Colour::ReconstructedExpression );
+                    stream << Text( result.getExpandedExpression(), TextAttributes().setIndent(2) ) << "\n";
+                }
+            }
+            void printMessage() const {
+                if( !messageLabel.empty() )
+                    stream << messageLabel << ":" << "\n";
+                for( std::vector<MessageInfo>::const_iterator it = messages.begin(), itEnd = messages.end();
+                        it != itEnd;
+                        ++it ) {
+                    stream << Text( it->message, TextAttributes().setIndent(2) ) << "\n";
+                }
+            }
+            void printSourceInfo() const {
+                Colour colourGuard( Colour::FileName );
+                stream << result.getSourceInfo() << ": ";
+            }
+
+            std::ostream& stream;
+            AssertionStats const& stats;
+            AssertionResult const& result;
+            Colour::Code colour;
+            std::string passOrFail;
+            std::string messageLabel;
+            std::string message;
+            std::vector<MessageInfo> messages;
+        };
+
+        void lazyPrint() {
+
+            if( testRunInfo )
+                lazyPrintRunInfo();
+            if( unusedGroupInfo )
+                lazyPrintGroupInfo();
+
+            if( !m_headerPrinted ) {
+                printTestCaseAndSectionHeader();
+                m_headerPrinted = true;
+            }
+            m_atLeastOneTestCasePrinted = true;
+        }
+        void lazyPrintRunInfo() {
+            stream  << "\n" << getTildes() << "\n";
+            Colour colour( Colour::SecondaryText );
+            stream  << testRunInfo->name
+                    << " is a Catch v"  << libraryVersion.majorVersion << "."
+                    << libraryVersion.minorVersion << " b"
+                    << libraryVersion.buildNumber;
+            if( libraryVersion.branchName != "master" )
+                stream << " (" << libraryVersion.branchName << ")";
+            stream  << " host application.\n"
+                    << "Run with -? for options\n\n";
+
+            testRunInfo.reset();
+        }
+        void lazyPrintGroupInfo() {
+            if( !unusedGroupInfo->name.empty() && unusedGroupInfo->groupsCounts > 1 ) {
+                printClosedHeader( "Group: " + unusedGroupInfo->name );
+                unusedGroupInfo.reset();
+            }
+        }
+        void printTestCaseAndSectionHeader() {
+            printOpenHeader( unusedTestCaseInfo->name );
+            if( currentSectionInfo ) {
+                Colour colourGuard( Colour::Headers );
+                std::vector<ThreadedSectionInfo*> sections;
+                for(    ThreadedSectionInfo* section = currentSectionInfo.get();
+                        section;
+                        section = section->parent )
+                    sections.push_back( section );
+
+                // Sections
+                if( !sections.empty() ) {
+                    typedef std::vector<ThreadedSectionInfo*>::const_reverse_iterator It;
+                    for( It it = sections.rbegin(), itEnd = sections.rend(); it != itEnd; ++it )
+                        printHeaderString( (*it)->name, 2 );
+
+                }
+            }
+            SourceLineInfo lineInfo = currentSectionInfo
+                                    ? currentSectionInfo->lineInfo
+                                    : unusedTestCaseInfo->lineInfo;
+
+            if( !lineInfo.empty() ){
+                stream << getDashes() << "\n";
+                Colour colourGuard( Colour::FileName );
+                stream << lineInfo << "\n";
+            }
+            stream << getDots() << "\n" << std::endl;
+        }
+
+        void printClosedHeader( std::string const& _name ) {
+            printOpenHeader( _name );
+            stream << getDots() << "\n";
+        }
+        void printOpenHeader( std::string const& _name ) {
+            stream  << getDashes() << "\n";
+            {
+                Colour colourGuard( Colour::Headers );
+                printHeaderString( _name );
+            }
+        }
+
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        void printHeaderString( std::string const& _string, std::size_t indent = 0 ) {
+            std::size_t i = _string.find( ": " );
+            if( i != std::string::npos )
+                i+=2;
+            else
+                i = 0;
+            stream << Text( _string, TextAttributes()
+                                        .setIndent( indent+i)
+                                        .setInitialIndent( indent ) ) << "\n";
+        }
+
+        void printTotals( const Totals& totals ) {
+            if( totals.assertions.total() == 0 ) {
+                stream << "No tests ran";
+            }
+            else if( totals.assertions.failed ) {
+                Colour colour( Colour::ResultError );
+                printCounts( "test case", totals.testCases );
+                if( totals.testCases.failed > 0 ) {
+                    stream << " (";
+                    printCounts( "assertion", totals.assertions );
+                    stream << ")";
+                }
+            }
+            else {
+                Colour colour( Colour::ResultSuccess );
+                stream << "All tests passed ("
+                        << pluralise( totals.assertions.passed, "assertion" ) << " in "
+                        << pluralise( totals.testCases.passed, "test case" ) << ")";
+            }
+        }
+        void printCounts( std::string const& label, Counts const& counts ) {
+            if( counts.total() == 1 ) {
+                stream << "1 " << label << " - ";
+                if( counts.failed )
+                    stream << "failed";
+                else
+                    stream << "passed";
+            }
+            else {
+                stream << counts.total() << " " << label << "s ";
+                if( counts.passed ) {
+                    if( counts.failed )
+                        stream << "- " << counts.failed << " failed";
+                    else if( counts.passed == 2 )
+                        stream << "- both passed";
+                    else
+                        stream << "- all passed";
+                }
+                else {
+                    if( counts.failed == 2 )
+                        stream << "- both failed";
+                    else
+                        stream << "- all failed";
+                }
+            }
+        }
+
+        void printTotalsDivider() {
+            stream << getDoubleDashes() << "\n";
+        }
+        void printSummaryDivider() {
+            stream << getDashes() << "\n";
+        }
+        static std::string const& getDashes() {
+            static const std::string dashes( CATCH_CONFIG_CONSOLE_WIDTH-1, '-' );
+            return dashes;
+        }
+        static std::string const& getDots() {
+            static const std::string dots( CATCH_CONFIG_CONSOLE_WIDTH-1, '.' );
+            return dots;
+        }
+        static std::string const& getDoubleDashes() {
+            static const std::string doubleDashes( CATCH_CONFIG_CONSOLE_WIDTH-1, '=' );
+            return doubleDashes;
+        }
+        static std::string const& getTildes() {
+            static const std::string dots( CATCH_CONFIG_CONSOLE_WIDTH-1, '~' );
+            return dots;
+        }
+
+    private:
+        bool m_headerPrinted;
+        bool m_atLeastOneTestCasePrinted;
+    };
+
+    INTERNAL_CATCH_REGISTER_REPORTER( "console", ConsoleReporter )
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED