KSat/fsfw
15
4
Fork 0
forked from fsfw/fsfw
Code Issues Pull Requests 1 Releases Wiki Activity

test folder moved to separate test folder

Browse Source 
for fsfw for now
This commit is contained in:
Robin Müller 2020-04-19 12:06:28 +02:00
parent e77ca55b1d
commit 36715e3f4c
8 changed files with 0 additions and 18770 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
test/CatchExample.cpp
View File

@ -1,51 +0,0 @@
// Catch Example.
// Does not work yet. Problems with linker without main and config folder.
// propably because global object manager and some config files are not supplied
// but mandatory for full compilation of the framework.
// Let Catch provide main():
#if defined(UNIT_TEST)
#define CATCH_CONFIG_MAIN
#include <framework/test/catch2/catch.hpp>
#include <framework/test/UnitTestClass.h>
#include <framework/returnvalues/HasReturnvaluesIF.h>
int Factorial( int number ) {
return number <= 1 ? number : Factorial( number - 1 ) * number; // fail
// return number <= 1 ? 1 : Factorial( number - 1 ) * number; // pass
}
TEST_CASE( "Factorial of 0 is 1 (fail)", "[single-file]" ) {
REQUIRE( Factorial(0) == 1 );
}
TEST_CASE( "Factorials of 1 and higher are computed (pass)", "[single-file]" ) {
REQUIRE( Factorial(1) == 1 );
REQUIRE( Factorial(2) == 2 );
REQUIRE( Factorial(3) == 6 );
REQUIRE( Factorial(10) == 3628800 );
}
TEST_CASE( "Custom test", "[single-file]" ) {
UnitTestClass unitTestClass;
REQUIRE( unitTestClass.test_autoserialization() == HasReturnvaluesIF::RETURN_OK );
}
// Compile & run:
// - g++ -std=c++11 -Wall -I$(CATCH_SINGLE_INCLUDE) -o 010-TestCase 010-TestCase.cpp && ./010-TestCase --success
// - cl -EHsc -I%CATCH_SINGLE_INCLUDE% 010-TestCase.cpp && 010-TestCase --success
// Expected compact output (all assertions):
//
// prompt> 010-TestCase --reporter compact --success
// 010-TestCase.cpp:14: failed: Factorial(0) == 1 for: 0 == 1
// 010-TestCase.cpp:18: passed: Factorial(1) == 1 for: 1 == 1
// 010-TestCase.cpp:19: passed: Factorial(2) == 2 for: 2 == 2
// 010-TestCase.cpp:20: passed: Factorial(3) == 6 for: 6 == 6
// 010-TestCase.cpp:21: passed: Factorial(10) == 3628800 for: 3628800 (0x375f00) == 3628800 (0x375f00)
// Failed 1 test case, failed 1 assertion.
#endif

302
test/UnitTestClass.cpp
View File

@ -1,302 +0,0 @@
/**
* @file UnitTestClass.cpp
*
* @date 11.04.2020
* @author R. Mueller
*/
#include <framework/test/UnitTestClass.h>
#include <framework/serviceinterface/ServiceInterfaceStream.h>
#include <framework/serialize/SerializeElement.h>
#include <framework/serialize/SerialBufferAdapter.h>
#include <cstdlib>
#if defined(UNIT_TEST)
#include "catch.hpp"
#define CATCH_CONFIG_MAIN
TEST_CASE( "Serialization Size tests", "[single-file]") {
//REQUIRE(UnitTestClass::test_serialization == RETURN_OK );
}
#endif
UnitTestClass::UnitTestClass() {}
UnitTestClass::~UnitTestClass() {}
ReturnValue_t UnitTestClass::perform_tests() {
ReturnValue_t result = test_serialization();
if(result != RETURN_OK) {
return result;
}
return RETURN_OK;
}
ReturnValue_t UnitTestClass::test_serialization() {
// Here, we test all serialization tools. First test basic cases.
ReturnValue_t result = test_endianness_tools();
if(result != RETURN_OK) {
return result;
}
result = test_autoserialization();
if(result != RETURN_OK) {
return result;
}
result = test_serial_buffer_adapter();
if(result != RETURN_OK) {
return result;
}
return RETURN_OK;
}
ReturnValue_t UnitTestClass::test_endianness_tools() {
test_array[0] = 0;
test_array[1] = 0;
uint16_t two_byte_value = 1;
size_t size = 0;
uint8_t* p_array = test_array.data();
AutoSerializeAdapter::serialize(&two_byte_value, &p_array, &size, 2, false);
// Little endian: Value one on first byte
if(test_array[0] != 1 and test_array[1] != 0) {
return put_error(TestIds::ENDIANNESS_TOOLS);
}
p_array = test_array.data();
size = 0;
AutoSerializeAdapter::serialize(&two_byte_value, &p_array, &size, 2, true);
// Big endian: Value one on second byte
if(test_array[0] != 0 and test_array[1] != 1) {
return put_error(TestIds::ENDIANNESS_TOOLS);
}
// Endianness paameter will be changed later.
// p_array = test_array.data();
// ssize_t ssize = size;
// // Resulting parameter should be big endian
// AutoSerializeAdapter::deSerialize(&two_byte_value,
// const_cast<const uint8_t **>(&p_array), &ssize, true);
// if(two_byte_value != 1) {
// return put_error(TestIds::ENDIANNESS_TOOLS);
// }
//
// ssize = size;
// p_array = test_array.data();
// // Resulting parameter should be little endian
// AutoSerializeAdapter::deSerialize(&two_byte_value,
// const_cast<const uint8_t **>(&p_array), &ssize, false);
// if(two_byte_value != 256) {
// return put_error(TestIds::ENDIANNESS_TOOLS);
// }
return RETURN_OK;
}
ReturnValue_t UnitTestClass::test_autoserialization() {
current_id = TestIds::AUTO_SERIALIZATION_SIZE;
// Unit Test getSerializedSize
if(AutoSerializeAdapter::
getSerializedSize(&test_value_bool) != sizeof(test_value_bool) or
AutoSerializeAdapter::
getSerializedSize(&tv_uint8) != sizeof(tv_uint8) or
AutoSerializeAdapter::
getSerializedSize(&tv_uint16) != sizeof(tv_uint16) or
AutoSerializeAdapter::
getSerializedSize(&tv_uint32) != sizeof(tv_uint32) or
AutoSerializeAdapter::
getSerializedSize(&tv_uint64) != sizeof(tv_uint64) or
AutoSerializeAdapter::
getSerializedSize(&tv_int8) != sizeof(tv_int8) or
AutoSerializeAdapter::
getSerializedSize(&tv_double) != sizeof(tv_double) or
AutoSerializeAdapter::
getSerializedSize(&tv_int16) != sizeof(tv_int16) or
AutoSerializeAdapter::
getSerializedSize(&tv_int32) != sizeof(tv_int32) or
AutoSerializeAdapter::
getSerializedSize(&tv_float) != sizeof(tv_float))
{
return put_error(current_id);
}
// Unit Test AutoSerializeAdapter deserialize
current_id = TestIds::AUTO_SERIALIZATION_SERIALIZE;
size_t serialized_size = 0;
uint8_t * p_array = test_array.data();
AutoSerializeAdapter::serialize(&test_value_bool, &p_array,
&serialized_size, test_array.size(), false);
AutoSerializeAdapter::serialize(&tv_uint8, &p_array,
&serialized_size, test_array.size(), false);
AutoSerializeAdapter::serialize(&tv_uint16, &p_array,
&serialized_size, test_array.size(), false);
AutoSerializeAdapter::serialize(&tv_uint32, &p_array,
&serialized_size, test_array.size(), false);
AutoSerializeAdapter::serialize(&tv_int8, &p_array,
&serialized_size, test_array.size(), false);
AutoSerializeAdapter::serialize(&tv_int16, &p_array,
&serialized_size, test_array.size(), false);
AutoSerializeAdapter::serialize(&tv_int32, &p_array,
&serialized_size, test_array.size(), false);
AutoSerializeAdapter::serialize(&tv_uint64, &p_array,
&serialized_size, test_array.size(), false);
AutoSerializeAdapter::serialize(&tv_float, &p_array,
&serialized_size, test_array.size(), false);
AutoSerializeAdapter::serialize(&tv_double, &p_array,
&serialized_size, test_array.size(), false);
AutoSerializeAdapter::serialize(&tv_sfloat, &p_array,
&serialized_size, test_array.size(), false);
AutoSerializeAdapter::serialize(&tv_sdouble, &p_array,
&serialized_size, test_array.size(), false);
// expected size is 1 + 1 + 2 + 4 + 1 + 2 + 4 + 8 + 4 + 8 + 4 + 8
if(serialized_size != 47) {
return put_error(current_id);
}
// Unit Test AutoSerializeAdapter serialize
current_id = TestIds::AUTO_SERIALIZATION_DESERIALIZE;
p_array = test_array.data();
size_t remaining_size = serialized_size;
AutoSerializeAdapter::deSerialize(&test_value_bool,
const_cast<const uint8_t**>(&p_array), &remaining_size, false);
AutoSerializeAdapter::deSerialize(&tv_uint8,
const_cast<const uint8_t**>(&p_array), &remaining_size, false);
AutoSerializeAdapter::deSerialize(&tv_uint16,
const_cast<const uint8_t**>(&p_array), &remaining_size, false);
AutoSerializeAdapter::deSerialize(&tv_uint32,
const_cast<const uint8_t**>(&p_array), &remaining_size, false);
AutoSerializeAdapter::deSerialize(&tv_int8,
const_cast<const uint8_t**>(&p_array), &remaining_size, false);
AutoSerializeAdapter::deSerialize(&tv_int16,
const_cast<const uint8_t**>(&p_array), &remaining_size, false);
AutoSerializeAdapter::deSerialize(&tv_int32,
const_cast<const uint8_t**>(&p_array), &remaining_size, false);
AutoSerializeAdapter::deSerialize(&tv_uint64,
const_cast<const uint8_t**>(&p_array), &remaining_size, false);
AutoSerializeAdapter::deSerialize(&tv_float,
const_cast<const uint8_t**>(&p_array), &remaining_size, false);
AutoSerializeAdapter::deSerialize(&tv_double,
const_cast<const uint8_t**>(&p_array), &remaining_size, false);
AutoSerializeAdapter::deSerialize(&tv_sfloat,
const_cast<const uint8_t**>(&p_array), &remaining_size, false);
AutoSerializeAdapter::deSerialize(&tv_sdouble,
const_cast<const uint8_t**>(&p_array), &remaining_size, false);
if(test_value_bool != true or tv_uint8 != 5 or tv_uint16 != 283 or
tv_uint32 != 929221 or tv_uint64 != 2929329429 or tv_int8 != -16 or
tv_int16 != -829 or tv_int32 != -2312)
{
return put_error(current_id);
}
// These epsilon values were just guessed.. It appears to work though.
if(abs(tv_float - 8.214921) > 0.0001 or
abs(tv_double - 9.2132142141e8) > 0.01 or
abs(tv_sfloat - (-922.2321321)) > 0.0001 or
abs(tv_sdouble - (-2.2421e19)) > 0.01) {
return put_error(current_id);
}
// Check overflow
return RETURN_OK;
}
// TODO: Also test for constant buffers.
ReturnValue_t UnitTestClass::test_serial_buffer_adapter() {
current_id = TestIds::SERIALIZATION_BUFFER_ADAPTER;
// I will skip endian swapper testing, its going to be changed anyway..
// uint8_t tv_uint8_swapped = EndianSwapper::swap(tv_uint8);
size_t serialized_size = 0;
test_value_bool = true;
uint8_t * p_array = test_array.data();
std::array<uint8_t, 5> test_serial_buffer {5, 4, 3, 2, 1};
SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter =
SerialBufferAdapter<uint8_t>(test_serial_buffer.data(),
test_serial_buffer.size(), false);
tv_uint16 = 16;
AutoSerializeAdapter::serialize(&test_value_bool, &p_array,&serialized_size,
test_array.size(), false);
AutoSerializeAdapter::serialize(&tv_serial_buffer_adapter, &p_array,
&serialized_size, test_array.size(), false);
AutoSerializeAdapter::serialize(&tv_uint16, &p_array, &serialized_size,
test_array.size(), false);
if(serialized_size != 8 or test_array[0] != true or test_array[1] != 5
or test_array[2] != 4 or test_array[3] != 3 or test_array[4] != 2
or test_array[5] != 1)
{
return put_error(current_id);
}
memcpy(&tv_uint16, test_array.data() + 6, sizeof(tv_uint16));
if(tv_uint16 != 16) {
return put_error(current_id);
}
// Serialize with size field
SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter2 =
SerialBufferAdapter<uint8_t>(test_serial_buffer.data(),
test_serial_buffer.size(), true);
serialized_size = 0;
p_array = test_array.data();
AutoSerializeAdapter::serialize(&test_value_bool, &p_array,&serialized_size,
test_array.size(), false);
AutoSerializeAdapter::serialize(&tv_serial_buffer_adapter2, &p_array,
&serialized_size, test_array.size(), false);
AutoSerializeAdapter::serialize(&tv_uint16, &p_array, &serialized_size,
test_array.size(), false);
if(serialized_size != 9 or test_array[0] != true or test_array[1] != 5
or test_array[2] != 5 or test_array[3] != 4 or test_array[4] != 3
or test_array[5] != 2 or test_array[6] != 1)
{
return put_error(current_id);
}
memcpy(&tv_uint16, test_array.data() + 7, sizeof(tv_uint16));
if(tv_uint16 != 16) {
return put_error(current_id);
}
// Serialize with size field
SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter3 =
SerialBufferAdapter<uint8_t>(
const_cast<const uint8_t*>(test_serial_buffer.data()),
test_serial_buffer.size(), false);
serialized_size = 0;
p_array = test_array.data();
AutoSerializeAdapter::serialize(&test_value_bool, &p_array,&serialized_size,
test_array.size(), false);
AutoSerializeAdapter::serialize(&tv_serial_buffer_adapter3, &p_array,
&serialized_size, test_array.size(), false);
AutoSerializeAdapter::serialize(&tv_uint16, &p_array, &serialized_size,
test_array.size(), false);
if(serialized_size != 8 or test_array[0] != true or test_array[1] != 5
or test_array[2] != 4 or test_array[3] != 3 or test_array[4] != 2
or test_array[5] != 1)
{
return put_error(current_id);
}
memcpy(&tv_uint16, test_array.data() + 6, sizeof(tv_uint16));
if(tv_uint16 != 16) {
return put_error(current_id);
}
return RETURN_OK;
}
ReturnValue_t UnitTestClass::put_error(TestIds currentId) {
auto errorIter = testResultMap.find(currentId);
if(errorIter != testResultMap.end()) {
testResultMap.emplace(currentId, 1);
}
else {
errorIter->second ++;
}
error << "Unit Tester failed at test ID "
<< static_cast<uint32_t>(currentId) << "\r\n" << std::flush;
return RETURN_FAILED;
}

84
test/UnitTestClass.h
View File

@ -1,84 +0,0 @@
/**
* @file UnitTestClass.h
*
* @date 11.04.2020
* @author R. Mueller
*/
#ifndef FRAMEWORK_TEST_UNITTESTCLASS_H_
#define FRAMEWORK_TEST_UNITTESTCLASS_H_
#include <framework/returnvalues/HasReturnvaluesIF.h>
#include <map>
#include <vector>
/**
* We could start doing basic forms of Unit Testing (without a framework, first)
* for framework components. This could include:
*
* 1. TMTC Services
* 2. Serialization tools
* 3. Framework internal algorithms
*
* TODO: Maybe use specialized framework.
*/
class UnitTestClass: public HasReturnvaluesIF {
public:
UnitTestClass();
virtual~ UnitTestClass();
enum class TestIds {
ENDIANNESS_TOOLS,
AUTO_SERIALIZATION_SIZE,
AUTO_SERIALIZATION_SERIALIZE,
AUTO_SERIALIZATION_DESERIALIZE ,
SERIALIZATION_BUFFER_ADAPTER,
SERIALIZATION_FIXED_ARRAY_LIST_ADAPTER,
SERIALIZATION_COMBINATION,
TMTC_SERVICES ,
MISC
};
/**
* Some function which calls all other tests
* @return
*/
ReturnValue_t perform_tests();
ReturnValue_t test_serialization();
ReturnValue_t test_autoserialization();
ReturnValue_t test_serial_buffer_adapter();
ReturnValue_t test_endianness_tools();
private:
uint32_t errorCounter = 0;
TestIds current_id = TestIds::MISC;
std::array<uint8_t, 512> test_array;
using error_count_t = uint8_t;
using TestResultMap = std::map<TestIds, error_count_t>;
using TestBuffer = std::vector<uint8_t>;
TestResultMap testResultMap;
// POD test values
bool test_value_bool = true;
uint8_t tv_uint8 {5};
uint16_t tv_uint16 {283};
uint32_t tv_uint32 {929221};
uint64_t tv_uint64 {2929329429};
int8_t tv_int8 {-16};
int16_t tv_int16 {-829};
int32_t tv_int32 {-2312};
float tv_float {8.2149214};
float tv_sfloat = {-922.2321321};
double tv_double {9.2132142141e8};
double tv_sdouble {-2.2421e19};
ReturnValue_t put_error(TestIds currentId);
};
#endif /* FRAMEWORK_TEST_UNITTESTCLASS_H_ */

17618
test/catch2/catch.hpp
View File

File diff suppressed because it is too large Load Diff

62
test/catch2/catch_reporter_automake.hpp
View File

@ -1,62 +0,0 @@
/*
* Created by Justin R. Wilson on 2/19/2017.
* Copyright 2017 Justin R. Wilson. 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_AUTOMAKE_HPP_INCLUDED
#define TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
// Don't #include any Catch headers here - we can assume they are already
// included before this header.
// This is not good practice in general but is necessary in this case so this
// file can be distributed as a single header that works with the main
// Catch single header.
namespace Catch {
struct AutomakeReporter : StreamingReporterBase<AutomakeReporter> {
AutomakeReporter( ReporterConfig const& _config )
: StreamingReporterBase( _config )
{}
~AutomakeReporter() override;
static std::string getDescription() {
return "Reports test results in the format of Automake .trs files";
}
void assertionStarting( AssertionInfo const& ) override {}
bool assertionEnded( AssertionStats const& /*_assertionStats*/ ) override { return true; }
void testCaseEnded( TestCaseStats const& _testCaseStats ) override {
// Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
stream << ":test-result: ";
if (_testCaseStats.totals.assertions.allPassed()) {
stream << "PASS";
} else if (_testCaseStats.totals.assertions.allOk()) {
stream << "XFAIL";
} else {
stream << "FAIL";
}
stream << ' ' << _testCaseStats.testInfo.name << '\n';
StreamingReporterBase::testCaseEnded( _testCaseStats );
}
void skipTest( TestCaseInfo const& testInfo ) override {
stream << ":test-result: SKIP " << testInfo.name << '\n';
}
};
#ifdef CATCH_IMPL
AutomakeReporter::~AutomakeReporter() {}
#endif
CATCH_REGISTER_REPORTER( "automake", AutomakeReporter)
} // end namespace Catch
#endif // TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED

181
test/catch2/catch_reporter_sonarqube.hpp
View File

@ -1,181 +0,0 @@
/*
* Created by Daniel Garcia on 2018-12-04.
* Copyright Social Point SL. 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 CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
#define CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
// Don't #include any Catch headers here - we can assume they are already
// included before this header.
// This is not good practice in general but is necessary in this case so this
// file can be distributed as a single header that works with the main
// Catch single header.
#include <map>
namespace Catch {
struct SonarQubeReporter : CumulativeReporterBase<SonarQubeReporter> {
SonarQubeReporter(ReporterConfig const& config)
: CumulativeReporterBase(config)
, xml(config.stream()) {
m_reporterPrefs.shouldRedirectStdOut = true;
m_reporterPrefs.shouldReportAllAssertions = true;
}
~SonarQubeReporter() override;
static std::string getDescription() {
return "Reports test results in the Generic Test Data SonarQube XML format";
}
static std::set<Verbosity> getSupportedVerbosities() {
return { Verbosity::Normal };
}
void noMatchingTestCases(std::string const& /*spec*/) override {}
void testRunStarting(TestRunInfo const& testRunInfo) override {
CumulativeReporterBase::testRunStarting(testRunInfo);
xml.startElement("testExecutions");
xml.writeAttribute("version", "1");
}
void testGroupEnded(TestGroupStats const& testGroupStats) override {
CumulativeReporterBase::testGroupEnded(testGroupStats);
writeGroup(*m_testGroups.back());
}
void testRunEndedCumulative() override {
xml.endElement();
}
void writeGroup(TestGroupNode const& groupNode) {
std::map<std::string, TestGroupNode::ChildNodes> testsPerFile;
for(auto const& child : groupNode.children)
testsPerFile[child->value.testInfo.lineInfo.file].push_back(child);
for(auto const& kv : testsPerFile)
writeTestFile(kv.first.c_str(), kv.second);
}
void writeTestFile(const char* filename, TestGroupNode::ChildNodes const& testCaseNodes) {
XmlWriter::ScopedElement e = xml.scopedElement("file");
xml.writeAttribute("path", filename);
for(auto const& child : testCaseNodes)
writeTestCase(*child);
}
void writeTestCase(TestCaseNode const& testCaseNode) {
// All test cases have exactly one section - which represents the
// test case itself. That section may have 0-n nested sections
assert(testCaseNode.children.size() == 1);
SectionNode const& rootSection = *testCaseNode.children.front();
writeSection("", rootSection, testCaseNode.value.testInfo.okToFail());
}
void writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) {
std::string name = trim(sectionNode.stats.sectionInfo.name);
if(!rootName.empty())
name = rootName + '/' + name;
if(!sectionNode.assertions.empty() || !sectionNode.stdOut.empty() || !sectionNode.stdErr.empty()) {
XmlWriter::ScopedElement e = xml.scopedElement("testCase");
xml.writeAttribute("name", name);
xml.writeAttribute("duration", static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
writeAssertions(sectionNode, okToFail);
}
for(auto const& childNode : sectionNode.childSections)
writeSection(name, *childNode, okToFail);
}
void writeAssertions(SectionNode const& sectionNode, bool okToFail) {
for(auto const& assertion : sectionNode.assertions)
writeAssertion( assertion, okToFail);
}
void writeAssertion(AssertionStats const& stats, bool okToFail) {
AssertionResult const& result = stats.assertionResult;
if(!result.isOk()) {
std::string elementName;
if(okToFail) {
elementName = "skipped";
}
else {
switch(result.getResultType()) {
case ResultWas::ThrewException:
case ResultWas::FatalErrorCondition:
elementName = "error";
break;
case ResultWas::ExplicitFailure:
elementName = "failure";
break;
case ResultWas::ExpressionFailed:
elementName = "failure";
break;
case ResultWas::DidntThrowException:
elementName = "failure";
break;
// We should never see these here:
case ResultWas::Info:
case ResultWas::Warning:
case ResultWas::Ok:
case ResultWas::Unknown:
case ResultWas::FailureBit:
case ResultWas::Exception:
elementName = "internalError";
break;
}
}
XmlWriter::ScopedElement e = xml.scopedElement(elementName);
ReusableStringStream messageRss;
messageRss << result.getTestMacroName() << "(" << result.getExpression() << ")";
xml.writeAttribute("message", messageRss.str());
ReusableStringStream textRss;
if (stats.totals.assertions.total() > 0) {
textRss << "FAILED:\n";
if (result.hasExpression()) {
textRss << "\t" << result.getExpressionInMacro() << "\n";
}
if (result.hasExpandedExpression()) {
textRss << "with expansion:\n\t" << result.getExpandedExpression() << "\n";
}
}
if(!result.getMessage().empty())
textRss << result.getMessage() << "\n";
for(auto const& msg : stats.infoMessages)
if(msg.type == ResultWas::Info)
textRss << msg.message << "\n";
textRss << "at " << result.getSourceInfo();
xml.writeText(textRss.str(), XmlFormatting::Newline);
}
}
private:
XmlWriter xml;
};
#ifdef CATCH_IMPL
SonarQubeReporter::~SonarQubeReporter() {}
#endif
CATCH_REGISTER_REPORTER( "sonarqube", SonarQubeReporter )
} // end namespace Catch
#endif // CATCH_REPORTER_SONARQUBE_HPP_INCLUDED

253
test/catch2/catch_reporter_tap.hpp
View File

@ -1,253 +0,0 @@
/*
* Created by Colton Wolkins on 2015-08-15.
* Copyright 2015 Martin Moene. 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_TAP_HPP_INCLUDED
#define TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
// Don't #include any Catch headers here - we can assume they are already
// included before this header.
// This is not good practice in general but is necessary in this case so this
// file can be distributed as a single header that works with the main
// Catch single header.
#include <algorithm>
namespace Catch {
struct TAPReporter : StreamingReporterBase<TAPReporter> {
using StreamingReporterBase::StreamingReporterBase;
~TAPReporter() override;
static std::string getDescription() {
return "Reports test results in TAP format, suitable for test harnesses";
}
ReporterPreferences getPreferences() const override {
return m_reporterPrefs;
}
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 {
++counter;
stream << "# " << currentTestCaseInfo->name << std::endl;
AssertionPrinter printer( stream, _assertionStats, counter );
printer.print();
stream << std::endl;
return true;
}
void testRunEnded( TestRunStats const& _testRunStats ) override {
printTotals( _testRunStats.totals );
stream << "\n" << std::endl;
StreamingReporterBase::testRunEnded( _testRunStats );
}
private:
std::size_t counter = 0;
class AssertionPrinter {
public:
AssertionPrinter& operator= ( AssertionPrinter const& ) = delete;
AssertionPrinter( AssertionPrinter const& ) = delete;
AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter )
: stream( _stream )
, result( _stats.assertionResult )
, messages( _stats.infoMessages )
, itMessage( _stats.infoMessages.begin() )
, printInfoMessages( true )
, counter(_counter)
{}
void print() {
itMessage = messages.begin();
switch( result.getResultType() ) {
case ResultWas::Ok:
printResultType( passedString() );
printOriginalExpression();
printReconstructedExpression();
if ( ! result.hasExpression() )
printRemainingMessages( Colour::None );
else
printRemainingMessages();
break;
case ResultWas::ExpressionFailed:
if (result.isOk()) {
printResultType(passedString());
} else {
printResultType(failedString());
}
printOriginalExpression();
printReconstructedExpression();
if (result.isOk()) {
printIssue(" # TODO");
}
printRemainingMessages();
break;
case ResultWas::ThrewException:
printResultType( failedString() );
printIssue( "unexpected exception with message:" );
printMessage();
printExpressionWas();
printRemainingMessages();
break;
case ResultWas::FatalErrorCondition:
printResultType( failedString() );
printIssue( "fatal error condition with message:" );
printMessage();
printExpressionWas();
printRemainingMessages();
break;
case ResultWas::DidntThrowException:
printResultType( failedString() );
printIssue( "expected exception, got none" );
printExpressionWas();
printRemainingMessages();
break;
case ResultWas::Info:
printResultType( "info" );
printMessage();
printRemainingMessages();
break;
case ResultWas::Warning:
printResultType( "warning" );
printMessage();
printRemainingMessages();
break;
case ResultWas::ExplicitFailure:
printResultType( failedString() );
printIssue( "explicitly" );
printRemainingMessages( Colour::None );
break;
// These cases are here to prevent compiler warnings
case ResultWas::Unknown:
case ResultWas::FailureBit:
case ResultWas::Exception:
printResultType( "** internal error **" );
break;
}
}
private:
static Colour::Code dimColour() { return Colour::FileName; }
static const char* failedString() { return "not ok"; }
static const char* passedString() { return "ok"; }
void printSourceInfo() const {
Colour colourGuard( dimColour() );
stream << result.getSourceInfo() << ":";
}
void printResultType( std::string const& passOrFail ) const {
if( !passOrFail.empty() ) {
stream << passOrFail << ' ' << counter << " -";
}
}
void printIssue( std::string const& issue ) const {
stream << " " << issue;
}
void printExpressionWas() {
if( result.hasExpression() ) {
stream << ";";
{
Colour colour( dimColour() );
stream << " expression was:";
}
printOriginalExpression();
}
}
void printOriginalExpression() const {
if( result.hasExpression() ) {
stream << " " << result.getExpression();
}
}
void printReconstructedExpression() const {
if( result.hasExpandedExpression() ) {
{
Colour colour( dimColour() );
stream << " for: ";
}
std::string expr = result.getExpandedExpression();
std::replace( expr.begin(), expr.end(), '\n', ' ');
stream << expr;
}
}
void printMessage() {
if ( itMessage != messages.end() ) {
stream << " '" << itMessage->message << "'";
++itMessage;
}
}
void printRemainingMessages( Colour::Code colour = dimColour() ) {
if (itMessage == messages.end()) {
return;
}
// using messages.end() directly (or auto) yields compilation error:
std::vector<MessageInfo>::const_iterator itEnd = messages.end();
const std::size_t N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );
{
Colour colourGuard( colour );
stream << " with " << pluralise( N, "message" ) << ":";
}
for(; itMessage != itEnd; ) {
// If this assertion is a warning ignore any INFO messages
if( printInfoMessages || itMessage->type != ResultWas::Info ) {
stream << " '" << itMessage->message << "'";
if ( ++itMessage != itEnd ) {
Colour colourGuard( dimColour() );
stream << " and";
}
}
}
}
private:
std::ostream& stream;
AssertionResult const& result;
std::vector<MessageInfo> messages;
std::vector<MessageInfo>::const_iterator itMessage;
bool printInfoMessages;
std::size_t counter;
};
void printTotals( const Totals& totals ) const {
if( totals.testCases.total() == 0 ) {
stream << "1..0 # Skipped: No tests ran.";
} else {
stream << "1.." << counter;
}
}
};
#ifdef CATCH_IMPL
TAPReporter::~TAPReporter() {}
#endif
CATCH_REGISTER_REPORTER( "tap", TAPReporter )
} // end namespace Catch
#endif // TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED

219
test/catch2/catch_reporter_teamcity.hpp
View File

@ -1,219 +0,0 @@
/*
* Created by Phil Nash on 19th December 2014
* Copyright 2014 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_TEAMCITY_HPP_INCLUDED
#define TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
// Don't #include any Catch headers here - we can assume they are already
// included before this header.
// This is not good practice in general but is necessary in this case so this
// file can be distributed as a single header that works with the main
// Catch single header.
#include <cstring>
#ifdef __clang__
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wpadded"
#endif
namespace Catch {
struct TeamCityReporter : StreamingReporterBase<TeamCityReporter> {
TeamCityReporter( ReporterConfig const& _config )
: StreamingReporterBase( _config )
{
m_reporterPrefs.shouldRedirectStdOut = true;
}
static std::string escape( std::string const& str ) {
std::string escaped = str;
replaceInPlace( escaped, "|", "||" );
replaceInPlace( escaped, "'", "|'" );
replaceInPlace( escaped, "\n", "|n" );
replaceInPlace( escaped, "\r", "|r" );
replaceInPlace( escaped, "[", "|[" );
replaceInPlace( escaped, "]", "|]" );
return escaped;
}
~TeamCityReporter() override;
static std::string getDescription() {
return "Reports test results as TeamCity service messages";
}
void skipTest( TestCaseInfo const& /* testInfo */ ) override {
}
void noMatchingTestCases( std::string const& /* spec */ ) override {}
void testGroupStarting( GroupInfo const& groupInfo ) override {
StreamingReporterBase::testGroupStarting( groupInfo );
stream << "##teamcity[testSuiteStarted name='"
<< escape( groupInfo.name ) << "']\n";
}
void testGroupEnded( TestGroupStats const& testGroupStats ) override {
StreamingReporterBase::testGroupEnded( testGroupStats );
stream << "##teamcity[testSuiteFinished name='"
<< escape( testGroupStats.groupInfo.name ) << "']\n";
}
void assertionStarting( AssertionInfo const& ) override {}
bool assertionEnded( AssertionStats const& assertionStats ) override {
AssertionResult const& result = assertionStats.assertionResult;
if( !result.isOk() ) {
ReusableStringStream msg;
if( !m_headerPrintedForThisSection )
printSectionHeader( msg.get() );
m_headerPrintedForThisSection = true;
msg << result.getSourceInfo() << "\n";
switch( result.getResultType() ) {
case ResultWas::ExpressionFailed:
msg << "expression failed";
break;
case ResultWas::ThrewException:
msg << "unexpected exception";
break;
case ResultWas::FatalErrorCondition:
msg << "fatal error condition";
break;
case ResultWas::DidntThrowException:
msg << "no exception was thrown where one was expected";
break;
case ResultWas::ExplicitFailure:
msg << "explicit failure";
break;
// We shouldn't get here because of the isOk() test
case ResultWas::Ok:
case ResultWas::Info:
case ResultWas::Warning:
CATCH_ERROR( "Internal error in TeamCity reporter" );
// These cases are here to prevent compiler warnings
case ResultWas::Unknown:
case ResultWas::FailureBit:
case ResultWas::Exception:
CATCH_ERROR( "Not implemented" );
}
if( assertionStats.infoMessages.size() == 1 )
msg << " with message:";
if( assertionStats.infoMessages.size() > 1 )
msg << " with messages:";
for( auto const& messageInfo : assertionStats.infoMessages )
msg << "\n \"" << messageInfo.message << "\"";
if( result.hasExpression() ) {
msg <<
"\n " << result.getExpressionInMacro() << "\n"
"with expansion:\n" <<
" " << result.getExpandedExpression() << "\n";
}
if( currentTestCaseInfo->okToFail() ) {
msg << "- failure ignore as test marked as 'ok to fail'\n";
stream << "##teamcity[testIgnored"
<< " name='" << escape( currentTestCaseInfo->name )<< "'"
<< " message='" << escape( msg.str() ) << "'"
<< "]\n";
}
else {
stream << "##teamcity[testFailed"
<< " name='" << escape( currentTestCaseInfo->name )<< "'"
<< " message='" << escape( msg.str() ) << "'"
<< "]\n";
}
}
stream.flush();
return true;
}
void sectionStarting( SectionInfo const& sectionInfo ) override {
m_headerPrintedForThisSection = false;
StreamingReporterBase::sectionStarting( sectionInfo );
}
void testCaseStarting( TestCaseInfo const& testInfo ) override {
m_testTimer.start();
StreamingReporterBase::testCaseStarting( testInfo );
stream << "##teamcity[testStarted name='"
<< escape( testInfo.name ) << "']\n";
stream.flush();
}
void testCaseEnded( TestCaseStats const& testCaseStats ) override {
StreamingReporterBase::testCaseEnded( testCaseStats );
if( !testCaseStats.stdOut.empty() )
stream << "##teamcity[testStdOut name='"
<< escape( testCaseStats.testInfo.name )
<< "' out='" << escape( testCaseStats.stdOut ) << "']\n";
if( !testCaseStats.stdErr.empty() )
stream << "##teamcity[testStdErr name='"
<< escape( testCaseStats.testInfo.name )
<< "' out='" << escape( testCaseStats.stdErr ) << "']\n";
stream << "##teamcity[testFinished name='"
<< escape( testCaseStats.testInfo.name ) << "' duration='"
<< m_testTimer.getElapsedMilliseconds() << "']\n";
stream.flush();
}
private:
void printSectionHeader( std::ostream& os ) {
assert( !m_sectionStack.empty() );
if( m_sectionStack.size() > 1 ) {
os << getLineOfChars<'-'>() << "\n";
std::vector<SectionInfo>::const_iterator
it = m_sectionStack.begin()+1, // Skip first section (test case)
itEnd = m_sectionStack.end();
for( ; it != itEnd; ++it )
printHeaderString( os, it->name );
os << getLineOfChars<'-'>() << "\n";
}
SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
os << lineInfo << "\n";
os << getLineOfChars<'.'>() << "\n\n";
}
// if string has a : in first line will set indent to follow it on
// subsequent lines
static void printHeaderString( std::ostream& os, 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;
os << Column( _string )
.indent( indent+i)
.initialIndent( indent ) << "\n";
}
private:
bool m_headerPrintedForThisSection = false;
Timer m_testTimer;
};
#ifdef CATCH_IMPL
TeamCityReporter::~TeamCityReporter() {}
#endif
CATCH_REGISTER_REPORTER( "teamcity", TeamCityReporter )
} // end namespace Catch
#ifdef __clang__
# pragma clang diagnostic pop
#endif
#endif // TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED