3rd-party/catch2
1
0
Fork 0
mirror of https://github.com/catchorg/Catch2.git synced 2024-11-22 13:26:10 +01:00
Code Issues Packages Projects Releases Wiki Activity

Fleshed out console reporter

Browse Source
This commit is contained in:
Phil Nash 2012-12-09 11:20:46 +00:00
parent daedf8ff5f
commit e6d1c9897a
3 changed files with 189 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
approvalTests.py
View File

@ -14,7 +14,9 @@ filteredResultsPath = os.path.join( catchPath, 'projects/SelfTest/Baselines/unap
cmdPath = sys.argv[1]
f = open( rawResultsPath, 'w' )
subprocess.call([ cmdPath, "~dummy", "-s", "-w", "NoAssertions" ], stdout=f, stderr=f )
subprocess.call([ cmdPath, "~dummy", "-s", "-w", "NoAssertions", "-r", "basic" ], stdout=f, stderr=f )
#subprocess.call([ cmdPath, "~dummy", "-s", "-w", "NoAssertions", "-r", "console" ], stdout=f, stderr=f )
#subprocess.call([ cmdPath, "~dummy", "-s", "-w", "NoAssertions", "-r", "basic", "-a", "4" ], stdout=f, stderr=f )
subprocess.call([ cmdPath, "~dummy", "-s", "-w", "NoAssertions", "-r", "junit" ], stdout=f, stderr=f )
subprocess.call([ cmdPath, "~dummy", "-s", "-w", "NoAssertions", "-r", "xml" ], stdout=f, stderr=f )
f.close()

8
include/internal/catch_interfaces_reporter.h
View File

@ -70,12 +70,14 @@ namespace Catch
struct ThreadedSectionInfo : SectionInfo, SharedImpl<> {
ThreadedSectionInfo( SectionInfo const& _sectionInfo, Ptr<ThreadedSectionInfo> const& _parent = Ptr<ThreadedSectionInfo>() )
: SectionInfo( _sectionInfo ),
parent( _parent )
parent( _parent ),
printed( false )
{}
virtual ~ThreadedSectionInfo();
std::vector<Ptr<ThreadedSectionInfo> > children;
Ptr<ThreadedSectionInfo> parent;
bool printed;
};
struct AssertionStats : SharedImpl<> {
@ -190,7 +192,8 @@ namespace Catch
struct AccumulatingReporter : SharedImpl<IStreamingReporter> {
AccumulatingReporter( ReporterConfig const& _config )
: stream( _config.stream() )
: m_config( _config ),
stream( _config.stream() )
{}
virtual ~AccumulatingReporter();
@ -231,6 +234,7 @@ namespace Catch
virtual void testRunEnded( Ptr<TestRunStats const> const& /* _testRunStats */ ) {
}
ReporterConfig m_config;
Option<TestRunInfo> testRunInfo;
Option<GroupInfo> unusedGroupInfo;
Option<TestCaseInfo> unusedTestCaseInfo;

190
include/reporters/catch_reporter_console.hpp
View File

@ -35,11 +35,13 @@ namespace Catch {
}
void lazyPrintGroupInfo() {
if( !unusedGroupInfo->name.empty() )
stream << "[Group: '" << unusedGroupInfo->name << "']" << std::endl;
// stream << "[Group: '" << unusedGroupInfo->name << "']" << std::endl;
stream << "[Started group: '" << unusedGroupInfo->name << "']" << std::endl;
unusedGroupInfo.reset();
}
void lazyPrintTestCaseInfo() {
stream << "[Test case: '" << unusedTestCaseInfo->name << "']" << std::endl;
// stream << "[Test case: '" << unusedTestCaseInfo->name << "']" << std::endl;
stream << "[Running: " << unusedTestCaseInfo->name << "]" << std::endl;
unusedTestCaseInfo.reset();
}
std::string makeSectionPath( ThreadedSectionInfo const * section, std::string const& delimiter ) {
@ -49,6 +51,7 @@ namespace Catch {
return sectionPath;
}
void lazyPrintSectionInfo() {
// !TBD use printed flag
ThreadedSectionInfo* section = unusedSectionInfo.get();
std::string sectionPath = makeSectionPath( section, ", " );
@ -58,6 +61,21 @@ namespace Catch {
stream << "[Section: " << sectionPath << "]" << std::endl;
unusedSectionInfo.reset();
}
void lazyPrintSectionInfoLegacy() {
std::vector<ThreadedSectionInfo*> sections;
for( ThreadedSectionInfo* section = unusedSectionInfo.get();
section && !section->printed;
section = section->parent.get() )
sections.push_back( section );
typedef std::vector<ThreadedSectionInfo*>::const_reverse_iterator It;
for( It it = sections.rbegin(), itEnd = sections.rend(); it != itEnd; ++it ) {
stream << "[Started section: " << "'" + (*it)->name + "'" << "]" << std::endl;
(*it)->printed = true;
}
unusedSectionInfo.reset();
}
void lazyPrint() {
if( testRunInfo )
lazyPrintRunInfo();
@ -65,15 +83,132 @@ namespace Catch {
lazyPrintGroupInfo();
if( unusedTestCaseInfo )
lazyPrintTestCaseInfo();
if( unusedSectionInfo )
lazyPrintSectionInfo();
if( currentSectionInfo && !currentSectionInfo->printed )
lazyPrintSectionInfoLegacy(); // !TBD
}
virtual void assertionStarting( AssertionInfo const& _assertionInfo ) {
virtual void assertionStarting( AssertionInfo const& ) {
}
virtual void assertionEnded( Ptr<AssertionStats const> const& _assertionStats ) {
if( !_assertionStats->assertionResult.isOk() )
AssertionResult const& result = _assertionStats->assertionResult;
// Drop out if result was successful and we're not printing those
if( !m_config.includeSuccessfulResults() && result.isOk() )
return;
lazyPrint();
if( !result.getSourceInfo().empty() ) {
TextColour colour( TextColour::FileName );
stream << result.getSourceInfo();
}
if( result.hasExpression() ) {
TextColour colour( TextColour::OriginalExpression );
stream << result.getExpression();
if( result.succeeded() ) {
TextColour successColour( TextColour::Success );
stream << " succeeded";
}
else {
TextColour errorColour( TextColour::Error );
stream << " failed";
if( result.isOk() ) {
TextColour okAnywayColour( TextColour::Success );
stream << " - but was ok";
}
}
}
switch( result.getResultType() ) {
case ResultWas::ThrewException:
{
TextColour colour( TextColour::Error );
if( result.hasExpression() )
stream << " with unexpected";
else
stream << "Unexpected";
stream << " exception with message: '" << result.getMessage() << "'";
}
break;
case ResultWas::DidntThrowException:
{
TextColour colour( TextColour::Error );
if( result.hasExpression() )
stream << " because no exception was thrown where one was expected";
else
stream << "No exception thrown where one was expected";
}
break;
case ResultWas::Info:
{
TextColour colour( TextColour::ReconstructedExpression );
streamVariableLengthText( "info", result.getMessage() );
}
break;
case ResultWas::Warning:
{
TextColour colour( TextColour::ReconstructedExpression );
streamVariableLengthText( "warning", result.getMessage() );
}
break;
case ResultWas::ExplicitFailure:
{
TextColour colour( TextColour::Error );
stream << "failed with message: '" << result.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( !result.hasExpression() ) {
if( result.succeeded() ) {
TextColour colour( TextColour::Success );
stream << " succeeded";
}
else {
TextColour colour( TextColour::Error );
stream << " failed";
if( result.isOk() ) {
TextColour okAnywayColour( TextColour::Success );
stream << " - but was ok";
}
}
}
if( result.hasMessage() ) {
stream << "\n";
TextColour colour( TextColour::ReconstructedExpression );
streamVariableLengthText( "with message", result.getMessage() );
}
break;
}
if( result.hasExpandedExpression() ) {
stream << " for: ";
if( result.getExpandedExpression().size() > 40 ) {
stream << "\n";
if( result.getExpandedExpression().size() < 70 )
stream << "\t";
}
TextColour colour( TextColour::ReconstructedExpression );
stream << result.getExpandedExpression();
}
stream << std::endl;
}
void streamVariableLengthText( std::string const& prefix, std::string const& text ) {
std::string trimmed = trim( text );
if( trimmed.find_first_of( "\r\n" ) == std::string::npos ) {
stream << "[" << prefix << ": " << trimmed << "]";
}
else {
stream << "\n[" << prefix << "] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n" << trimmed
<< "\n[end of " << prefix << "] <<<<<<<<<<<<<<<<<<<<<<<<\n";
}
}
void printAssertionCounts( std::string const& label, Counts const& counts, std::string const& allPrefix = "All " ) {
@ -105,27 +240,58 @@ namespace Catch {
}
virtual void sectionEnded( Ptr<SectionStats const> const& _sectionStats ) {
if( !unusedSectionInfo ) {
stream << "[Summary for section '" << _sectionStats->sectionInfo.name << "': ";
printAssertionCounts( "assertion", _sectionStats->assertions );
if( _sectionStats->missingAssertions ) {
lazyPrint();
TextColour colour( TextColour::ResultError );
stream << "\nNo assertions in section, '" << _sectionStats->sectionInfo.name << "'\n" << std::endl;
}
if( currentSectionInfo && currentSectionInfo->printed ) {
// stream << "[Summary for section '" << _sectionStats->sectionInfo.name << "': ";
stream << "[End of section: '" << _sectionStats->sectionInfo.name << "' ";
Counts const& assertions = _sectionStats->assertions;
if( assertions.failed ) {
TextColour colour( TextColour::ResultError );
printAssertionCounts( "assertion", assertions );
}
else {
TextColour colour( TextColour::ResultSuccess );
stream << ( assertions.passed > 1 ? "All " : "" )
<< pluralise( assertions.passed, "assertion" ) << " passed" ;
}
stream << "]\n" << std::endl;
}
AccumulatingReporter::sectionEnded( _sectionStats );
}
virtual void testCaseEnded( Ptr<TestCaseStats const> const& _testCaseStats ) {
if( _testCaseStats->missingAssertions ) {
lazyPrint();
TextColour colour( TextColour::ResultError );
stream << "\nNo assertions in test case, '" << _testCaseStats->testInfo.name << "'\n" << std::endl;
}
if( !unusedTestCaseInfo ) {
stream << "[Summary for test case '" << _testCaseStats->testInfo.name << "': ";
// stream << "[Summary for test case '" << _testCaseStats->testInfo.name << "': ";
stream << "[Finished: '" << _testCaseStats->testInfo.name << "' ";
printTotals( _testCaseStats->totals );
stream << "]\n" << std::endl;
}
AccumulatingReporter::testCaseEnded( _testCaseStats );
}
virtual void testGroupEnded( Ptr<TestGroupStats const> const& _testGroupStats ) {
// !TBD
if( !unusedGroupInfo ) {
// stream << "[Summary for group '" << _testGroupStats->groupInfo.name << "': ";
stream << "[End of group '" << _testGroupStats->groupInfo.name << "'. ";
printTotals( _testGroupStats->totals );
stream << "]\n" << std::endl;
}
AccumulatingReporter::testGroupEnded( _testGroupStats );
}
virtual void testRunEnded( Ptr<TestRunStats const> const& _testRunStats ) {
// !TBD
if( !unusedTestCaseInfo ) {
// stream << "[Summary for '" << _testRunStats->runInfo.name << "': ";
stream << "[Testing completed. ";
printTotals( _testRunStats->totals );
stream << "]\n" << std::endl;
}
AccumulatingReporter::testRunEnded( _testRunStats );
}