unittest-cpp · killoctal · Aug 29, 2016 · Aug 29, 2016 · Aug 29, 2016 · Aug 29, 2016
diff --git a/UnitTest++/ArgumentsReader.cpp b/UnitTest++/ArgumentsReader.cpp
@@ -0,0 +1,81 @@
+#include "ArgumentsReader.h"
+
+using namespace UnitTest;
+
+ArgumentsReader::ArgumentsReader(int argc, char**argv)
+{
+	_arguments.reserve(argc);
+	for (int i = 0; i < argc; i++)
+	{
+		_arguments.push_back(argv[i]);
+	}
+}
+
+
+ArgumentsReader::~ArgumentsReader()
+{
+}
+
+
+bool ArgumentsReader::findArgumentListIndex(const string & argumentName, size_t & outFrom, size_t & outCount) const
+{
+	if (_arguments.empty())
+	{
+		return false;
+	}
+	outCount = 0;
+	if (argumentName.empty())
+	{
+		outFrom = 1;
+	}
+	else
+	{
+		outFrom = 0;
+		for (size_t i = 1; i < _arguments.size(); i++)
+		{
+			if (argumentName == _arguments[i])
+			{
+				outFrom = i + 1;
+				break;
+			}
+		}
+		if (outFrom == 0)
+		{
+			return false;
+		}
+	}
+
+	for (size_t i = outFrom; i < _arguments.size(); i++)
+	{
+		const string & value = _arguments[i];
+		if (value.size() >= 2 && value.substr(0, 2) == "--")
+		{
+			break;
+		}
+		outCount++;
+	}
+
+	return true;
+}
+
+
+vector<string> ArgumentsReader::extractValues(const string & argumentName) const
+{
+	size_t from, count;
+	if (!findArgumentListIndex(argumentName, from, count))
+	{
+		return vector<string>();
+	}
+	vector<string> values;
+	for (size_t i = from; i < from + count; i++)
+	{
+		values.push_back(getArgument(i));
+	}
+	return values;
+}
+
+
+string ArgumentsReader::getArgument(size_t index) const
+{
+	return _arguments[index];
+}
diff --git a/UnitTest++/ArgumentsReader.h b/UnitTest++/ArgumentsReader.h
@@ -0,0 +1,21 @@
+#include <string>
+#include <vector>
+
+namespace UnitTest {
+
+	using namespace std;
+
+	class ArgumentsReader
+	{
+	public:
+		ArgumentsReader(int argc, char**argv);
+		virtual ~ArgumentsReader();
+
+		bool findArgumentListIndex(const string & argumentName, size_t & outFrom, size_t & outCount) const;
+		vector<string> extractValues(const string & argumentName) const;
+		string getArgument(size_t index) const;
+
+	private:
+		vector<string> _arguments;
+	};
+}
diff --git a/UnitTest++/PredicateCmdBuilder.cpp b/UnitTest++/PredicateCmdBuilder.cpp
@@ -0,0 +1,23 @@
+#include "PredicateCmdBuilder.h"
+
+using namespace UnitTest;
+
+
+void PredicateCmdBuilder::fillSuitePredicate(const ArgumentsReader & arguments, SuitePredicate & outPredicate, bool allowImplicitArgs)
+{
+	outPredicate.addSuites(arguments.extractValues("--suite"));
+	outPredicate.addTests(arguments.extractValues("--test"));
+
+	if (allowImplicitArgs)
+	{
+		vector<string> implicitArguments = arguments.extractValues("");
+		outPredicate.addSuites(implicitArguments);
+		outPredicate.addTests(implicitArguments);
+	}
+
+	if (outPredicate.empty())
+	{
+		outPredicate.addAll();
+	}
+}
+
diff --git a/UnitTest++/PredicateCmdBuilder.h b/UnitTest++/PredicateCmdBuilder.h
@@ -0,0 +1,16 @@
+#ifndef UNITTEST_PredicateCmdBuilder_H
+#define UNITTEST_TESTRUNNERCMD_H
+
+#include "ArgumentsReader.h"
+#include "SuitePredicate.h"
+
+namespace UnitTest {
+
+	class PredicateCmdBuilder
+	{
+	public:
+		static void fillSuitePredicate(const ArgumentsReader & arguments, SuitePredicate & outPredicate, bool allowImplicitArgs = true);
+	};
+}
+
+#endif
diff --git a/UnitTest++/SuitePredicate.cpp b/UnitTest++/SuitePredicate.cpp
@@ -0,0 +1,105 @@
+#include "SuitePredicate.h"
+
+using namespace std;
+using namespace UnitTest;
+
+
+SuitePredicate::SuitePredicate()
+	: _all(false)
+{
+}
+
+
+SuitePredicate::~SuitePredicate()
+{
+}
+
+
+void SuitePredicate::addSuite(const string & suiteName)
+{
+	_suiteNames.push_back(suiteName);
+}
+
+
+void SuitePredicate::addTest(const string & testName)
+{
+	_testNames.push_back(testName);
+}
+
+
+void SuitePredicate::addSuites(const vector<string> & suiteNames)
+{
+	for (size_t i = 0; i < suiteNames.size(); i++)
+	{
+		addSuite(suiteNames[i]);
+	}
+}
+
+
+void SuitePredicate::addTests(const vector<string> & testNames)
+{
+	for (size_t i = 0; i < testNames.size(); i++)
+	{
+		addTest(testNames[i]);
+	}
+}
+
+
+void SuitePredicate::addAll()
+{
+	_all = true;
+}
+
+
+bool SuitePredicate::empty()
+{
+	if (!_suiteNames.empty())
+	{
+		return false;
+	}
+	if (!_testNames.empty())
+	{
+		return false;
+	}
+	if (_all)
+	{
+		return false;
+	}
+	return true;
+}
+
+
+bool SuitePredicate::operator()(Test const * const test) const
+{
+	if (_all)
+	{
+		return true;
+	}
+	return (mustExecuteSuite(test) || mustExecuteTest(test));
+}
+
+
+bool SuitePredicate::mustExecuteSuite(Test const * const test) const
+{
+	for (size_t i = 0; i < _suiteNames.size(); i++)
+	{
+		if (_suiteNames[i] == test->m_details.suiteName)
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+bool SuitePredicate::mustExecuteTest(Test const * const test) const
+{
+	for (size_t i = 0; i < _testNames.size(); i++)
+	{
+		if (_testNames[i] == test->m_details.testName)
+		{
+			return true;
+		}
+	}
+	return false;
+}
diff --git a/UnitTest++/SuitePredicate.h b/UnitTest++/SuitePredicate.h
@@ -0,0 +1,40 @@
+#ifndef UNITTEST_SUITEPREDICATE_H
+#define UNITTEST_SUITEPREDICATE_H
+
+#include <string>
+#include <vector>
+#include "Test.h"
+
+namespace UnitTest
+{
+	using namespace std;
+
+	class UNITTEST_LINKAGE SuitePredicate
+	{
+	public:
+		SuitePredicate();
+		virtual ~SuitePredicate();
+
+		void addSuite(const string & suiteName);
+		void addTest(const string & testName);
+		void addSuites(const vector<string> & suiteNames);
+		void addTests(const vector<string> & testNames);
+		void addAll();
+		bool empty();
+
+		bool operator()(Test const * const test) const;
+
+		const vector<string> & getSuites() const { return _suiteNames; }
+		const vector<string> & getTests() const { return _testNames; }
+
+	private:
+		bool mustExecuteSuite(Test const * const test) const;
+		bool mustExecuteTest(Test const * const test) const;
+
+		vector<string> _suiteNames;
+		vector<string> _testNames;
+		bool _all;
+	};
+}
+
+#endif
diff --git a/UnitTest++/TestDetails.cpp b/UnitTest++/TestDetails.cpp
@@ -1,4 +1,5 @@
 #include "TestDetails.h"
+#include <cstring> // "c" version required for gcc
 
 namespace UnitTest {
 
@@ -18,5 +19,29 @@ namespace UnitTest {
       , timeConstraintExempt(details.timeConstraintExempt)
    {}
 
+   bool TestDetails::sameTest(const TestDetails & details) const
+   {
+      if (&details == this)
+      {
+         return true;
+      }
 
+      // Fast pointer comparison
+      if (details.suiteName == suiteName &&
+         details.testName == testName &&
+         details.filename == filename)
+      {
+         return true;
+      }
+
+      // Long string comparison
+      if (!strcmp(details.suiteName, suiteName) &&
+         !strcmp(details.testName, testName) &&
+         !strcmp(details.filename, filename))
+      {
+         return true;
+      }
+
+      return false;
+   }
 }
diff --git a/UnitTest++/TestDetails.h b/UnitTest++/TestDetails.h
@@ -17,6 +17,8 @@ namespace UnitTest {
       int const lineNumber;
       mutable bool timeConstraintExempt;
 
+      bool sameTest(const TestDetails & details) const;
+
       TestDetails(TestDetails const&); // Why is it public? --> http://gcc.gnu.org/bugs.html#cxx_rvalbind
    private:
       TestDetails& operator=(TestDetails const&);

diff --git a/UnitTest++/TestRunner.cpp b/UnitTest++/TestRunner.cpp
@@ -4,6 +4,7 @@
 #include "TestReporterStdout.h"
 #include "TimeHelpers.h"
 #include "MemoryOutStream.h"
+#include "PredicateCmdBuilder.h"
 
 #include <cstring>
 
@@ -17,6 +18,21 @@ namespace UnitTest {
       return runner.RunTestsIf(Test::GetTestList(), NULL, True(), 0);
    }
 
+   int RunTestsCmd(int argc, char**argv, bool allowImplicitArgs)
+   {
+      SuitePredicate predicate;
+      ArgumentsReader arguments(argc, argv);
+      PredicateCmdBuilder::fillSuitePredicate(arguments, predicate, allowImplicitArgs);
+
+      TestReporterStdout reporter;
+      TestRunner runner(reporter);
+      return runner.RunTestsIf(Test::GetTestList(), 0, predicate, 0);
+   }
+
+   int RunTestsCmd(int argc, char**argv)
+   {
+      return RunTestsCmd(argc, argv, true);
+   }
 
    TestRunner::TestRunner(TestReporter& reporter)
       : m_reporter(&reporter)

diff --git a/UnitTest++/TestRunner.h b/UnitTest++/TestRunner.h
@@ -11,6 +11,25 @@ namespace UnitTest {
    class TestResults;
    class Timer;
 
+   /**
+    * Run tests/suites using custom selection from command line.
+	*
+	* Commands:
+	*  --test One or multiple test names to execute, can be combined with --suite
+	*  --suite One or multiple suite names to execute, can be combined with --test
+	*
+	* Special feature: You do not have to specify explicitely --test and --suite, you
+	* can mix suite names and test names and the cmd will find the way. The
+	* constraint is that it must have no arguments beginning with --.
+	* For disabling this feature, set allowImplicitArgs=false
+	*
+	* Usage examples:
+	*  Explicit: myTests.exe --suite MySuite1 MyOtherSuite --test MySpecialTest MyOtherTest
+	*  Implicit: myTests.exe MySpecialTest MyOtherTest MySuite1
+	*/
+   UNITTEST_LINKAGE int RunTestsCmd(int argc, char**argv, bool allowImplicitArgs);
+   UNITTEST_LINKAGE int RunTestsCmd(int argc, char**argv); // Important: keep version with same signature as int main()
+
    UNITTEST_LINKAGE int RunAllTests();
 
    struct True