catch2/include/reporters/catch_reporter_basic.hpp

354 lines
14 KiB
C++
Raw Normal View History

2010-11-10 00:24:00 +01:00
/*
* 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"
2010-11-10 00:24:00 +01:00
2012-05-16 15:53:59 +02:00
namespace Catch {
class BasicReporter : public SharedImpl<IReporter> {
2012-05-16 15:53:59 +02:00
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;
};
2010-11-10 00:24:00 +01:00
public:
2012-07-20 20:07:42 +02:00
BasicReporter( const ReporterConfig& config )
: m_config( config ),
m_firstSectionInTestCase( true ),
m_aborted( false )
2012-05-16 15:53:59 +02:00
{}
virtual ~BasicReporter();
2012-05-16 15:53:59 +02:00
static std::string getDescription() {
2010-11-10 00:24:00 +01:00
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 " ) {
2012-05-16 15:53:59 +02:00
if( totals.assertions.total() == 0 ) {
m_config.stream() << "No tests ran";
}
2012-05-16 15:53:59 +02:00
else if( totals.assertions.failed ) {
Colour colour( Colour::ResultError );
ReportCounts( "test case", totals.testCases, allPrefix );
2012-05-16 15:53:59 +02:00
if( totals.testCases.failed > 0 ) {
m_config.stream() << " (";
ReportCounts( "assertion", totals.assertions, allPrefix );
m_config.stream() << ")";
}
}
2012-05-16 15:53:59 +02:00
else {
Colour colour( Colour::ResultSuccess );
m_config.stream() << allPrefix << "tests passed ("
<< pluralise( totals.assertions.passed, "assertion" ) << " in "
2012-03-04 12:14:21 +01:00
<< pluralise( totals.testCases.passed, "test case" ) << ")";
}
}
private: // IReporter
2012-05-16 15:53:59 +02:00
virtual bool shouldRedirectStdout() const {
return false;
}
2012-05-16 15:53:59 +02:00
virtual void StartTesting() {
m_testingSpan = SpanInfo();
}
virtual void Aborted() {
m_aborted = true;
}
2012-05-16 15:53:59 +02:00
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;
}
2012-05-16 15:53:59 +02:00
virtual void StartGroup( const std::string& groupName ) {
m_groupSpan = groupName;
}
2012-05-16 15:53:59 +02:00
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;
}
2012-05-16 15:53:59 +02:00
virtual void StartSection( const std::string& sectionName, const std::string& ) {
m_sectionSpans.push_back( SpanInfo( sectionName ) );
}
virtual void NoAssertionsInSection( const std::string& sectionName ) {
2012-09-03 09:18:32 +02:00
startSpansLazily();
Colour colour( Colour::ResultError );
m_config.stream() << "\nNo assertions in section, '" << sectionName << "'\n" << std::endl;
}
virtual void NoAssertionsInTestCase( const std::string& testName ) {
2012-09-03 09:18:32 +02:00
startSpansLazily();
Colour colour( Colour::ResultError );
m_config.stream() << "\nNo assertions in test case, '" << testName << "'\n" << std::endl;
}
2012-05-16 15:53:59 +02:00
virtual void EndSection( const std::string& sectionName, const Counts& assertions ) {
SpanInfo& sectionSpan = m_sectionSpans.back();
2012-05-16 15:53:59 +02:00
if( sectionSpan.emitted && !sectionSpan.name.empty() ) {
m_config.stream() << "[End of section: '" << sectionName << "' ";
2012-05-16 15:53:59 +02:00
if( assertions.failed ) {
Colour colour( Colour::ResultError );
ReportCounts( "assertion", assertions);
}
2012-05-16 15:53:59 +02:00
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();
2010-11-10 00:24:00 +01:00
}
virtual void Result( const AssertionResult& assertionResult ) {
if( !m_config.fullConfig()->includeSuccessfulResults() && assertionResult.getResultType() == ResultWas::Ok )
2010-11-10 00:24:00 +01:00
return;
2012-09-03 09:18:32 +02:00
startSpansLazily();
2012-10-24 22:59:47 +02:00
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();
2012-11-13 10:44:52 +01:00
if( assertionResult.succeeded() ) {
Colour successColour( Colour::Success );
m_config.stream() << " succeeded";
}
2012-05-16 15:53:59 +02:00
else {
Colour errorColour( Colour::Error );
m_config.stream() << " failed";
2012-11-13 10:44:52 +01:00
if( assertionResult.isOk() ) {
Colour okAnywayColour( Colour::Success );
m_config.stream() << " - but was ok";
2012-11-13 10:44:52 +01:00
}
}
2010-11-10 00:24:00 +01:00
}
switch( assertionResult.getResultType() ) {
2010-11-10 00:24:00 +01:00
case ResultWas::ThrewException:
2012-10-31 19:04:22 +01:00
{
Colour colour( Colour::Error );
2012-10-31 19:04:22 +01:00
if( assertionResult.hasExpression() )
m_config.stream() << " with unexpected";
2012-10-31 19:04:22 +01:00
else
m_config.stream() << "Unexpected";
m_config.stream() << " exception with message: '" << assertionResult.getMessage() << "'";
2012-10-31 19:04:22 +01:00
}
2010-11-10 00:24:00 +01:00
break;
2011-03-14 20:21:35 +01:00
case ResultWas::DidntThrowException:
2012-10-31 19:04:22 +01:00
{
Colour colour( Colour::Error );
2012-10-31 19:04:22 +01:00
if( assertionResult.hasExpression() )
m_config.stream() << " because no exception was thrown where one was expected";
2012-10-31 19:04:22 +01:00
else
m_config.stream() << "No exception thrown where one was expected";
2012-10-31 19:04:22 +01:00
}
2011-03-14 20:21:35 +01:00
break;
2010-11-10 00:24:00 +01:00
case ResultWas::Info:
2012-10-31 19:04:22 +01:00
{
Colour colour( Colour::ReconstructedExpression );
2012-10-31 19:04:22 +01:00
streamVariableLengthText( "info", assertionResult.getMessage() );
}
2010-11-10 00:24:00 +01:00
break;
case ResultWas::Warning:
2012-10-31 19:04:22 +01:00
{
Colour colour( Colour::ReconstructedExpression );
2012-10-31 19:04:22 +01:00
streamVariableLengthText( "warning", assertionResult.getMessage() );
}
2010-11-10 00:24:00 +01:00
break;
case ResultWas::ExplicitFailure:
2012-10-31 19:04:22 +01:00
{
Colour colour( Colour::Error );
m_config.stream() << "failed with message: '" << assertionResult.getMessage() << "'";
2012-10-31 19:04:22 +01:00
}
2010-11-10 00:24:00 +01:00
break;
2011-09-29 09:58:40 +02:00
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() ) {
2012-11-13 10:44:52 +01:00
if( assertionResult.succeeded() ) {
Colour colour( Colour::Success );
m_config.stream() << " succeeded";
}
2012-05-16 15:53:59 +02:00
else {
Colour colour( Colour::Error );
m_config.stream() << " failed";
2012-11-13 10:44:52 +01:00
if( assertionResult.isOk() ) {
Colour okAnywayColour( Colour::Success );
m_config.stream() << " - but was ok";
2012-11-13 10:44:52 +01:00
}
}
2011-03-14 20:21:35 +01:00
}
if( assertionResult.hasMessage() ) {
m_config.stream() << "\n";
Colour colour( Colour::ReconstructedExpression );
streamVariableLengthText( "with message", assertionResult.getMessage() );
}
break;
2010-11-10 00:24:00 +01:00
}
if( assertionResult.hasExpandedExpression() ) {
m_config.stream() << " for: ";
2012-10-29 20:55:13 +01:00
if( assertionResult.getExpandedExpression().size() > 40 ) {
m_config.stream() << "\n";
2012-10-29 20:55:13 +01:00
if( assertionResult.getExpandedExpression().size() < 70 )
m_config.stream() << "\t";
2012-10-29 20:55:13 +01:00
}
Colour colour( Colour::ReconstructedExpression );
m_config.stream() << assertionResult.getExpandedExpression();
2010-11-10 00:24:00 +01:00
}
m_config.stream() << std::endl;
2010-11-10 00:24:00 +01:00
}
virtual void EndTestCase( const TestCaseInfo& testInfo,
2012-05-16 15:53:59 +02:00
const Totals& totals,
const std::string& stdOut,
2012-05-16 15:53:59 +02:00
const std::string& stdErr ) {
if( !stdOut.empty() ) {
2012-09-03 09:18:32 +02:00
startSpansLazily();
2011-04-11 09:30:47 +02:00
streamVariableLengthText( "stdout", stdOut );
}
2012-05-16 15:53:59 +02:00
if( !stdErr.empty() ) {
2012-09-03 09:18:32 +02:00
startSpansLazily();
2011-04-11 09:30:47 +02:00
streamVariableLengthText( "stderr", stdErr );
}
2012-05-16 15:53:59 +02:00
if( m_testSpan.emitted ) {
m_config.stream() << "[Finished: '" << testInfo.name << "' ";
ReportCounts( totals );
m_config.stream() << "]" << std::endl;
}
}
private: // helpers
2012-09-03 09:18:32 +02:00
void startSpansLazily() {
2012-05-16 15:53:59 +02:00
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;
}
2012-05-16 15:53:59 +02:00
if( !m_groupSpan.emitted && !m_groupSpan.name.empty() ) {
m_config.stream() << "[Started group: '" << m_groupSpan.name << "']" << std::endl;
m_groupSpan.emitted = true;
}
2012-05-16 15:53:59 +02:00
if( !m_testSpan.emitted ) {
m_config.stream() << std::endl << "[Running: " << m_testSpan.name << "]" << std::endl;
m_testSpan.emitted = true;
}
2012-05-16 15:53:59 +02:00
if( !m_sectionSpans.empty() ) {
SpanInfo& sectionSpan = m_sectionSpans.back();
2012-05-16 15:53:59 +02:00
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();
2012-05-16 15:53:59 +02:00
for(; it != itEnd; ++it ) {
SpanInfo& prevSpan = *it;
2012-05-16 15:53:59 +02:00
if( !prevSpan.emitted && !prevSpan.name.empty() ) {
m_config.stream() << "[Started section: '" << prevSpan.name << "']" << std::endl;
prevSpan.emitted = true;
}
}
}
}
}
2012-05-16 15:53:59 +02:00
void streamVariableLengthText( const std::string& prefix, const std::string& text ) {
2011-04-11 09:30:47 +02:00
std::string trimmed = trim( text );
2012-05-16 15:53:59 +02:00
if( trimmed.find_first_of( "\r\n" ) == std::string::npos ) {
m_config.stream() << "[" << prefix << ": " << trimmed << "]";
2011-04-11 09:30:47 +02:00
}
2012-05-16 15:53:59 +02:00
else {
m_config.stream() << "\n[" << prefix << "] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n" << trimmed
<< "\n[end of " << prefix << "] <<<<<<<<<<<<<<<<<<<<<<<<\n";
2011-04-11 09:30:47 +02:00
}
}
2010-11-10 00:24:00 +01:00
private:
2012-07-20 20:07:42 +02:00
ReporterConfig m_config;
bool m_firstSectionInTestCase;
SpanInfo m_testingSpan;
SpanInfo m_groupSpan;
SpanInfo m_testSpan;
std::vector<SpanInfo> m_sectionSpans;
bool m_aborted;
2010-11-10 00:24:00 +01:00
};
2010-11-10 00:24:00 +01:00
} // end namespace Catch
#endif // TWOBLUECUBES_CATCH_REPORTER_BASIC_HPP_INCLUDED