Skip to content
Snippets Groups Projects
Commit 77c6ab53 authored by Tomáš Pecka's avatar Tomáš Pecka
Browse files

Unit tests: CPPUNIT -> Catch2: measure

parent 009380cb
No related branches found
No related tags found
1 merge request!62Dev tp
Hide whitespace changes
Inline Side-by-side
alib2measure/test-src/main.cpp
+ 2
− 166
View file @ 77c6ab53
#include <version.hpp>
#include <tclap/CmdLine.h>
#include <cppunit/CompilerOutputter.h>
#include <cppunit/extensions/TestFactoryRegistry.h>
#include <cppunit/ui/text/TestRunner.h>
#include <cppunit/TestResultCollector.h>
#include <cppunit/TestResult.h>
#include <cppunit/XmlOutputter.h>
#include <cppunit/Test.h>
#include <cppunit/TestFailure.h>
#include <cppunit/portability/Stream.h>
#include <cppunit/TestListener.h>
#include <cppunit/SourceLine.h>
#include <cppunit/Exception.h>
//#include <exception/CommonException.h>
CPPUNIT_NS_BEGIN
class CPPUNIT_API TestProgressListener : public TestListener
{
public:
TestProgressListener();
virtual ~TestProgressListener();
void startTest( Test *test );
void addFailure( const TestFailure &failure );
void endTest( Test *test );
int getResult() const;
void printResults() const;
private:
TestProgressListener( const TestProgressListener &copy );
void operator =( const TestProgressListener &copy );
private:
int m_Failures;
int m_Tests;
int m_Assertions;
bool m_lastTestFailed;
};
TestProgressListener::TestProgressListener() : m_Failures( 0 ), m_Tests(0), m_Assertions(0), m_lastTestFailed( false )
{
}
TestProgressListener::~TestProgressListener()
{
}
void TestProgressListener::startTest( Test * test )
{
stdCOut() << test->getName() << ":" << "\n";
stdCOut().flush();
m_lastTestFailed = false;
m_Tests++;
}
void TestProgressListener::addFailure( const TestFailure &failure )
{
stdCOut() << (failure.isError() ? "error" : "assertion") << " : " << failure.failedTestName() << " : " << failure.sourceLine().lineNumber() << "\n";
stdCOut() << "Exception " << failure.thrownException()->message().details();
m_lastTestFailed = true;
if(failure.isError()) m_Failures++; else m_Assertions++;
}
void TestProgressListener::endTest( Test * test)
{
stdCOut() << "Result (" << test->getName() << ")";
stdCOut().flush();
if ( !m_lastTestFailed )
stdCOut() << " : OK";
else
stdCOut() << " : Fail";
stdCOut() << "\n\n";
}
int TestProgressListener::getResult() const {
return m_Failures + m_Assertions;
}
void TestProgressListener::printResults() const {
stdCOut() << "Overal result: Tests: " << m_Tests << " Assertions: " << m_Assertions << " Failures: " << m_Failures << "\n";
}
CPPUNIT_NS_END
int main(int argc, char* argv[]) {
try {
TCLAP::CmdLine cmd("Main test binary.", ' ', ALIB_VERSION_INFO);
TCLAP::MultiArg<std::string> testPathSegments("p", "path", "test path", false, "string" );
cmd.add( testPathSegments );
cmd.parse(argc, argv);
CppUnit::TestResult controller;
CppUnit::TestResultCollector result;
controller.addListener( &result );
CppUnit::TestProgressListener progressListener;
controller.addListener( &progressListener );
CppUnit::Test *suite = NULL;
std::string testPath = "";
if(testPathSegments.getValue().size() == 0) {
// Get the top level suite from the registry
suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
} else if(testPathSegments.getValue().size() == 1) {
suite = CppUnit::TestFactoryRegistry::getRegistry(testPathSegments.getValue()[0]).makeTest();
} else {
suite = CppUnit::TestFactoryRegistry::getRegistry(testPathSegments.getValue()[0]).makeTest();
bool first = true;
for(const std::string& path : testPathSegments.getValue()) {
if(first) {
first = false;
continue;
}
testPath += path + "/";
}
testPath.pop_back();
}
// Adds the test to the list of test to run
CppUnit::TextUi::TestRunner runner;
runner.addTest( suite );
// Change the default outputter to a compiler error format outputter
runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(), std::cerr ) );
// Run the tests.
runner.run( controller, testPath );
progressListener.printResults();
std::ofstream xmlFileResults("CppUnitTestResults.xml");
CppUnit::XmlOutputter xmlOut(&result, xmlFileResults);
xmlOut.write();
return progressListener.getResult();
/* } catch(const exception::CommonException& exception) {
std::cerr << exception.getCause() << std::endl;
return 1;*/
} catch(const TCLAP::ArgException& exception) {
std::cerr << exception.error() << std::endl;
return 2;
} catch (const std::exception& exception) {
std::cerr << "Exception caught: " << exception.what() << std::endl;
return 3;
} catch(...) {
std::cerr << "Unknown exception caught." << std::endl;
return 127;
}
}
#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>
alib2measure/test-src/measurements/MeasurementsTest.cpp
+ 151
− 154
View file @ 77c6ab53
#include "MeasurementsTest.h"
#include <catch2/catch.hpp>
#include <sstream>
#include <thread>
#include <cmath>
#include <iostream>
#include <alib/measure>
 
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION ( MeasurementsTest, "measurements" );
CPPUNIT_TEST_SUITE_REGISTRATION ( MeasurementsTest );
void MeasurementsTest::setUp ( ) {
TEST_CASE ( "Measurements", "[unit][measure][measurements]" ) {
measurements::reset ( );
}
 
void MeasurementsTest::tearDown ( ) {
}
SECTION ( "Construct Measurements" ) {
}
 
void MeasurementsTest::testConstructMeasurements ( ) {
}
SECTION ( "Time Measurements" ) {
measurements::start ( "global", measurements::Type::OVERALL );
measurements::start ( "init", measurements::Type::INIT );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 100 ) );
measurements::end ( );
measurements::start ( "main", measurements::Type::MAIN );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 20 ) );
measurements::start ( "aux", measurements::Type::AUXILIARY );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 40 ) );
measurements::end ( );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 80 ) );
measurements::start ( "aux", measurements::Type::AUXILIARY );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 40 ) );
measurements::end ( );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 80 ) );
measurements::end ( );
measurements::start ( "fin", measurements::Type::FINALIZE );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 30 ) );
measurements::start ( "aux", measurements::Type::AUXILIARY );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 40 ) );
measurements::end ( );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 80 ) );
measurements::end ( );
measurements::end ( );
measurements::start ( "global2", measurements::Type::OVERALL );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 100 ) );
measurements::end ( );
measurements::start ( "global3", measurements::Type::OVERALL );
measurements::start ( "init", measurements::Type::INIT );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 100 ) );
measurements::end ( );
measurements::start ( "main", measurements::Type::MAIN );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 20 ) );
measurements::start ( "aux", measurements::Type::AUXILIARY );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 40 ) );
measurements::end ( );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 80 ) );
measurements::start ( "aux", measurements::Type::AUXILIARY );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 40 ) );
measurements::end ( );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 80 ) );
measurements::end ( );
measurements::end ( );
//root, global1, init, main, aux, aux, fin,aux,...,global2,...,global3, init, main, aux, aux
int expectedResults [ ] = {0, 510000, 100000, 260000, 40000, 40000, 150000, 40000, 100000, 360000, 100000, 260000, 40000, 40000 };
const int DEVIATION = 25000;
auto results = measurements::results ( );
int i = 0;
for(const measurements::MeasurementFrame & frame : results.frames) {
CHECK ( std::abs ( expectedResults[i] - frame.time.duration.count ( ) ) <= DEVIATION );
i++;
}
 
void MeasurementsTest::testTimeMeasurements ( ) {
measurements::start ( "global", measurements::Type::OVERALL );
measurements::start ( "init", measurements::Type::INIT );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 100 ) );
measurements::end ( );
measurements::start ( "main", measurements::Type::MAIN );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 20 ) );
measurements::start ( "aux", measurements::Type::AUXILIARY );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 40 ) );
measurements::end ( );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 80 ) );
measurements::start ( "aux", measurements::Type::AUXILIARY );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 40 ) );
measurements::end ( );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 80 ) );
measurements::end ( );
measurements::start ( "fin", measurements::Type::FINALIZE );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 30 ) );
measurements::start ( "aux", measurements::Type::AUXILIARY );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 40 ) );
measurements::end ( );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 80 ) );
measurements::end ( );
measurements::end ( );
measurements::start ( "global2", measurements::Type::OVERALL );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 100 ) );
measurements::end ( );
measurements::start ( "global3", measurements::Type::OVERALL );
measurements::start ( "init", measurements::Type::INIT );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 100 ) );
measurements::end ( );
measurements::start ( "main", measurements::Type::MAIN );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 20 ) );
measurements::start ( "aux", measurements::Type::AUXILIARY );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 40 ) );
measurements::end ( );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 80 ) );
measurements::start ( "aux", measurements::Type::AUXILIARY );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 40 ) );
measurements::end ( );
std::this_thread::sleep_for ( std::chrono::milliseconds ( 80 ) );
measurements::end ( );
measurements::end ( );
//root, global1, init, main, aux, aux, fin,aux,...,global2,...,global3, init, main, aux, aux
int expectedResults [ ] = {0, 510000, 100000, 260000, 40000, 40000, 150000, 40000, 100000, 360000, 100000, 260000, 40000, 40000 };
const int DEVIATION = 25000;
auto results = measurements::results ( );
int i = 0;
for(const measurements::MeasurementFrame & frame : results.frames) {
CPPUNIT_ASSERT ( std::abs ( expectedResults[i] - frame.time.duration.count ( ) ) <= DEVIATION );
i++;
// std::cout << measurements::MeasurementFormat::LIST << measurements::results ( ) << std::endl;
// std::cout << measurements::MeasurementFormat::TREE << measurements::results ( ) << std::endl;
}
 
std::cout << measurements::MeasurementFormat::LIST << measurements::results ( ) << std::endl;
std::cout << measurements::MeasurementFormat::TREE << measurements::results ( ) << std::endl;
}
#ifdef __clang__
#define __NO_OPTIMIZE_ATTRIBUTE__ __attribute__((optnone))
#else
#define __NO_OPTIMIZE_ATTRIBUTE__ __attribute__((optimize("O0")))
#endif
 
void __NO_OPTIMIZE_ATTRIBUTE__ MeasurementsTest::testMemoryMeasurements ( ) {
measurements::start ( "chunk1", measurements::Type::MAIN );
int * baz = new int[500];
measurements::end ( );
delete[] baz;
int * foo = new int[1000];
measurements::start ( "chunk2", measurements::Type::MAIN );
measurements::start ( "chunk21", measurements::Type::MAIN );
int * bar = new int[2000];
measurements::end ( );
delete[] foo;
delete[] bar;
measurements::end ( );
measurements::start ( "chunk3", measurements::Type::MAIN );
measurements::start ( "chunk31", measurements::Type::MAIN );
bar = new int[1000];
delete[] bar;
measurements::end ( );
measurements::end ( );
auto results = measurements::results ( );
std::cout << measurements::MeasurementFormat::LIST << measurements::results ( ) << std::endl;
std::cout << measurements::MeasurementFormat::TREE << measurements::results ( ) << std::endl;
//void __NO_OPTIMIZE_ATTRIBUTE__ MeasurementsTest::testMemoryMeasurements ( ) {
SECTION ( "Memory Measurements" ) {
measurements::start ( "chunk1", measurements::Type::MAIN );
int * baz = new int[500];
measurements::end ( );
delete[] baz;
int * foo = new int[1000];
measurements::start ( "chunk2", measurements::Type::MAIN );
measurements::start ( "chunk21", measurements::Type::MAIN );
int * bar = new int[2000];
measurements::end ( );
delete[] foo;
delete[] bar;
measurements::end ( );
measurements::start ( "chunk3", measurements::Type::MAIN );
measurements::start ( "chunk31", measurements::Type::MAIN );
bar = new int[1000];
delete[] bar;
measurements::end ( );
measurements::end ( );
auto results = measurements::results ( );
//std::cout << measurements::MeasurementFormat::LIST << measurements::results ( ) << std::endl;
//std::cout << measurements::MeasurementFormat::TREE << measurements::results ( ) << std::endl;
 
#if 0
int expectedResultsHW [ ] = { 12000, 2000, 12000 , 12000, 4000, 4000 };
int expectedResultsSHU [ ] = { 0, 0 , 4000 , 4000 , 0 , 0 };
int expectedResultsEHU [ ] = { 0, 2000, 0 , 12000, 0 , 0 };
int i = 0;
for(const measurements::MeasurementFrame & frame : results.frames) {
CPPUNIT_ASSERT ( expectedResultsHW[i] == frame.memory.highWatermark );
CPPUNIT_ASSERT ( expectedResultsSHU[i] == frame.memory.startHeapUsage );
CPPUNIT_ASSERT ( expectedResultsEHU[i] == frame.memory.endHeapUsage );
i++;
}
int expectedResultsHW [ ] = { 12000, 2000, 12000 , 12000, 4000, 4000 };
int expectedResultsSHU [ ] = { 0, 0 , 4000 , 4000 , 0 , 0 };
int expectedResultsEHU [ ] = { 0, 2000, 0 , 12000, 0 , 0 };
int i = 0;
for(const measurements::MeasurementFrame & frame : results.frames) {
CHECK ( expectedResultsHW[i] == frame.memory.highWatermark );
CHECK ( expectedResultsSHU[i] == frame.memory.startHeapUsage );
CHECK ( expectedResultsEHU[i] == frame.memory.endHeapUsage );
i++;
}
#endif
}
}
 
void MeasurementsTest::testCounterMeasurements ( ) {
measurements::start ( "chunk1", measurements::Type::MAIN );
measurements::counterInc ( "test1", 5 );
measurements::counterInc ( "test2" );
measurements::start ( "chunk11", measurements::Type::MAIN );
measurements::counterDec ( "test3" );
measurements::start ( "chunk111", measurements::Type::MAIN );
measurements::counterDec ( "test1" );
measurements::counterDec ( "test2", 10 );
measurements::counterDec ( "test3" );
measurements::counterDec ( "test4" );
measurements::end ( );
measurements::start ( "chunk112", measurements::Type::MAIN );
measurements::counterDec ( "test1" );
measurements::counterDec ( "test2", 10 );
measurements::counterDec ( "test3" );
measurements::counterDec ( "test4" );
measurements::end ( );
measurements::end ( );
measurements::end ( );
std::map < std::string, int > expectedResults [ ] = {
{ } ,
{ { "test1", 3 } , { "test2", -19 } , { "test3", -3 } , { "test4", -2 } } ,
{ { "test1", 3 } , { "test2", -19 } , { "test3", -3 } , { "test4", -2 } } ,
{ { "test1", 4 } , { "test2", -9 } , { "test3", -2 } , { "test4", -1 } } ,
{ { "test1", 3 } , { "test2", -19 } , { "test3", -3 } , { "test4", -2 } } ,
};
auto results = measurements::results ( );
int i = 0;
for(const measurements::MeasurementFrame & frame : results.frames) {
auto erit = expectedResults[i].begin ( );
auto it = frame.counter.counters.begin ( );
while ( erit != expectedResults[i].end ( ) ) {
CPPUNIT_ASSERT ( erit->first == measurements::to_string ( it->first ) );
CPPUNIT_ASSERT ( erit->second == it->second );
++erit;
++it;
SECTION ( "Counter" ) {
measurements::start ( "chunk1", measurements::Type::MAIN );
measurements::counterInc ( "test1", 5 );
measurements::counterInc ( "test2" );
measurements::start ( "chunk11", measurements::Type::MAIN );
measurements::counterDec ( "test3" );
measurements::start ( "chunk111", measurements::Type::MAIN );
measurements::counterDec ( "test1" );
measurements::counterDec ( "test2", 10 );
measurements::counterDec ( "test3" );
measurements::counterDec ( "test4" );
measurements::end ( );
measurements::start ( "chunk112", measurements::Type::MAIN );
measurements::counterDec ( "test1" );
measurements::counterDec ( "test2", 10 );
measurements::counterDec ( "test3" );
measurements::counterDec ( "test4" );
measurements::end ( );
measurements::end ( );
measurements::end ( );
std::map < std::string, int > expectedResults [ ] = {
{ } ,
{ { "test1", 3 } , { "test2", -19 } , { "test3", -3 } , { "test4", -2 } } ,
{ { "test1", 3 } , { "test2", -19 } , { "test3", -3 } , { "test4", -2 } } ,
{ { "test1", 4 } , { "test2", -9 } , { "test3", -2 } , { "test4", -1 } } ,
{ { "test1", 3 } , { "test2", -19 } , { "test3", -3 } , { "test4", -2 } } ,
};
auto results = measurements::results ( );
int i = 0;
for(const measurements::MeasurementFrame & frame : results.frames) {
auto erit = expectedResults[i].begin ( );
auto it = frame.counter.counters.begin ( );
while ( erit != expectedResults[i].end ( ) ) {
REQUIRE ( erit->first == measurements::to_string ( it->first ) );
CHECK ( erit->second == it->second );
++erit;
++it;
}
i++;
}
 
i++;
// std::cout << measurements::MeasurementFormat::LIST << measurements::results ( ) << std::endl;
// std::cout << measurements::MeasurementFormat::TREE << measurements::results ( ) << std::endl;
}
std::cout << measurements::MeasurementFormat::LIST << measurements::results ( ) << std::endl;
std::cout << measurements::MeasurementFormat::TREE << measurements::results ( ) << std::endl;
}
alib2measure/test-src/measurements/MeasurementsTest.h deleted 100644 → 0
+ 0
− 24
View file @ 009380cb
#ifndef MEASUREMENTS_TEST_H_
#define MEASUREMENTS_TEST_H_
#include <cppunit/extensions/HelperMacros.h>
class MeasurementsTest : public CppUnit::TestFixture {
CPPUNIT_TEST_SUITE ( MeasurementsTest );
CPPUNIT_TEST ( testConstructMeasurements );
CPPUNIT_TEST ( testTimeMeasurements );
CPPUNIT_TEST ( testMemoryMeasurements );
CPPUNIT_TEST ( testCounterMeasurements );
CPPUNIT_TEST_SUITE_END ( );
public:
void setUp ( );
void tearDown ( );
void testConstructMeasurements ( );
void testTimeMeasurements ( );
void testMemoryMeasurements ( );
void testCounterMeasurements ( );
};
#endif // MEASUREMENTS_TEST_H_
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment