move compare helpers to new auxiliary library

acompare2/makefile.conf

 EXECUTABLE:=acompare2
-LINK_PATHS=../alib2elgo/ ../alib2algo/ ../alib2data/ ../alib2common/ ../alib2std/
-LINK_LIBRARIES=alib2elgo alib2algo alib2data alib2common alib2std xml2
-INCLUDE_PATHS=\$$(SOURCES_BASE_DIR)/../../alib2elgo/src/ \$$(SOURCES_BASE_DIR)/../../alib2algo/src/ \$$(SOURCES_BASE_DIR)/../../alib2data/src/ \$$(SOURCES_BASE_DIR)/../../alib2common/src/ \$$(SOURCES_BASE_DIR)/../../alib2std/src/ /usr/include/libxml2/
+LINK_PATHS= ../alib2aux/ ../alib2str/ ../alib2data/ ../alib2common/ ../alib2std/
+LINK_LIBRARIES=alib2aux alib2str alib2data alib2common alib2std xml2
+INCLUDE_PATHS=\$$(SOURCES_BASE_DIR)/../../alib2aux/src/ \$$(SOURCES_BASE_DIR)/../../alib2str/src/ \$$(SOURCES_BASE_DIR)/../../alib2data/src/ \$$(SOURCES_BASE_DIR)/../../alib2common/src/ \$$(SOURCES_BASE_DIR)/../../alib2std/src/ /usr/include/libxml2/

acompare2/src/acompare.cpp

@@ -13,9 +13,9 @@
 #include "exception/CommonException.h"
 #include "factory/XmlDataFactory.hpp"
-#include "AutomatonCompare.h"
-#include "GrammarCompare.h"
-#include "StringCompare.h"
+#include <compare/AutomatonCompare.h>
+#include <compare/GrammarCompare.h>
+#include <compare/StringCompare.h>
 int main ( int argc, char * * argv ) {
 	try {
@@ -59,7 +59,7 @@ int main ( int argc, char * * argv ) {
 			measurements::end ( );
 			measurements::start ( "Compare", measurements::Type::MAIN );
-			res = AutomatonCompare::compare ( automaton1, automaton2 );
+			res = compare::AutomatonCompare::compare ( automaton1, automaton2 );
 		} else if ( alib::XmlDataFactory::first < grammar::Grammar > ( tokens1 ) && alib::XmlDataFactory::first < grammar::Grammar > ( tokens2 ) ) {
 			grammar::Grammar grammar1 = alib::XmlDataFactory::fromTokens ( std::move ( tokens1 ) );
 			grammar::Grammar grammar2 = alib::XmlDataFactory::fromTokens ( std::move ( tokens2 ) );
@@ -67,7 +67,7 @@ int main ( int argc, char * * argv ) {
 			measurements::end ( );
 			measurements::start ( "Compare", measurements::Type::MAIN );
-			res = GrammarCompare::compare ( grammar1, grammar2 );
+			res = compare::GrammarCompare::compare ( grammar1, grammar2 );
 		} else if ( alib::XmlDataFactory::first < string::String > ( tokens1 ) && alib::XmlDataFactory::first < string::String > ( tokens2 ) ) {
 			string::String string1 = alib::XmlDataFactory::fromTokens ( std::move ( tokens1 ) );
 			string::String string2 = alib::XmlDataFactory::fromTokens ( std::move ( tokens2 ) );
@@ -75,7 +75,7 @@ int main ( int argc, char * * argv ) {
 			measurements::end ( );
 			measurements::start ( "Compare", measurements::Type::MAIN );
-			res = StringCompare::compare ( string1, string2 );
+			res = compare::StringCompare::compare ( string1, string2 );
 		} else {
 			throw exception::CommonException ( "Only automata, grammars and strings can be compared." );
 		}

alib2aux/makefile

+-include makefile.conf
+-include ../build.conf
+-include ../makefile-library

alib2aux/makefile.conf

+LIBRARY:=alib2aux
+TESTBIN:=alib2test
+LINK_PATHS=../alib2data/ ../alib2common/ ../alib2std/
+LINK_LIBRARIES=alib2data alib2common alib2std xml2
+INCLUDE_PATHS=\$$(SOURCES_BASE_DIR)/../../alib2data/src/ \$$(SOURCES_BASE_DIR)/../../alib2common/src/ \$$(SOURCES_BASE_DIR)/../../alib2std/src/ /usr/include/libxml2/

acompare2/src/AutomatonCompare.cpp → alib2aux/src/compare/AutomatonCompare.cpp

@@ -8,6 +8,8 @@
 #include "AutomatonCompare.h"
 #include <registration/AlgoRegistration.hpp>
+namespace compare {
+
 auto AutomatonCompareDFA = registration::OverloadRegister < AutomatonCompare, int, automaton::DFA < >, automaton::DFA < > > ( AutomatonCompare::compare );
 auto AutomatonCompareNFA = registration::OverloadRegister < AutomatonCompare, int, automaton::NFA < > , automaton::NFA < > > ( AutomatonCompare::compare );
 auto AutomatonCompareMultiInitialStateNFA = registration::OverloadRegister < AutomatonCompare, int, automaton::MultiInitialStateNFA < >, automaton::MultiInitialStateNFA < > > ( AutomatonCompare::compare );
@@ -35,3 +37,4 @@ int AutomatonCompare::compare(const automaton::Automaton& a, const automaton::Au
 	return dispatch(a.getData(), b.getData());
 }
+} /* namespace compare */

acompare2/src/AutomatonCompare.h → alib2aux/src/compare/AutomatonCompare.h

@@ -41,6 +41,8 @@
 #include "automaton/PDA/SinglePopDPDA.h"
 #include "automaton/TM/OneTapeDTM.h"
+namespace compare {
+
 class AutomatonCompare : public alib::DoubleDispatch<AutomatonCompare, int, const automaton::AutomatonBase &, const automaton::AutomatonBase &> {
 private:
 	template<class SymbolType, class StateType>
@@ -1330,4 +1332,6 @@ int AutomatonCompare::compare(const T & a, const T & b) {
 	}
 }
+} /* namespace compare */
+
 #endif /* AUTOMATON_COMPARE_H_ */

acompare2/src/GrammarCompare.cpp → alib2aux/src/compare/GrammarCompare.cpp

@@ -31,6 +31,8 @@
 #include "grammar/Unrestricted/UnrestrictedGrammar.h"
 #include <registration/AlgoRegistration.hpp>
+namespace compare {
+
 bool GrammarCompare::testCompare(const grammar::LeftLG < > & a, const grammar::LeftLG < > & b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
@@ -581,3 +583,4 @@ int GrammarCompare::compare(const grammar::Grammar& a, const grammar::Grammar& b
 	return dispatch(a.getData(), b.getData());
 }
+} /* namespace compare */

acompare2/src/GrammarCompare.h → alib2aux/src/compare/GrammarCompare.h

@@ -18,6 +18,8 @@
 #include <map>
 #include <utility>
+namespace compare {
+
 class GrammarCompare : public alib::DoubleDispatch<GrammarCompare, int, const grammar::GrammarBase &, const grammar::GrammarBase &> {
 private:
 	static bool testCompare(const grammar::LeftLG < > & a, const grammar::LeftLG < > & b);
@@ -79,4 +81,6 @@ int GrammarCompare::compare(const T & a, const T & b) {
 	}
 }
+} /* namespace compare */
+
 #endif /* GRAMMAR_COMPARE_H_ */

acompare2/src/StringCompare.cpp → alib2aux/src/compare/StringCompare.cpp

@@ -11,6 +11,8 @@
 #include "string/LinearString.h"
 #include <registration/AlgoRegistration.hpp>
+namespace compare {
+
 bool StringCompare::testCompare ( const string::LinearString < > & a, const string::LinearString < > & b ) {
 	return a.getContent ( ) == b.getContent ( ) && a.getAlphabet ( ) == b.getAlphabet ( );
 }
@@ -79,3 +81,5 @@ auto StringCompareCyclic = registration::OverloadRegister < StringCompare, int,
 int StringCompare::compare ( const string::String & a, const string::String & b ) {
 	return dispatch ( a.getData ( ), b.getData ( ) );
 }
+
+} /* namespace compare */

acompare2/src/StringCompare.h → alib2aux/src/compare/StringCompare.h

@@ -17,6 +17,8 @@
 #include <utility>
 #include <vector>
+namespace compare {
+
 class StringCompare : public alib::DoubleDispatch < StringCompare, int, const string::StringBase &, const string::StringBase & > {
 private:
 	static bool testCompare ( const string::LinearString < > & a, const string::LinearString < > & b );
@@ -47,4 +49,6 @@ int StringCompare::compare ( const T & a, const T & b ) {
 	}
 }
+} /* namespace compare */
+
 #endif /* GRAMMAR_COMPARE_H_ */

alib2aux/test-src/main.cpp

+#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.", ' ', "0.01");
+
+		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;
+	}
+}

makefile

@@ -23,6 +23,7 @@ SUBDIRS_LIBS = alib2std \
 		alib2common \
 		alib2data \
 		alib2data_experimental \
+		alib2aux \
 		alib2str \
 		alib2str_experimental \
 		alib2raw \