mirror of
https://github.com/catchorg/Catch2.git
synced 2024-11-17 11:12:25 +01:00
552 lines
20 KiB
C++
552 lines
20 KiB
C++
/*
|
|
* Created by Malcolm on 4/11/2013.
|
|
* Copyright 2013 Malcolm Noyes. 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_MSTEST_HPP_INCLUDED
|
|
#define TWOBLUECUBES_CATCH_REPORTER_MSTEST_HPP_INCLUDED
|
|
|
|
#include "../internal/catch_interfaces_reporter.h"
|
|
#include "../internal/catch_text.h"
|
|
#include "../internal/catch_version.h"
|
|
#include "../internal/catch_console_colour.hpp"
|
|
|
|
namespace Catch {
|
|
|
|
#if (_MANAGED == 1) || (_M_CEE == 1) // detect CLR
|
|
|
|
inline void write_output_message(const std::string& msg)
|
|
{
|
|
String^ tmp = gcnew String(msg.c_str());
|
|
Console::WriteLine(tmp);
|
|
}
|
|
|
|
#else // detect CLR
|
|
|
|
#ifdef _WINDLL
|
|
|
|
#ifdef _UNICODE
|
|
inline void write_output_message(const std::string& msg)
|
|
{
|
|
std::wstringstream _s;
|
|
_s << msg.c_str();
|
|
std::wstring ws = _s.str();
|
|
Logger::WriteMessage(ws.c_str());
|
|
}
|
|
#else
|
|
inline void write_output_message(const std::string& msg)
|
|
{
|
|
Logger::WriteMessage(msg.c_str());
|
|
}
|
|
#endif
|
|
|
|
#endif // _WINDLL
|
|
|
|
#endif // detect CLR
|
|
inline void replaceSingleLinefeed(const std::string& s, std::string& result)
|
|
{
|
|
bool needr(false);
|
|
for(std::string::const_iterator it = s.begin(); it != s.end(); ++it ) {
|
|
if( *it == '\r' ) {
|
|
needr = false;
|
|
}
|
|
else if( *it == '\n' && needr ) {
|
|
needr = false;
|
|
result += '\r';
|
|
result += *it;
|
|
}
|
|
else {
|
|
needr = true;
|
|
}
|
|
result += *it;
|
|
}
|
|
}
|
|
|
|
struct VSStreamingReporterBase : SharedImpl<IStreamingReporter> {
|
|
|
|
VSStreamingReporterBase( ReporterConfig const& _config )
|
|
: m_config( _config.fullConfig() )
|
|
{}
|
|
|
|
virtual ~VSStreamingReporterBase() {}
|
|
|
|
virtual void noMatchingTestCases( std::string const& ) {}
|
|
|
|
virtual void testRunStarting( TestRunInfo const& _testRunInfo ) {
|
|
currentTestRunInfo = _testRunInfo;
|
|
}
|
|
virtual void testGroupStarting( GroupInfo const& _groupInfo ) {
|
|
currentGroupInfo = _groupInfo;
|
|
}
|
|
|
|
virtual void testCaseStarting( TestCaseInfo const& _testInfo ) {
|
|
currentTestCaseInfo = _testInfo;
|
|
}
|
|
virtual void sectionStarting( SectionInfo const& _sectionInfo ) {
|
|
m_sectionStack.push_back( _sectionInfo );
|
|
}
|
|
|
|
virtual void sectionEnded( SectionStats const& /* _sectionStats */ ) {
|
|
m_sectionStack.pop_back();
|
|
}
|
|
virtual void testCaseEnded( TestCaseStats const& /* _testCaseStats */ ) {
|
|
currentTestCaseInfo.reset();
|
|
assert( m_sectionStack.empty() );
|
|
}
|
|
virtual void testGroupEnded( TestGroupStats const& /* _testGroupStats */ ) {
|
|
currentGroupInfo.reset();
|
|
}
|
|
virtual void testRunEnded( TestRunStats const& /* _testRunStats */ ) {
|
|
currentTestCaseInfo.reset();
|
|
currentGroupInfo.reset();
|
|
currentTestRunInfo.reset();
|
|
}
|
|
|
|
Ptr<IConfig> m_config;
|
|
|
|
LazyStat<TestRunInfo> currentTestRunInfo;
|
|
LazyStat<GroupInfo> currentGroupInfo;
|
|
LazyStat<TestCaseInfo> currentTestCaseInfo;
|
|
|
|
std::vector<SectionInfo> m_sectionStack;
|
|
};
|
|
|
|
struct MSTestReporter : VSStreamingReporterBase {
|
|
typedef VSStreamingReporterBase StreamingReporterBase;
|
|
MSTestReporter( ReporterConfig const& _config )
|
|
: VSStreamingReporterBase( _config ),
|
|
m_prevCout( std::cout.rdbuf() ),
|
|
m_prevCerr( std::cerr.rdbuf() ),
|
|
#if defined(INTERNAL_CATCH_VS_NATIVE) || _MSC_VER >= 1700
|
|
m_addLineFeeds(false),
|
|
#else
|
|
m_addLineFeeds(true),
|
|
#endif
|
|
m_headerPrinted( false ),
|
|
m_atLeastOneTestCasePrinted( false )
|
|
{
|
|
std::cout.rdbuf( stream.rdbuf() );
|
|
std::cerr.rdbuf( stream.rdbuf() );
|
|
}
|
|
|
|
virtual ~MSTestReporter() {
|
|
std::string output = stream.str();
|
|
if( !output.empty() ) {
|
|
if( m_addLineFeeds ) {
|
|
std::string revised;
|
|
replaceSingleLinefeed(output, revised);
|
|
write_output_message(revised);
|
|
}
|
|
else {
|
|
write_output_message(output);
|
|
}
|
|
}
|
|
std::cout.rdbuf( m_prevCout );
|
|
std::cerr.rdbuf( m_prevCerr );
|
|
}
|
|
|
|
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;
|
|
|
|
bool printInfoMessages = true;
|
|
|
|
// Drop out if result was successful and we're not printing those
|
|
if( !m_config->includeSuccessfulResults() && result.isOk() ) {
|
|
if( result.getResultType() != ResultWas::Warning )
|
|
return false;
|
|
printInfoMessages = false;
|
|
}
|
|
|
|
lazyPrint();
|
|
|
|
AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
|
|
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 );
|
|
if( m_sectionStack.size() > 1 )
|
|
stream << "\nNo assertions in section";
|
|
else
|
|
stream << "\nNo assertions in test case";
|
|
stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
|
|
}
|
|
if( m_headerPrinted ) {
|
|
if( m_config->showDurations() == ShowDurations::Always )
|
|
stream << "Completed in " << _sectionStats.durationInSeconds << "s" << std::endl;
|
|
m_headerPrinted = false;
|
|
}
|
|
else {
|
|
if( m_config->showDurations() == ShowDurations::Always )
|
|
stream << _sectionStats.sectionInfo.name << " completed in " << _sectionStats.durationInSeconds << "s" << std::endl;
|
|
}
|
|
StreamingReporterBase::sectionEnded( _sectionStats );
|
|
}
|
|
|
|
virtual void testCaseEnded( TestCaseStats const& _testCaseStats ) {
|
|
StreamingReporterBase::testCaseEnded( _testCaseStats );
|
|
m_headerPrinted = false;
|
|
}
|
|
virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) {
|
|
if( currentGroupInfo.used ) {
|
|
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, bool _printInfoMessages )
|
|
: stream( _stream ),
|
|
stats( _stats ),
|
|
result( _stats.assertionResult ),
|
|
colour( Colour::None ),
|
|
message( result.getMessage() ),
|
|
messages( _stats.infoMessages ),
|
|
printInfoMessages( _printInfoMessages )
|
|
{
|
|
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 ) {
|
|
// If this assertion is a warning ignore any INFO messages
|
|
if( printInfoMessages || it->type != ResultWas::Info )
|
|
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;
|
|
bool printInfoMessages;
|
|
};
|
|
|
|
void lazyPrint() {
|
|
|
|
if( !currentTestRunInfo.used )
|
|
lazyPrintRunInfo();
|
|
if( !currentGroupInfo.used )
|
|
lazyPrintGroupInfo();
|
|
|
|
if( !m_headerPrinted ) {
|
|
printTestCaseAndSectionHeader();
|
|
m_headerPrinted = true;
|
|
}
|
|
m_atLeastOneTestCasePrinted = true;
|
|
}
|
|
void lazyPrintRunInfo() {
|
|
stream << "\n" << getTildes() << "\n";
|
|
Colour colour( Colour::SecondaryText );
|
|
stream << "Using Catch v" << libraryVersion::value.majorVersion << "."
|
|
<< libraryVersion::value.minorVersion << " b"
|
|
<< libraryVersion::value.buildNumber;
|
|
if( libraryVersion::value.branchName != "master" )
|
|
stream << " (" << libraryVersion::value.branchName << ")";
|
|
#if (_MANAGED == 1) || (_M_CEE == 1) // detect CLR
|
|
stream << " for a managed MSTest project." << "\n";
|
|
#else
|
|
#ifdef _WINDLL
|
|
stream << " for a native MSTest project." << "\n";
|
|
#endif
|
|
#endif
|
|
|
|
currentTestRunInfo.used = true;
|
|
}
|
|
void lazyPrintGroupInfo() {
|
|
if( !currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1 ) {
|
|
printClosedHeader( "Group: " + currentGroupInfo->name );
|
|
currentGroupInfo.used = true;
|
|
}
|
|
}
|
|
void printTestCaseAndSectionHeader() {
|
|
assert( !m_sectionStack.empty() );
|
|
printOpenHeader( currentTestCaseInfo->name );
|
|
|
|
if( m_sectionStack.size() > 1 ) {
|
|
Colour colourGuard( Colour::Headers );
|
|
|
|
std::vector<SectionInfo>::const_iterator
|
|
it = m_sectionStack.begin()+1, // Skip first section (test case)
|
|
itEnd = m_sectionStack.end();
|
|
for( ; it != itEnd; ++it )
|
|
printHeaderString( it->name, 2 );
|
|
}
|
|
|
|
SourceLineInfo lineInfo = m_sectionStack.front().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.testCases.total() == 0 ) {
|
|
stream << "No tests ran";
|
|
}
|
|
else if( totals.assertions.total() == 0 ) {
|
|
Colour colour( Colour::Yellow );
|
|
printCounts( "test case", totals.testCases );
|
|
stream << " (no assertions)";
|
|
}
|
|
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 getDashes() {
|
|
const std::string dashes( CATCH_CONFIG_CONSOLE_WIDTH-1, '-' );
|
|
return dashes;
|
|
}
|
|
static std::string getDots() {
|
|
const std::string dots( CATCH_CONFIG_CONSOLE_WIDTH-1, '.' );
|
|
return dots;
|
|
}
|
|
static std::string getDoubleDashes() {
|
|
const std::string doubleDashes( CATCH_CONFIG_CONSOLE_WIDTH-1, '=' );
|
|
return doubleDashes;
|
|
}
|
|
static std::string getTildes() {
|
|
const std::string dots( CATCH_CONFIG_CONSOLE_WIDTH-1, '~' );
|
|
return dots;
|
|
}
|
|
|
|
private:
|
|
std::ostringstream stream;
|
|
std::streambuf* m_prevCout;
|
|
std::streambuf* m_prevCerr;
|
|
protected:
|
|
bool m_addLineFeeds;
|
|
|
|
private:
|
|
bool m_headerPrinted;
|
|
bool m_atLeastOneTestCasePrinted;
|
|
};
|
|
|
|
struct MSTestReporterLineFeed : MSTestReporter {
|
|
MSTestReporterLineFeed( ReporterConfig const& _config )
|
|
: MSTestReporter( _config )
|
|
{
|
|
m_addLineFeeds = false;
|
|
}
|
|
};
|
|
} // end namespace Catch
|
|
|
|
#endif // TWOBLUECUBES_CATCH_REPORTER_MSTEST_HPP_INCLUDED
|