mirror of
https://github.com/catchorg/Catch2.git
synced 2025-08-01 12:55:40 +02:00
Re-org
This commit is contained in:
Phil Nash
346
include/reporters/catch_reporter_basic.hpp
Normal file
346
include/reporters/catch_reporter_basic.hpp
Normal file
@@ -0,0 +1,346 @@
|
||||
/*
|
||||
* catch_reporter_basic.hpp
|
||||
* Catch
|
||||
*
|
||||
* 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"
|
||||
|
||||
namespace Catch
|
||||
{
|
||||
class BasicReporter : public 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 IReporterConfig& config
|
||||
)
|
||||
: m_config( config )
|
||||
{
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
static std::string getDescription
|
||||
()
|
||||
{
|
||||
return "Reports test results as lines of text";
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
void ReportCounts
|
||||
(
|
||||
std::size_t succeeded,
|
||||
std::size_t failed
|
||||
)
|
||||
{
|
||||
if( failed + succeeded == 0 )
|
||||
m_config.stream() << "No tests ran";
|
||||
else if( failed == 0 )
|
||||
m_config.stream() << "All " << succeeded << " test(s) succeeded";
|
||||
else if( succeeded == 0 )
|
||||
m_config.stream() << "All " << failed << " test(s) failed";
|
||||
else
|
||||
m_config.stream() << succeeded << " test(s) passed but " << failed << " test(s) failed";
|
||||
}
|
||||
|
||||
private: // IReporter
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void StartTesting
|
||||
()
|
||||
{
|
||||
m_testingSpan = SpanInfo();
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void EndTesting
|
||||
(
|
||||
std::size_t succeeded,
|
||||
std::size_t failed
|
||||
)
|
||||
{
|
||||
// Output the overall test results even if "Started Testing" was not emitted
|
||||
m_config.stream() << "[Testing completed. ";
|
||||
ReportCounts( succeeded, failed );
|
||||
m_config.stream() << "]\n" << std::endl;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void StartGroup
|
||||
(
|
||||
const std::string& groupName
|
||||
)
|
||||
{
|
||||
m_groupSpan = groupName;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void EndGroup
|
||||
(
|
||||
const std::string& groupName,
|
||||
std::size_t succeeded,
|
||||
std::size_t failed
|
||||
)
|
||||
{
|
||||
if( m_groupSpan.emitted && !groupName.empty() )
|
||||
{
|
||||
m_config.stream() << "[End of group: '" << groupName << "'. ";
|
||||
ReportCounts( succeeded, failed );
|
||||
m_config.stream() << "]\n" << std::endl;
|
||||
m_groupSpan = SpanInfo();
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void StartTestCase
|
||||
(
|
||||
const TestCaseInfo& testInfo
|
||||
)
|
||||
{
|
||||
m_testSpan = testInfo.getName();
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void StartSection
|
||||
(
|
||||
const std::string& sectionName,
|
||||
const std::string /*description*/
|
||||
)
|
||||
{
|
||||
m_sectionSpans.push_back( SpanInfo( sectionName ) );
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void EndSection
|
||||
(
|
||||
const std::string& sectionName,
|
||||
std::size_t succeeded,
|
||||
std::size_t failed
|
||||
)
|
||||
{
|
||||
SpanInfo& sectionSpan = m_sectionSpans.back();
|
||||
if( sectionSpan.emitted && !sectionSpan.name.empty() )
|
||||
{
|
||||
m_config.stream() << "[End of section: '" << sectionName << "'. ";
|
||||
ReportCounts( succeeded, failed );
|
||||
m_config.stream() << "]\n" << std::endl;
|
||||
}
|
||||
m_sectionSpans.pop_back();
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void Result
|
||||
(
|
||||
const ResultInfo& resultInfo
|
||||
)
|
||||
{
|
||||
if( !m_config.includeSuccessfulResults() && resultInfo.getResultType() == ResultWas::Ok )
|
||||
return;
|
||||
|
||||
StartSpansLazily();
|
||||
|
||||
if( !resultInfo.getFilename().empty() )
|
||||
#ifndef __GNUG__
|
||||
m_config.stream() << resultInfo.getFilename() << "(" << resultInfo.getLine() << "): ";
|
||||
#else
|
||||
m_config.stream() << resultInfo.getFilename() << ":" << resultInfo.getLine() << ": ";
|
||||
#endif
|
||||
|
||||
if( resultInfo.hasExpression() )
|
||||
{
|
||||
m_config.stream() << resultInfo.getExpression();
|
||||
if( resultInfo.ok() )
|
||||
m_config.stream() << " succeeded";
|
||||
else
|
||||
m_config.stream() << " failed";
|
||||
}
|
||||
switch( resultInfo.getResultType() )
|
||||
{
|
||||
case ResultWas::ThrewException:
|
||||
if( resultInfo.hasExpression() )
|
||||
m_config.stream() << " with unexpected";
|
||||
else
|
||||
m_config.stream() << "Unexpected";
|
||||
m_config.stream() << " exception with message: '" << resultInfo.getMessage() << "'";
|
||||
break;
|
||||
case ResultWas::DidntThrowException:
|
||||
if( resultInfo.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:
|
||||
streamVariableLengthText( "info", resultInfo.getMessage() );
|
||||
break;
|
||||
case ResultWas::Warning:
|
||||
m_config.stream() << "warning:\n'" << resultInfo.getMessage() << "'";
|
||||
break;
|
||||
case ResultWas::ExplicitFailure:
|
||||
m_config.stream() << "failed with message: '" << resultInfo.getMessage() << "'";
|
||||
break;
|
||||
default:
|
||||
if( !resultInfo.hasExpression() )
|
||||
{
|
||||
if( resultInfo.ok() )
|
||||
m_config.stream() << " succeeded";
|
||||
else
|
||||
m_config.stream() << " failed";
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
if( resultInfo.hasExpression() )
|
||||
{
|
||||
m_config.stream() << " for: " << resultInfo.getExpandedExpression();
|
||||
}
|
||||
m_config.stream() << std::endl;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void EndTestCase
|
||||
(
|
||||
const TestCaseInfo& testInfo,
|
||||
std::size_t succeeded,
|
||||
std::size_t failed,
|
||||
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.getName() << " ";
|
||||
ReportCounts( succeeded, failed );
|
||||
m_config.stream() << "]" << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
private: // helpers
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
void StartSpansLazily()
|
||||
{
|
||||
if( !m_testingSpan.emitted )
|
||||
{
|
||||
if( m_config.getName().empty() )
|
||||
m_config.stream() << "[Started testing]" << std::endl;
|
||||
else
|
||||
m_config.stream() << "[Started testing: " << m_config.getName() << "]" << 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 << "]\n";
|
||||
}
|
||||
else
|
||||
{
|
||||
m_config.stream() << "\n[" << prefix << "] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n" << trimmed
|
||||
<< "\n[end of " << prefix << "] <<<<<<<<<<<<<<<<<<<<<<<<\n";
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
const IReporterConfig& m_config;
|
||||
bool m_firstSectionInTestCase;
|
||||
|
||||
SpanInfo m_testingSpan;
|
||||
SpanInfo m_groupSpan;
|
||||
SpanInfo m_testSpan;
|
||||
std::vector<SpanInfo> m_sectionSpans;
|
||||
};
|
||||
|
||||
INTERNAL_CATCH_REGISTER_REPORTER( "basic", BasicReporter )
|
||||
|
||||
} // end namespace Catch
|
||||
|
||||
#endif // TWOBLUECUBES_CATCH_REPORTER_BASIC_HPP_INCLUDED
|
||||
263
include/reporters/catch_reporter_junit.hpp
Normal file
263
include/reporters/catch_reporter_junit.hpp
Normal file
@@ -0,0 +1,263 @@
|
||||
/*
|
||||
* catch_reporter_junit.hpp
|
||||
* Catch
|
||||
*
|
||||
* Created by Phil on 26/11/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_JUNIT_HPP_INCLUDED
|
||||
#define TWOBLUECUBES_CATCH_REPORTER_JUNIT_HPP_INCLUDED
|
||||
|
||||
#include "internal/catch_capture.hpp"
|
||||
#include "internal/catch_interfaces_reporter.h"
|
||||
#include "internal/catch_reporter_registrars.hpp"
|
||||
#include "internal/catch_xmlwriter.hpp"
|
||||
|
||||
namespace Catch
|
||||
{
|
||||
class JunitReporter : public Catch::IReporter
|
||||
{
|
||||
struct TestStats
|
||||
{
|
||||
std::string m_element;
|
||||
std::string m_resultType;
|
||||
std::string m_message;
|
||||
std::string m_content;
|
||||
};
|
||||
|
||||
struct TestCaseStats
|
||||
{
|
||||
TestCaseStats( const std::string& name = std::string() )
|
||||
: m_name( name )
|
||||
{
|
||||
}
|
||||
|
||||
double m_timeInSeconds;
|
||||
std::string m_status;
|
||||
std::string m_className;
|
||||
std::string m_name;
|
||||
std::vector<TestStats> m_testStats;
|
||||
};
|
||||
|
||||
struct Stats
|
||||
{
|
||||
Stats( const std::string& name = std::string() )
|
||||
: m_testsCount( 0 ),
|
||||
m_failuresCount( 0 ),
|
||||
m_disabledCount( 0 ),
|
||||
m_errorsCount( 0 ),
|
||||
m_timeInSeconds( 0 ),
|
||||
m_name( name )
|
||||
{
|
||||
}
|
||||
|
||||
std::size_t m_testsCount;
|
||||
std::size_t m_failuresCount;
|
||||
std::size_t m_disabledCount;
|
||||
std::size_t m_errorsCount;
|
||||
double m_timeInSeconds;
|
||||
std::string m_name;
|
||||
|
||||
std::vector<TestCaseStats> m_testCaseStats;
|
||||
};
|
||||
|
||||
public:
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
JunitReporter( const IReporterConfig& config )
|
||||
: m_config( config ),
|
||||
m_testSuiteStats( "AllTests" ),
|
||||
m_currentStats( &m_testSuiteStats )
|
||||
{
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
static std::string getDescription()
|
||||
{
|
||||
return "Reports test results in an XML format that looks like Ant's junitreport target";
|
||||
}
|
||||
|
||||
private: // IReporter
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void StartTesting()
|
||||
{
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void StartGroup( const std::string& groupName )
|
||||
{
|
||||
|
||||
m_statsForSuites.push_back( Stats( groupName ) );
|
||||
m_currentStats = &m_statsForSuites.back();
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void EndGroup( const std::string&, std::size_t succeeded, std::size_t failed )
|
||||
{
|
||||
m_currentStats->m_testsCount = failed+succeeded;
|
||||
m_currentStats = &m_testSuiteStats;
|
||||
}
|
||||
|
||||
virtual void StartSection( const std::string& /*sectionName*/, const std::string /*description*/ )
|
||||
{
|
||||
}
|
||||
|
||||
virtual void EndSection( const std::string& /*sectionName*/, std::size_t /*succeeded*/, std::size_t /*failed*/ )
|
||||
{
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void StartTestCase( const Catch::TestCaseInfo& testInfo )
|
||||
{
|
||||
m_currentStats->m_testCaseStats.push_back( TestCaseStats( testInfo.getName() ) );
|
||||
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void Result( const Catch::ResultInfo& resultInfo )
|
||||
{
|
||||
if( resultInfo.getResultType() != ResultWas::Ok || m_config.includeSuccessfulResults() )
|
||||
{
|
||||
TestCaseStats& testCaseStats = m_currentStats->m_testCaseStats.back();
|
||||
TestStats stats;
|
||||
std::ostringstream oss;
|
||||
if( !resultInfo.getMessage().empty() )
|
||||
{
|
||||
oss << resultInfo.getMessage() << " at ";
|
||||
}
|
||||
oss << resultInfo.getFilename() << ":" << resultInfo.getLine();
|
||||
stats.m_content = oss.str();
|
||||
stats.m_message = resultInfo.getExpandedExpression();
|
||||
stats.m_resultType = resultInfo.getTestMacroName();
|
||||
switch( resultInfo.getResultType() )
|
||||
{
|
||||
case ResultWas::ThrewException:
|
||||
stats.m_element = "error";
|
||||
m_currentStats->m_errorsCount++;
|
||||
break;
|
||||
case ResultWas::Info:
|
||||
stats.m_element = "info"; // !TBD ?
|
||||
break;
|
||||
case ResultWas::Warning:
|
||||
stats.m_element = "warning"; // !TBD ?
|
||||
break;
|
||||
case ResultWas::ExplicitFailure:
|
||||
stats.m_element = "failure";
|
||||
m_currentStats->m_failuresCount++;
|
||||
break;
|
||||
case ResultWas::ExpressionFailed:
|
||||
stats.m_element = "failure";
|
||||
m_currentStats->m_failuresCount++;
|
||||
break;
|
||||
case ResultWas::Ok:
|
||||
stats.m_element = "success";
|
||||
break;
|
||||
default:
|
||||
stats.m_element = "unknown";
|
||||
break;
|
||||
}
|
||||
testCaseStats.m_testStats.push_back( stats );
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void EndTestCase( const Catch::TestCaseInfo&, std::size_t /* succeeded */, std::size_t /* failed */, const std::string& stdOut, const std::string& stdErr )
|
||||
{
|
||||
if( !stdOut.empty() )
|
||||
m_stdOut << stdOut << "\n";
|
||||
if( !stdErr.empty() )
|
||||
m_stdErr << stdErr << "\n";
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void EndTesting( std::size_t /* succeeded */, std::size_t /* failed */ )
|
||||
{
|
||||
std::ostream& str = m_config.stream();
|
||||
{
|
||||
XmlWriter xml( str );
|
||||
|
||||
if( m_statsForSuites.size() > 0 )
|
||||
xml.startElement( "testsuites" );
|
||||
|
||||
std::vector<Stats>::const_iterator it = m_statsForSuites.begin();
|
||||
std::vector<Stats>::const_iterator itEnd = m_statsForSuites.end();
|
||||
|
||||
for(; it != itEnd; ++it )
|
||||
{
|
||||
XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
|
||||
xml.writeAttribute( "name", it->m_name );
|
||||
xml.writeAttribute( "errors", it->m_errorsCount );
|
||||
xml.writeAttribute( "failures", it->m_failuresCount );
|
||||
xml.writeAttribute( "tests", it->m_testsCount );
|
||||
xml.writeAttribute( "hostname", "tbd" );
|
||||
xml.writeAttribute( "time", "tbd" );
|
||||
xml.writeAttribute( "timestamp", "tbd" );
|
||||
|
||||
OutputTestCases( xml, *it );
|
||||
}
|
||||
|
||||
xml.scopedElement( "system-out" ).writeText( trim( m_stdOut.str() ) );
|
||||
xml.scopedElement( "system-err" ).writeText( trim( m_stdOut.str() ) );
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
void OutputTestCases( XmlWriter& xml, const Stats& stats )
|
||||
{
|
||||
std::vector<TestCaseStats>::const_iterator it = stats.m_testCaseStats.begin();
|
||||
std::vector<TestCaseStats>::const_iterator itEnd = stats.m_testCaseStats.end();
|
||||
for(; it != itEnd; ++it )
|
||||
{
|
||||
xml.writeBlankLine();
|
||||
xml.writeComment( "Test case" );
|
||||
|
||||
XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
|
||||
xml.writeAttribute( "classname", it->m_className );
|
||||
xml.writeAttribute( "name", it->m_name );
|
||||
xml.writeAttribute( "time", "tbd" );
|
||||
|
||||
OutputTestResult( xml, *it );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
void OutputTestResult( XmlWriter& xml, const TestCaseStats& stats )
|
||||
{
|
||||
std::vector<TestStats>::const_iterator it = stats.m_testStats.begin();
|
||||
std::vector<TestStats>::const_iterator itEnd = stats.m_testStats.end();
|
||||
for(; it != itEnd; ++it )
|
||||
{
|
||||
if( it->m_element != "success" )
|
||||
{
|
||||
XmlWriter::ScopedElement e = xml.scopedElement( it->m_element );
|
||||
|
||||
xml.writeAttribute( "message", it->m_message );
|
||||
xml.writeAttribute( "type", it->m_resultType );
|
||||
if( !it->m_content.empty() )
|
||||
xml.writeText( it->m_content );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
const IReporterConfig& m_config;
|
||||
bool m_currentTestSuccess;
|
||||
|
||||
Stats m_testSuiteStats;
|
||||
Stats* m_currentStats;
|
||||
std::vector<Stats> m_statsForSuites;
|
||||
std::ostringstream m_stdOut;
|
||||
std::ostringstream m_stdErr;
|
||||
};
|
||||
|
||||
INTERNAL_CATCH_REGISTER_REPORTER( "junit", JunitReporter )
|
||||
|
||||
} // end namespace Catch
|
||||
|
||||
#endif // TWOBLUECUBES_CATCH_REPORTER_JUNIT_HPP_INCLUDED
|
||||
180
include/reporters/catch_reporter_xml.hpp
Normal file
180
include/reporters/catch_reporter_xml.hpp
Normal file
@@ -0,0 +1,180 @@
|
||||
/*
|
||||
* catch_reporter_xml.hpp
|
||||
* Catch
|
||||
*
|
||||
* 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_XML_HPP_INCLUDED
|
||||
#define TWOBLUECUBES_CATCH_REPORTER_XML_HPP_INCLUDED
|
||||
|
||||
#include "internal/catch_capture.hpp"
|
||||
#include "internal/catch_interfaces_reporter.h"
|
||||
#include "internal/catch_reporter_registrars.hpp"
|
||||
#include "internal/catch_xmlwriter.hpp"
|
||||
|
||||
namespace Catch
|
||||
{
|
||||
class XmlReporter : public Catch::IReporter
|
||||
{
|
||||
public:
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
XmlReporter
|
||||
(
|
||||
const IReporterConfig& config
|
||||
)
|
||||
: m_config( config )
|
||||
{
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
static std::string getDescription
|
||||
()
|
||||
{
|
||||
return "Reports test results as an XML document";
|
||||
}
|
||||
|
||||
private: // IReporter
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void StartTesting
|
||||
()
|
||||
{
|
||||
m_xml = XmlWriter( m_config.stream() );
|
||||
m_xml.startElement( "Catch" );
|
||||
if( !m_config.getName().empty() )
|
||||
m_xml.writeAttribute( "name", m_config.getName() );
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void EndTesting
|
||||
(
|
||||
std::size_t succeeded,
|
||||
std::size_t failed
|
||||
)
|
||||
{
|
||||
m_xml.scopedElement( "OverallResults" )
|
||||
.writeAttribute( "successes", succeeded )
|
||||
.writeAttribute( "failures", failed );
|
||||
m_xml.endElement();
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void StartGroup
|
||||
(
|
||||
const std::string& groupName
|
||||
)
|
||||
{
|
||||
m_xml.startElement( "Group" )
|
||||
.writeAttribute( "name", groupName );
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void EndGroup
|
||||
(
|
||||
const std::string& /*groupName*/,
|
||||
std::size_t succeeded,
|
||||
std::size_t failed
|
||||
)
|
||||
{
|
||||
m_xml.scopedElement( "OverallResults" )
|
||||
.writeAttribute( "successes", succeeded )
|
||||
.writeAttribute( "failures", failed );
|
||||
m_xml.endElement();
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void StartSection( const std::string& sectionName, const std::string description )
|
||||
{
|
||||
m_xml.startElement( "Section" )
|
||||
.writeAttribute( "name", sectionName )
|
||||
.writeAttribute( "description", description );
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void EndSection( const std::string& /*sectionName*/, std::size_t succeeded, std::size_t failed )
|
||||
{
|
||||
m_xml.scopedElement( "OverallResults" )
|
||||
.writeAttribute( "successes", succeeded )
|
||||
.writeAttribute( "failures", failed );
|
||||
m_xml.endElement();
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void StartTestCase( const Catch::TestCaseInfo& testInfo )
|
||||
{
|
||||
m_xml.startElement( "TestCase" ).writeAttribute( "name", testInfo.getName() );
|
||||
m_currentTestSuccess = true;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void Result( const Catch::ResultInfo& resultInfo )
|
||||
{
|
||||
if( !m_config.includeSuccessfulResults() && resultInfo.getResultType() == ResultWas::Ok )
|
||||
return;
|
||||
|
||||
if( resultInfo.hasExpression() )
|
||||
{
|
||||
m_xml.startElement( "Expression" )
|
||||
.writeAttribute( "success", resultInfo.ok() )
|
||||
.writeAttribute( "filename", resultInfo.getFilename() )
|
||||
.writeAttribute( "line", resultInfo.getLine() );
|
||||
|
||||
m_xml.scopedElement( "Original" )
|
||||
.writeText( resultInfo.getExpression() );
|
||||
m_xml.scopedElement( "Expanded" )
|
||||
.writeText( resultInfo.getExpandedExpression() );
|
||||
m_currentTestSuccess &= resultInfo.ok();
|
||||
}
|
||||
|
||||
switch( resultInfo.getResultType() )
|
||||
{
|
||||
case ResultWas::ThrewException:
|
||||
m_xml.scopedElement( "Exception" )
|
||||
.writeAttribute( "filename", resultInfo.getFilename() )
|
||||
.writeAttribute( "line", resultInfo.getLine() )
|
||||
.writeText( resultInfo.getMessage() );
|
||||
m_currentTestSuccess = false;
|
||||
break;
|
||||
case ResultWas::Info:
|
||||
m_xml.scopedElement( "Info" )
|
||||
.writeText( resultInfo.getMessage() );
|
||||
break;
|
||||
case ResultWas::Warning:
|
||||
m_xml.scopedElement( "Warning" )
|
||||
.writeText( resultInfo.getMessage() );
|
||||
break;
|
||||
case ResultWas::ExplicitFailure:
|
||||
m_xml.scopedElement( "Failure" )
|
||||
.writeText( resultInfo.getMessage() );
|
||||
m_currentTestSuccess = false;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if( resultInfo.hasExpression() )
|
||||
m_xml.endElement();
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
virtual void EndTestCase( const Catch::TestCaseInfo&, std::size_t /* succeeded */, std::size_t /* failed */, const std::string& /*stdOut*/, const std::string& /*stdErr*/ )
|
||||
{
|
||||
m_xml.scopedElement( "OverallResult" ).writeAttribute( "success", m_currentTestSuccess );
|
||||
m_xml.endElement();
|
||||
}
|
||||
|
||||
private:
|
||||
const IReporterConfig& m_config;
|
||||
bool m_currentTestSuccess;
|
||||
XmlWriter m_xml;
|
||||
};
|
||||
|
||||
INTERNAL_CATCH_REGISTER_REPORTER( "xml", XmlReporter )
|
||||
|
||||
} // end namespace Catch
|
||||
|
||||
#endif // TWOBLUECUBES_CATCH_REPORTER_XML_HPP_INCLUDED
|
||||
Reference in New Issue
Block a user