catch2/include/reporters/catch_reporter_console.cpp

654 lines
26 KiB
C++
Raw Normal View History

/*
* 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)
*/
#include "catch_reporter_bases.hpp"
#include "../internal/catch_reporter_registrars.hpp"
#include "internal/catch_console_colour.h"
#include "../internal/catch_version.h"
#include "../internal/catch_text.h"
#include "../internal/catch_stringref.h"
#include <cfloat>
#include <cstdio>
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
// Note that 4062 (not all labels are handled
// and default is missing) is enabled
#endif
2017-09-19 15:38:18 +02:00
namespace Catch {
2017-09-19 15:38:18 +02:00
namespace {
std::size_t makeRatio( std::size_t number, std::size_t total ) {
std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number/ total : 0;
return ( ratio == 0 && number > 0 ) ? 1 : ratio;
}
2017-09-19 15:38:18 +02:00
std::size_t& findMax( std::size_t& i, std::size_t& j, std::size_t& k ) {
if( i > j && i > k )
return i;
else if( j > k )
return j;
else
return k;
}
2017-09-19 15:38:18 +02:00
struct ColumnInfo {
enum Justification { Left, Right };
std::string name;
int width;
Justification justification;
};
struct ColumnBreak {};
struct RowBreak {};
class TablePrinter {
std::ostream& m_os;
std::vector<ColumnInfo> m_columnInfos;
std::ostringstream m_oss;
int m_currentColumn = -1;
bool m_isOpen = false;
public:
TablePrinter( std::ostream& os, std::vector<ColumnInfo> const& columnInfos )
: m_os( os ),
m_columnInfos( columnInfos )
{}
auto columnInfos() const -> std::vector<ColumnInfo> const& {
return m_columnInfos;
}
2017-09-19 15:38:18 +02:00
void open() {
if( !m_isOpen ) {
m_isOpen = true;
*this << RowBreak();
for( auto const& info : m_columnInfos )
*this << info.name << ColumnBreak();
*this << RowBreak();
m_os << Catch::getLineOfChars<'-'>() << "\n";
}
}
void close() {
if( m_isOpen ) {
*this << RowBreak();
m_os << std::endl;
m_isOpen = false;
}
}
2017-09-19 15:38:18 +02:00
template<typename T>
friend TablePrinter& operator << ( TablePrinter& tp, T const& value ) {
tp.m_oss << value;
return tp;
}
2017-09-19 15:38:18 +02:00
friend TablePrinter& operator << ( TablePrinter& tp, ColumnBreak ) {
auto colStr = tp.m_oss.str();
// This takes account of utf8 encodings
auto strSize = Catch::StringRef( colStr ).numberOfCharacters();
tp.m_oss.str("");
tp.open();
if( tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size()-1) ) {
tp.m_currentColumn = -1;
tp.m_os << "\n";
}
tp.m_currentColumn++;
auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
auto padding = ( strSize+2 < static_cast<std::size_t>( colInfo.width ) )
? std::string( colInfo.width-(strSize+2), ' ' )
: std::string();
if( colInfo.justification == ColumnInfo::Left )
tp.m_os << colStr << padding << " ";
else
2017-09-19 15:38:18 +02:00
tp.m_os << padding << colStr << " ";
return tp;
}
2017-09-19 15:38:18 +02:00
friend TablePrinter& operator << ( TablePrinter& tp, RowBreak ) {
if( tp.m_currentColumn > 0 ) {
tp.m_os << "\n";
tp.m_currentColumn = -1;
}
return tp;
}
2017-09-19 15:38:18 +02:00
};
class Duration {
enum class Unit {
Auto,
Nanoseconds,
Microseconds,
Milliseconds,
Seconds,
Minutes
};
static const uint64_t s_nanosecondsInAMicrosecond = 1000;
static const uint64_t s_nanosecondsInAMillisecond = 1000*s_nanosecondsInAMicrosecond;
static const uint64_t s_nanosecondsInASecond = 1000*s_nanosecondsInAMillisecond;
static const uint64_t s_nanosecondsInAMinute = 60*s_nanosecondsInASecond;
uint64_t m_inNanoseconds;
Unit m_units;
public:
Duration( uint64_t inNanoseconds, Unit units = Unit::Auto )
: m_inNanoseconds( inNanoseconds ),
m_units( units )
{
if( m_units == Unit::Auto ) {
if( m_inNanoseconds < s_nanosecondsInAMicrosecond )
m_units = Unit::Nanoseconds;
else if( m_inNanoseconds < s_nanosecondsInAMillisecond )
m_units = Unit::Microseconds;
else if( m_inNanoseconds < s_nanosecondsInASecond )
m_units = Unit::Milliseconds;
else if( m_inNanoseconds < s_nanosecondsInAMinute )
m_units = Unit::Seconds;
else
m_units = Unit::Minutes;
}
}
2017-09-19 15:38:18 +02:00
auto value() const -> double {
switch( m_units ) {
case Unit::Microseconds:
return m_inNanoseconds / static_cast<double>( s_nanosecondsInAMicrosecond );
case Unit::Milliseconds:
return m_inNanoseconds / static_cast<double>( s_nanosecondsInAMillisecond );
case Unit::Seconds:
return m_inNanoseconds / static_cast<double>( s_nanosecondsInASecond );
case Unit::Minutes:
return m_inNanoseconds / static_cast<double>( s_nanosecondsInAMinute );
default:
return static_cast<double>( m_inNanoseconds );
}
}
auto unitsAsString() const -> std::string {
switch( m_units ) {
case Unit::Nanoseconds:
return "ns";
case Unit::Microseconds:
return "µs";
case Unit::Milliseconds:
return "ms";
case Unit::Seconds:
return "s";
case Unit::Minutes:
return "m";
default:
return "** internal error **";
}
2017-09-19 15:38:18 +02:00
}
friend auto operator << ( std::ostream& os, Duration const& duration ) -> std::ostream& {
return os << duration.value() << " " << duration.unitsAsString();
}
};
} // end anon namespace
struct ConsoleReporter : StreamingReporterBase<ConsoleReporter> {
TablePrinter m_tablePrinter;
ConsoleReporter( ReporterConfig const& config )
: StreamingReporterBase( config ),
m_tablePrinter( config.stream(),
{
2017-08-10 00:27:29 +02:00
{ "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH-32, ColumnInfo::Left },
{ "iters", 8, ColumnInfo::Right },
{ "elapsed ns", 14, ColumnInfo::Right },
{ "average", 14, ColumnInfo::Right }
} )
{}
~ConsoleReporter() override;
static std::string getDescription() {
return "Reports test results as plain lines of text";
}
void noMatchingTestCases( std::string const& spec ) override {
stream << "No test cases matched '" << spec << '\'' << std::endl;
}
void assertionStarting( AssertionInfo const& ) override {
}
bool assertionEnded( AssertionStats const& _assertionStats ) override {
AssertionResult const& result = _assertionStats.assertionResult;
bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
// Drop out if result was successful but we're not printing them.
if( !includeResults && result.getResultType() != ResultWas::Warning )
return false;
2012-12-09 12:20:46 +01:00
lazyPrint();
AssertionPrinter printer( stream, _assertionStats, includeResults );
2013-01-18 18:50:21 +01:00
printer.print();
stream << std::endl;
return true;
}
void sectionStarting( SectionInfo const& _sectionInfo ) override {
m_headerPrinted = false;
StreamingReporterBase::sectionStarting( _sectionInfo );
}
void sectionEnded( SectionStats const& _sectionStats ) override {
m_tablePrinter.close();
2013-01-18 18:50:21 +01:00
if( _sectionStats.missingAssertions ) {
lazyPrint();
Colour colour( Colour::ResultError );
if( m_sectionStack.size() > 1 )
stream << "\nNo assertions in section";
else
stream << "\nNo assertions in test case";
stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
2013-01-18 18:50:21 +01:00
}
if( m_config->showDurations() == ShowDurations::Always ) {
stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
}
if( m_headerPrinted ) {
m_headerPrinted = false;
}
2013-01-18 18:50:21 +01:00
StreamingReporterBase::sectionEnded( _sectionStats );
}
void benchmarkStarting( BenchmarkInfo const& info ) override {
lazyPrintWithoutClosingBenchmarkTable();
auto nameCol = Column( info.name ).width( m_tablePrinter.columnInfos()[0].width-2 );
bool firstLine = true;
for( auto line : nameCol ) {
if( !firstLine )
m_tablePrinter << ColumnBreak() << ColumnBreak() << ColumnBreak();
else
firstLine = false;
m_tablePrinter << line << ColumnBreak();
}
}
void benchmarkEnded( BenchmarkStats const& stats ) override {
Duration average( stats.elapsedTimeInNanoseconds/stats.iterations );
m_tablePrinter
<< stats.iterations << ColumnBreak()
<< stats.elapsedTimeInNanoseconds << ColumnBreak()
<< average << ColumnBreak();
}
void testCaseEnded( TestCaseStats const& _testCaseStats ) override {
m_tablePrinter.close();
2013-01-18 18:50:21 +01:00
StreamingReporterBase::testCaseEnded( _testCaseStats );
m_headerPrinted = false;
2013-01-17 13:07:34 +01:00
}
void testGroupEnded( TestGroupStats const& _testGroupStats ) override {
2013-08-08 09:24:37 +02:00
if( currentGroupInfo.used ) {
2013-01-18 18:50:21 +01:00
printSummaryDivider();
stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
printTotals( _testGroupStats.totals );
stream << '\n' << std::endl;
2013-01-18 18:50:21 +01:00
}
StreamingReporterBase::testGroupEnded( _testGroupStats );
}
void testRunEnded( TestRunStats const& _testRunStats ) override {
printTotalsDivider( _testRunStats.totals );
2013-01-18 18:50:21 +01:00
printTotals( _testRunStats.totals );
stream << std::endl;
2013-01-18 18:50:21 +01:00
StreamingReporterBase::testRunEnded( _testRunStats );
}
private:
2013-01-18 18:50:21 +01:00
class AssertionPrinter {
public:
AssertionPrinter& operator= ( AssertionPrinter const& ) = delete;
AssertionPrinter( AssertionPrinter const& ) = delete;
AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
2013-01-18 18:50:21 +01:00
: stream( _stream ),
stats( _stats ),
result( _stats.assertionResult ),
colour( Colour::None ),
message( result.getMessage() ),
messages( _stats.infoMessages ),
printInfoMessages( _printInfoMessages )
{
2013-01-18 18:50:21 +01:00
switch( result.getResultType() ) {
case ResultWas::Ok:
colour = Colour::Success;
2013-01-17 13:07:34 +01:00
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:
2013-01-18 18:50:21 +01:00
if( result.isOk() ) {
colour = Colour::Success;
2013-01-17 13:07:34 +01:00
passOrFail = "FAILED - but was ok";
}
else {
colour = Colour::Error;
2013-01-17 13:07:34 +01:00
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;
2013-01-17 13:07:34 +01:00
passOrFail = "FAILED";
messageLabel = "due to unexpected exception with ";
if (_stats.infoMessages.size() == 1)
messageLabel += "message";
if (_stats.infoMessages.size() > 1)
messageLabel += "messages";
break;
case ResultWas::FatalErrorCondition:
colour = Colour::Error;
passOrFail = "FAILED";
messageLabel = "due to a fatal error condition";
break;
case ResultWas::DidntThrowException:
colour = Colour::Error;
2013-01-17 13:07:34 +01:00
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:
2013-01-17 13:07:34 +01:00
passOrFail = "FAILED";
colour = Colour::Error;
if( _stats.infoMessages.size() == 1 )
messageLabel = "explicitly with message";
if( _stats.infoMessages.size() > 1 )
messageLabel = "explicitly with messages";
break;
2013-01-15 09:09:20 +01:00
// These cases are here to prevent compiler warnings
case ResultWas::Unknown:
case ResultWas::FailureBit:
case ResultWas::Exception:
passOrFail = "** internal error **";
colour = Colour::Error;
break;
}
}
2013-01-18 18:50:21 +01:00
void print() const {
printSourceInfo();
2013-01-18 18:50:21 +01:00
if( stats.totals.assertions.total() > 0 ) {
if( result.isOk() )
stream << '\n';
2013-01-18 18:50:21 +01:00
printResultType();
printOriginalExpression();
printReconstructedExpression();
}
else {
stream << '\n';
}
2013-01-18 18:50:21 +01:00
printMessage();
}
2013-01-18 18:50:21 +01:00
private:
void printResultType() const {
if( !passOrFail.empty() ) {
Colour colourGuard( colour );
2013-01-18 18:50:21 +01:00
stream << passOrFail << ":\n";
}
}
2013-01-18 18:50:21 +01:00
void printOriginalExpression() const {
if( result.hasExpression() ) {
Colour colourGuard( Colour::OriginalExpression );
2013-01-18 18:50:21 +01:00
stream << " ";
stream << result.getExpressionInMacro();
stream << '\n';
2013-01-18 18:50:21 +01:00
}
}
2013-01-18 18:50:21 +01:00
void printReconstructedExpression() const {
if( result.hasExpandedExpression() ) {
stream << "with expansion:\n";
Colour colourGuard( Colour::ReconstructedExpression );
stream << Column( result.getExpandedExpression() ).indent(2) << '\n';
2013-01-18 18:50:21 +01:00
}
}
2013-01-18 18:50:21 +01:00
void printMessage() const {
if( !messageLabel.empty() )
stream << messageLabel << ':' << '\n';
for( auto const& msg : messages ) {
// If this assertion is a warning ignore any INFO messages
if( printInfoMessages || msg.type != ResultWas::Info )
stream << Column( msg.message ).indent(2) << '\n';
}
2012-12-09 12:20:46 +01:00
}
2013-01-18 18:50:21 +01:00
void printSourceInfo() const {
Colour colourGuard( Colour::FileName );
stream << result.getSourceInfo() << ": ";
2012-12-09 12:20:46 +01:00
}
2013-01-18 18:50:21 +01:00
std::ostream& stream;
AssertionStats const& stats;
AssertionResult const& result;
Colour::Code colour;
2013-01-18 18:50:21 +01:00
std::string passOrFail;
std::string messageLabel;
std::string message;
std::vector<MessageInfo> messages;
bool printInfoMessages;
2013-01-18 18:50:21 +01:00
};
2013-01-14 19:51:49 +01:00
void lazyPrint() {
m_tablePrinter.close();
lazyPrintWithoutClosingBenchmarkTable();
}
void lazyPrintWithoutClosingBenchmarkTable() {
2013-08-08 09:24:37 +02:00
if( !currentTestRunInfo.used )
2013-01-14 19:51:49 +01:00
lazyPrintRunInfo();
2013-08-08 09:24:37 +02:00
if( !currentGroupInfo.used )
2013-01-14 19:51:49 +01:00
lazyPrintGroupInfo();
if( !m_headerPrinted ) {
printTestCaseAndSectionHeader();
m_headerPrinted = true;
}
2013-01-14 19:51:49 +01:00
}
void lazyPrintRunInfo() {
stream << '\n' << getLineOfChars<'~'>() << '\n';
Colour colour( Colour::SecondaryText );
2013-08-08 09:24:37 +02:00
stream << currentTestRunInfo->name
<< " is a Catch v" << libraryVersion() << " host application.\n"
2013-01-14 19:51:49 +01:00
<< "Run with -? for options\n\n";
if( m_config->rngSeed() != 0 )
stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
2013-08-08 09:24:37 +02:00
currentTestRunInfo.used = true;
2013-01-14 19:51:49 +01:00
}
void lazyPrintGroupInfo() {
2013-08-08 09:24:37 +02:00
if( !currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1 ) {
printClosedHeader( "Group: " + currentGroupInfo->name );
currentGroupInfo.used = true;
2013-01-14 19:51:49 +01:00
}
}
void printTestCaseAndSectionHeader() {
assert( !m_sectionStack.empty() );
2013-08-08 09:24:37 +02:00
printOpenHeader( currentTestCaseInfo->name );
if( m_sectionStack.size() > 1 ) {
Colour colourGuard( Colour::Headers );
auto
it = m_sectionStack.begin()+1, // Skip first section (test case)
itEnd = m_sectionStack.end();
for( ; it != itEnd; ++it )
printHeaderString( it->name, 2 );
2013-01-14 19:51:49 +01:00
}
SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
2013-04-17 01:05:25 +02:00
if( !lineInfo.empty() ){
stream << getLineOfChars<'-'>() << '\n';
2013-04-17 01:05:25 +02:00
Colour colourGuard( Colour::FileName );
stream << lineInfo << '\n';
2013-04-17 01:05:25 +02:00
}
stream << getLineOfChars<'.'>() << '\n' << std::endl;
2013-01-14 19:51:49 +01:00
}
2013-01-16 10:39:08 +01:00
void printClosedHeader( std::string const& _name ) {
printOpenHeader( _name );
stream << getLineOfChars<'.'>() << '\n';
}
void printOpenHeader( std::string const& _name ) {
stream << getLineOfChars<'-'>() << '\n';
2013-04-01 12:25:54 +02:00
{
Colour colourGuard( Colour::Headers );
printHeaderString( _name );
2013-04-01 12:25:54 +02:00
}
2013-01-14 19:51:49 +01:00
}
// 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 << Column( _string ).indent( indent+i ).initialIndent( indent ) << '\n';
}
2014-07-09 20:20:24 +02:00
struct SummaryColumn {
SummaryColumn( std::string const& _label, Colour::Code _colour )
: label( _label ),
colour( _colour )
{}
SummaryColumn addRow( std::size_t count ) {
ReusableStringStream rss;
rss << count;
std::string row = rss.str();
for( auto& oldRow : rows ) {
while( oldRow.size() < row.size() )
oldRow = ' ' + oldRow;
while( oldRow.size() > row.size() )
row = ' ' + row;
2014-07-09 20:20:24 +02:00
}
rows.push_back( row );
return *this;
}
std::string label;
Colour::Code colour;
std::vector<std::string> rows;
};
void printTotals( Totals const& totals ) {
2013-11-12 20:06:08 +01:00
if( totals.testCases.total() == 0 ) {
stream << Colour( Colour::Warning ) << "No tests ran\n";
2013-01-14 19:51:49 +01:00
}
2016-03-14 20:13:34 +01:00
else if( totals.assertions.total() > 0 && totals.testCases.allPassed() ) {
stream << Colour( Colour::ResultSuccess ) << "All tests passed";
stream << " ("
2013-01-14 19:51:49 +01:00
<< pluralise( totals.assertions.passed, "assertion" ) << " in "
<< pluralise( totals.testCases.passed, "test case" ) << ')'
<< '\n';
2013-01-14 19:51:49 +01:00
}
2014-07-09 20:20:24 +02:00
else {
std::vector<SummaryColumn> columns;
columns.push_back( SummaryColumn( "", Colour::None )
.addRow( totals.testCases.total() )
.addRow( totals.assertions.total() ) );
columns.push_back( SummaryColumn( "passed", Colour::Success )
.addRow( totals.testCases.passed )
.addRow( totals.assertions.passed ) );
columns.push_back( SummaryColumn( "failed", Colour::ResultError )
.addRow( totals.testCases.failed )
.addRow( totals.assertions.failed ) );
columns.push_back( SummaryColumn( "failed as expected", Colour::ResultExpectedFailure )
.addRow( totals.testCases.failedButOk )
.addRow( totals.assertions.failedButOk ) );
printSummaryRow( "test cases", columns, 0 );
printSummaryRow( "assertions", columns, 1 );
}
2013-01-14 19:51:49 +01:00
}
2014-07-09 20:20:24 +02:00
void printSummaryRow( std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row ) {
for( auto col : cols ) {
std::string value = col.rows[row];
if( col.label.empty() ) {
2014-07-09 20:20:24 +02:00
stream << label << ": ";
if( value != "0" )
stream << value;
else
stream << Colour( Colour::Warning ) << "- none -";
}
else if( value != "0" ) {
stream << Colour( Colour::LightGrey ) << " | ";
stream << Colour( col.colour )
<< value << ' ' << col.label;
2014-07-09 20:20:24 +02:00
}
2013-01-14 19:51:49 +01:00
}
stream << '\n';
2013-01-14 19:51:49 +01:00
}
void printTotalsDivider( Totals const& totals ) {
if( totals.testCases.total() > 0 ) {
std::size_t failedRatio = makeRatio( totals.testCases.failed, totals.testCases.total() );
std::size_t failedButOkRatio = makeRatio( totals.testCases.failedButOk, totals.testCases.total() );
std::size_t passedRatio = makeRatio( totals.testCases.passed, totals.testCases.total() );
while( failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH-1 )
findMax( failedRatio, failedButOkRatio, passedRatio )++;
while( failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH-1 )
findMax( failedRatio, failedButOkRatio, passedRatio )--;
stream << Colour( Colour::Error ) << std::string( failedRatio, '=' );
stream << Colour( Colour::ResultExpectedFailure ) << std::string( failedButOkRatio, '=' );
if( totals.testCases.allPassed() )
stream << Colour( Colour::ResultSuccess ) << std::string( passedRatio, '=' );
else
stream << Colour( Colour::Success ) << std::string( passedRatio, '=' );
}
else {
stream << Colour( Colour::Warning ) << std::string( CATCH_CONFIG_CONSOLE_WIDTH-1, '=' );
}
stream << '\n';
}
void printSummaryDivider() {
stream << getLineOfChars<'-'>() << '\n';
}
private:
bool m_headerPrinted = false;
};
CATCH_REGISTER_REPORTER( "console", ConsoleReporter )
ConsoleReporter::~ConsoleReporter() {}
} // end namespace Catch
#if defined(_MSC_VER)
#pragma warning(pop)
#endif