From d083237022489c21ea4f13f45da51bd9a479549f Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 11 May 2016 10:33:41 +0200 Subject: [PATCH 001/131] Imported files from other project --- UnitTest++/ParameterizedSuite.h | 233 +++++++++++++++++++++++++++++++ tests/TestParameterizedSuite.cpp | 93 ++++++++++++ 2 files changed, 326 insertions(+) create mode 100644 UnitTest++/ParameterizedSuite.h create mode 100644 tests/TestParameterizedSuite.cpp diff --git a/UnitTest++/ParameterizedSuite.h b/UnitTest++/ParameterizedSuite.h new file mode 100644 index 0000000..70d0708 --- /dev/null +++ b/UnitTest++/ParameterizedSuite.h @@ -0,0 +1,233 @@ +#ifndef UNITTEST_PARAMETERIZEDSUITE_H +#define UNITTEST_PARAMETERIZEDSUITE_H + +#include +#include +#include +#include + +#include "Test.h" + +namespace UnitTest +{ + using namespace std; + + class ParameterizedSuiteAbstract + { + public: + + ParameterizedSuiteAbstract(const string & suiteName) + : _suiteName(suiteName), + _testName(suiteName + "ParameterizedSuite_starter") + { + // WARNING: this is pointer because of memory problems with suiteName/testName.c_str(), + // the constructor does not initialize them in the right order + _testAnchor = make_unique(*this); + } + + size_t getIteration() + { + return _iteration; + } + + protected: + + virtual void peekCurrentValue() = 0; + virtual size_t valuesSize() = 0; + + void ensureInitialized() + { + tryPeekFirstValue(); + tryBranchUniqueTest(); + } + + bool hasMoreValues(int advance = 0) + { + return (_iteration + advance < (int)valuesSize()); + } + + private: + + class TestAnchor : public Test + { + public: + TestAnchor(ParameterizedSuiteAbstract & parameterized) + : Test(parameterized._testName.c_str(), parameterized._suiteName.c_str()), + _parameterized(parameterized) + { + Test::GetTestList().Add(this); + } + virtual void RunImpl() const override + { + _parameterized.onNewIteration(); + } + private: + ParameterizedSuiteAbstract & _parameterized; + }; + + bool tryPeekFirstValue() + { + if (_iterationBranched) + { + return false; + } + + peekCurrentValue(); + return false; + } + + bool tryBranchUniqueTest() + { + if (_iterationBranched) + { + return false; + } + + //TODO find a way to allow single parameterized test execution + static bool messageDisplayed = false; + if (!messageDisplayed) + { + messageDisplayed = true; + cout << "WARNING: test of parameterized suite " << _suiteName << " can not be executed alone, test will be executed with first value only."; + } + + return true; + } + + bool branchTestsForIteration() + { + if (_iterationBranched) + { + return false; + } + + for (Test* iTest = _testAnchor.get(); iTest != nullptr; iTest = iTest->m_nextTest) + { + bool inSameSuite = (strcmp(iTest->m_details.suiteName, _suiteName.c_str()) == 0); + bool ownAnchor = (iTest == _testAnchor.get()); + bool isOtherParameterizedSuite = (iTest != _testAnchor.get() && dynamic_cast(iTest) != nullptr); + if (!inSameSuite || isOtherParameterizedSuite) + { + _firstOuterTest = iTest; + break; + } + _lastOfSuite = iTest; + } + + _lastOfSuite->m_nextTest = _testAnchor.get(); + + _iterationBranched = true; + return true; + } + + bool unbranchIterationIfLast() + { + if (!_iterationBranched) + { + return false; + } + + if (hasMoreValues(1)) + { + return false; + } + + _lastOfSuite->m_nextTest = _firstOuterTest; + return true; + } + + void onNewIteration() + { + if (_iterationBranched) + { + _iteration++; + } + + bool justBranched = branchTestsForIteration(); + bool justUnbranched = unbranchIterationIfLast(); + + if (justBranched && justUnbranched) + { + // If no values to test, skip all tests + if (valuesSize() == 0) + { + _testAnchor->m_nextTest = _firstOuterTest; + return; + } + } + + peekCurrentValue(); + } + + volatile bool _iterationBranched = false; + size_t _iteration = 0; + const string _suiteName; + const string _testName; + Test* _firstOuterTest = nullptr; + Test* _lastOfSuite = nullptr; + unique_ptr _testAnchor; + }; + + + /** + * @brief Repeat full test suite and gives different values, like a for(:) loop + * TODO: iteration should be over tests instead over suite + * + * @code + * SUITE(Testing) { + * vector suitesParams { 1, 5, 10 }; + * ParameterizedSuite parameters(UnitTestSuite::GetSuiteName()); + * TEST(Show) + * { + * cout << parameters.getCurrent() << endl; + * } + * } + * @endcode + */ + template & V_Values> + class ParameterizedSuite : public ParameterizedSuiteAbstract + { + public: + ParameterizedSuite(const string & suiteName) + : ParameterizedSuite(suiteName, [](T_Value) {}) + { + } + + ParameterizedSuite(const string & suiteName, function onNextIterationMethod) + : ParameterizedSuiteAbstract(suiteName), + _onNextIterationMethod(onNextIterationMethod) + { + } + + T_Value getCurrent() + { + ensureInitialized(); + return _currentValue; + } + + T_Value operator()() + { + return getCurrent(); + } + + protected: + + virtual void peekCurrentValue() override + { + _currentValue = V_Values[getIteration()]; + _onNextIterationMethod(_currentValue); + } + + virtual size_t valuesSize() override + { + return V_Values.size(); + } + + private: + + function _onNextIterationMethod; + T_Value _currentValue; + }; +} + +#endif \ No newline at end of file diff --git a/tests/TestParameterizedSuite.cpp b/tests/TestParameterizedSuite.cpp new file mode 100644 index 0000000..a2a4b76 --- /dev/null +++ b/tests/TestParameterizedSuite.cpp @@ -0,0 +1,93 @@ +#include "UnitTest++/UnitTest++.h" + +#include "UnitTest++/ParameterizedSuite.h" + +using namespace std; +using namespace UnitTest; + + +static int valuesSum = 0; +static int iterationsSum = 0; +static int ignoredCounter = 0; +static int otherParameterizedSuiteSum = 0; +static int singleValueSuiteSum = 0; +static int noValueSuiteSum = 0; + +SUITE(ParameterizedSuite) +{ + TEST(TestsOfBelowAreIgnored) + { + ignoredCounter++; + CHECK_EQUAL(1, ignoredCounter); + } + + vector values = { 1, 2, 3, 4 }; + ParameterizedSuite parameterized(UnitTestSuite::GetSuiteName()); + + size_t lastIteration = -1; + int lastValue = 0; + + TEST(IterationsAreFollowing) + { + CHECK_EQUAL(lastIteration + 1, parameterized.getIteration()); + lastIteration = parameterized.getIteration(); + iterationsSum++; + } + + TEST(ValuesAreFollowing) + { + CHECK_EQUAL(lastValue + 1, parameterized.getCurrent()); + lastValue = parameterized.getCurrent(); + valuesSum += parameterized.getCurrent(); + } + + TEST(ValueAndIterationAreSync) + { + CHECK_EQUAL(parameterized.getIteration() + 1, parameterized.getCurrent()); + } + + vector values2 = { 1000, 2000 }; + ParameterizedSuite parameterized2(UnitTestSuite::GetSuiteName()); + + TEST(OtherPSIgnoredFromFirstPS) + { + otherParameterizedSuiteSum += parameterized2.getCurrent(); + } +} + + +SUITE(ParameterizedSuite_LessValues) +{ + vector noValues = {}; + ParameterizedSuite parameterizedEmpty(UnitTestSuite::GetSuiteName()); + + TEST(WhenNoValue_zeroExecution) + { + noValueSuiteSum++; + throw exception("Should not have been reached"); + } + + + vector singleValue = { 2 }; + ParameterizedSuite parameterizedSingle(UnitTestSuite::GetSuiteName()); + + TEST(WhenSingleValue_singleExecution) + { + singleValueSuiteSum += parameterizedSingle.getCurrent(); + CHECK_EQUAL(2, singleValueSuiteSum); + } +} + + +SUITE(ParameterizedSuite_Validation) +{ + TEST(ParameterizedSuiteHasBeenIterated) + { + CHECK_EQUAL(1, ignoredCounter); + CHECK_EQUAL(10, valuesSum); + CHECK_EQUAL(4, iterationsSum); + CHECK_EQUAL(3000, otherParameterizedSuiteSum); + CHECK_EQUAL(2, singleValueSuiteSum); + CHECK_EQUAL(0, noValueSuiteSum); + } +} From 68118d6bf44d4a50c49f1e2099144d77d6e76372 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 11 May 2016 11:02:11 +0200 Subject: [PATCH 002/131] removed dependency to (and lambdas) --- UnitTest++/ParameterizedSuite.h | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/UnitTest++/ParameterizedSuite.h b/UnitTest++/ParameterizedSuite.h index 70d0708..fa9ce87 100644 --- a/UnitTest++/ParameterizedSuite.h +++ b/UnitTest++/ParameterizedSuite.h @@ -1,7 +1,6 @@ #ifndef UNITTEST_PARAMETERIZEDSUITE_H #define UNITTEST_PARAMETERIZEDSUITE_H -#include #include #include #include @@ -188,14 +187,20 @@ namespace UnitTest class ParameterizedSuite : public ParameterizedSuiteAbstract { public: + struct ISuiteIterationListener + { + virtual void onNextIteration(T_Value current, size_t iteration) = 0; + }; + + ParameterizedSuite(const string & suiteName) - : ParameterizedSuite(suiteName, [](T_Value) {}) + : ParameterizedSuite(suiteName, nullptr) { } - ParameterizedSuite(const string & suiteName, function onNextIterationMethod) + ParameterizedSuite(const string & suiteName, ISuiteIterationListener* const suiteIterationListener) : ParameterizedSuiteAbstract(suiteName), - _onNextIterationMethod(onNextIterationMethod) + _suiteIterationListener(suiteIterationListener) { } @@ -215,7 +220,11 @@ namespace UnitTest virtual void peekCurrentValue() override { _currentValue = V_Values[getIteration()]; - _onNextIterationMethod(_currentValue); + + if (_suiteIterationListener != nullptr) + { + _suiteIterationListener->onNextIteration(_currentValue, getIteration()); + } } virtual size_t valuesSize() override @@ -225,7 +234,7 @@ namespace UnitTest private: - function _onNextIterationMethod; + ISuiteIterationListener* const _suiteIterationListener; T_Value _currentValue; }; } From d8a5370e6565a92c785f1fd7729c1165810a63d1 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 11 May 2016 11:11:34 +0200 Subject: [PATCH 003/131] pass values in constructor instead of template argument --- UnitTest++/ParameterizedSuite.h | 17 ++++++++++------- tests/TestParameterizedSuite.cpp | 8 ++++---- 2 files changed, 14 insertions(+), 11 deletions(-) diff --git a/UnitTest++/ParameterizedSuite.h b/UnitTest++/ParameterizedSuite.h index fa9ce87..ac98766 100644 --- a/UnitTest++/ParameterizedSuite.h +++ b/UnitTest++/ParameterizedSuite.h @@ -175,7 +175,7 @@ namespace UnitTest * @code * SUITE(Testing) { * vector suitesParams { 1, 5, 10 }; - * ParameterizedSuite parameters(UnitTestSuite::GetSuiteName()); + * ParameterizedSuite parameters(UnitTestSuite::GetSuiteName(), suitesParams); * TEST(Show) * { * cout << parameters.getCurrent() << endl; @@ -183,7 +183,7 @@ namespace UnitTest * } * @endcode */ - template & V_Values> + template class ParameterizedSuite : public ParameterizedSuiteAbstract { public: @@ -193,13 +193,14 @@ namespace UnitTest }; - ParameterizedSuite(const string & suiteName) - : ParameterizedSuite(suiteName, nullptr) + ParameterizedSuite(const string & suiteName, vector values) + : ParameterizedSuite(suiteName, values, nullptr) { } - ParameterizedSuite(const string & suiteName, ISuiteIterationListener* const suiteIterationListener) + ParameterizedSuite(const string & suiteName, vector values, ISuiteIterationListener* const suiteIterationListener) : ParameterizedSuiteAbstract(suiteName), + _values(values), _suiteIterationListener(suiteIterationListener) { } @@ -219,7 +220,7 @@ namespace UnitTest virtual void peekCurrentValue() override { - _currentValue = V_Values[getIteration()]; + _currentValue = _values[getIteration()]; if (_suiteIterationListener != nullptr) { @@ -229,12 +230,14 @@ namespace UnitTest virtual size_t valuesSize() override { - return V_Values.size(); + return _values.size(); } private: ISuiteIterationListener* const _suiteIterationListener; + + vector _values; T_Value _currentValue; }; } diff --git a/tests/TestParameterizedSuite.cpp b/tests/TestParameterizedSuite.cpp index a2a4b76..1480f2d 100644 --- a/tests/TestParameterizedSuite.cpp +++ b/tests/TestParameterizedSuite.cpp @@ -22,7 +22,7 @@ SUITE(ParameterizedSuite) } vector values = { 1, 2, 3, 4 }; - ParameterizedSuite parameterized(UnitTestSuite::GetSuiteName()); + ParameterizedSuite parameterized(UnitTestSuite::GetSuiteName(), values); size_t lastIteration = -1; int lastValue = 0; @@ -47,7 +47,7 @@ SUITE(ParameterizedSuite) } vector values2 = { 1000, 2000 }; - ParameterizedSuite parameterized2(UnitTestSuite::GetSuiteName()); + ParameterizedSuite parameterized2(UnitTestSuite::GetSuiteName(), values2); TEST(OtherPSIgnoredFromFirstPS) { @@ -59,7 +59,7 @@ SUITE(ParameterizedSuite) SUITE(ParameterizedSuite_LessValues) { vector noValues = {}; - ParameterizedSuite parameterizedEmpty(UnitTestSuite::GetSuiteName()); + ParameterizedSuite parameterizedEmpty(UnitTestSuite::GetSuiteName(), noValues); TEST(WhenNoValue_zeroExecution) { @@ -69,7 +69,7 @@ SUITE(ParameterizedSuite_LessValues) vector singleValue = { 2 }; - ParameterizedSuite parameterizedSingle(UnitTestSuite::GetSuiteName()); + ParameterizedSuite parameterizedSingle(UnitTestSuite::GetSuiteName(), singleValue); TEST(WhenSingleValue_singleExecution) { From d01652f5148a5a990cc5b14a530ddd0f3c8d42f4 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 11 May 2016 11:19:15 +0200 Subject: [PATCH 004/131] removed cascading constructor --- UnitTest++/ParameterizedSuite.h | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/UnitTest++/ParameterizedSuite.h b/UnitTest++/ParameterizedSuite.h index ac98766..11a0ac2 100644 --- a/UnitTest++/ParameterizedSuite.h +++ b/UnitTest++/ParameterizedSuite.h @@ -192,13 +192,7 @@ namespace UnitTest virtual void onNextIteration(T_Value current, size_t iteration) = 0; }; - - ParameterizedSuite(const string & suiteName, vector values) - : ParameterizedSuite(suiteName, values, nullptr) - { - } - - ParameterizedSuite(const string & suiteName, vector values, ISuiteIterationListener* const suiteIterationListener) + ParameterizedSuite(const string & suiteName, vector values, ISuiteIterationListener* const suiteIterationListener = nullptr) : ParameterizedSuiteAbstract(suiteName), _values(values), _suiteIterationListener(suiteIterationListener) From 2a3c4ef4458ee8245eaf4c237941782233f7a72a Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 11 May 2016 11:24:48 +0200 Subject: [PATCH 005/131] removed dependency to and unique_pointer --- UnitTest++/ParameterizedSuite.h | 25 +++++++++++++++++-------- 1 file changed, 17 insertions(+), 8 deletions(-) diff --git a/UnitTest++/ParameterizedSuite.h b/UnitTest++/ParameterizedSuite.h index 11a0ac2..3c6fd40 100644 --- a/UnitTest++/ParameterizedSuite.h +++ b/UnitTest++/ParameterizedSuite.h @@ -2,7 +2,6 @@ #define UNITTEST_PARAMETERIZEDSUITE_H #include -#include #include #include "Test.h" @@ -17,11 +16,21 @@ namespace UnitTest ParameterizedSuiteAbstract(const string & suiteName) : _suiteName(suiteName), - _testName(suiteName + "ParameterizedSuite_starter") + _testName(suiteName + "ParameterizedSuite_starter"), + _testAnchor(nullptr) // Important, even if defined just above (please read comment) { // WARNING: this is pointer because of memory problems with suiteName/testName.c_str(), // the constructor does not initialize them in the right order - _testAnchor = make_unique(*this); + _testAnchor = new TestAnchor(*this); + } + + virtual ~ParameterizedSuiteAbstract() + { + if (_testAnchor != nullptr) + { + delete _testAnchor; + _testAnchor = nullptr; + } } size_t getIteration() @@ -100,11 +109,11 @@ namespace UnitTest return false; } - for (Test* iTest = _testAnchor.get(); iTest != nullptr; iTest = iTest->m_nextTest) + for (Test* iTest = _testAnchor; iTest != nullptr; iTest = iTest->m_nextTest) { bool inSameSuite = (strcmp(iTest->m_details.suiteName, _suiteName.c_str()) == 0); - bool ownAnchor = (iTest == _testAnchor.get()); - bool isOtherParameterizedSuite = (iTest != _testAnchor.get() && dynamic_cast(iTest) != nullptr); + bool ownAnchor = (iTest == _testAnchor); + bool isOtherParameterizedSuite = (iTest != _testAnchor && dynamic_cast(iTest) != nullptr); if (!inSameSuite || isOtherParameterizedSuite) { _firstOuterTest = iTest; @@ -113,7 +122,7 @@ namespace UnitTest _lastOfSuite = iTest; } - _lastOfSuite->m_nextTest = _testAnchor.get(); + _lastOfSuite->m_nextTest = _testAnchor; _iterationBranched = true; return true; @@ -164,7 +173,7 @@ namespace UnitTest const string _testName; Test* _firstOuterTest = nullptr; Test* _lastOfSuite = nullptr; - unique_ptr _testAnchor; + TestAnchor* _testAnchor; }; From 313830b6893d78402725d46b3490564bffcd9ac9 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 11 May 2016 11:28:11 +0200 Subject: [PATCH 006/131] fixed uncoherent test name --- UnitTest++/ParameterizedSuite.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/UnitTest++/ParameterizedSuite.h b/UnitTest++/ParameterizedSuite.h index 3c6fd40..cf7a6a6 100644 --- a/UnitTest++/ParameterizedSuite.h +++ b/UnitTest++/ParameterizedSuite.h @@ -16,7 +16,7 @@ namespace UnitTest ParameterizedSuiteAbstract(const string & suiteName) : _suiteName(suiteName), - _testName(suiteName + "ParameterizedSuite_starter"), + _testName(suiteName + "ParameterizedSuite_anchor"), _testAnchor(nullptr) // Important, even if defined just above (please read comment) { // WARNING: this is pointer because of memory problems with suiteName/testName.c_str(), From a05e709d853d50a4ceac09384d5e5383009516eb Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Thu, 12 May 2016 13:31:45 +0200 Subject: [PATCH 007/131] added endl after warning --- UnitTest++/ParameterizedSuite.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/UnitTest++/ParameterizedSuite.h b/UnitTest++/ParameterizedSuite.h index cf7a6a6..1fe4747 100644 --- a/UnitTest++/ParameterizedSuite.h +++ b/UnitTest++/ParameterizedSuite.h @@ -96,7 +96,8 @@ namespace UnitTest if (!messageDisplayed) { messageDisplayed = true; - cout << "WARNING: test of parameterized suite " << _suiteName << " can not be executed alone, test will be executed with first value only."; + cout << "WARNING: test of parameterized suite " << _suiteName + << " can not be executed alone, test will be executed with first value only." << endl; } return true; From a6c56fe54b1d7839ed6f5c8a9209c91bd1b31cc3 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 13 May 2016 21:26:56 +0200 Subject: [PATCH 008/131] less C++11 --- UnitTest++/ParameterizedSuite.h | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/UnitTest++/ParameterizedSuite.h b/UnitTest++/ParameterizedSuite.h index 1fe4747..7c40d68 100644 --- a/UnitTest++/ParameterizedSuite.h +++ b/UnitTest++/ParameterizedSuite.h @@ -15,8 +15,12 @@ namespace UnitTest public: ParameterizedSuiteAbstract(const string & suiteName) - : _suiteName(suiteName), + : _iterationBranched(false), + _iteration(0), + _suiteName(suiteName), _testName(suiteName + "ParameterizedSuite_anchor"), + _firstOuterTest(nullptr), + _lastOfSuite(nullptr), _testAnchor(nullptr) // Important, even if defined just above (please read comment) { // WARNING: this is pointer because of memory problems with suiteName/testName.c_str(), @@ -168,12 +172,12 @@ namespace UnitTest peekCurrentValue(); } - volatile bool _iterationBranched = false; - size_t _iteration = 0; + volatile bool _iterationBranched; + size_t _iteration; const string _suiteName; const string _testName; - Test* _firstOuterTest = nullptr; - Test* _lastOfSuite = nullptr; + Test* _firstOuterTest; + Test* _lastOfSuite; TestAnchor* _testAnchor; }; From ab3cc22e574973c4d9c57b3b6acf802238109f74 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 13 May 2016 22:10:40 +0200 Subject: [PATCH 009/131] created macro SET_SUITE_PARAMETERS --- UnitTest++/ParameterizedMacros.h | 22 ++++++++++++++++++++++ UnitTest++/UnitTestPP.h | 1 + 2 files changed, 23 insertions(+) create mode 100644 UnitTest++/ParameterizedMacros.h diff --git a/UnitTest++/ParameterizedMacros.h b/UnitTest++/ParameterizedMacros.h new file mode 100644 index 0000000..0a852c1 --- /dev/null +++ b/UnitTest++/ParameterizedMacros.h @@ -0,0 +1,22 @@ +#ifndef UNITTEST_PARAMETERIZEDMACROS_H +#define UNITTEST_PARAMETERIZEDMACROS_H + +#include "ParameterizedSuite.h" + + +#define SET_SUITE_PARAMETERS(Name, Type) \ + class ParameterizedCreator ## Name\ + { \ + friend class ParameterizedSuite<## Type>; \ + public: \ + ParameterizedCreator ## Name() { create(); } \ + vector<## Type> parameters; \ + private: \ + void create(); \ + } parameterizedCreator ## Name ## Instance; \ + \ + ParameterizedSuite<##Type> ## Name(UnitTestSuite::GetSuiteName(), parameterizedCreator ## Name ## Instance.parameters); \ + \ + void ParameterizedCreator ## Name::create() + +#endif diff --git a/UnitTest++/UnitTestPP.h b/UnitTest++/UnitTestPP.h index 3e02d31..08f15bc 100644 --- a/UnitTest++/UnitTestPP.h +++ b/UnitTest++/UnitTestPP.h @@ -8,5 +8,6 @@ #include "TestRunner.h" #include "TimeConstraint.h" #include "ReportAssert.h" +#include "ParameterizedMacros.h" #endif From 1dbb31f18490cfd7f06bfb6092d1d3d65e3ab447 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 13 May 2016 22:12:34 +0200 Subject: [PATCH 010/131] updated tests for using macros --- tests/TestParameterizedSuite.cpp | 31 ++++++++++++++++++++++--------- 1 file changed, 22 insertions(+), 9 deletions(-) diff --git a/tests/TestParameterizedSuite.cpp b/tests/TestParameterizedSuite.cpp index 1480f2d..cf48e4a 100644 --- a/tests/TestParameterizedSuite.cpp +++ b/tests/TestParameterizedSuite.cpp @@ -15,14 +15,21 @@ static int noValueSuiteSum = 0; SUITE(ParameterizedSuite) { + + TEST(TestsOfBelowAreIgnored) { ignoredCounter++; CHECK_EQUAL(1, ignoredCounter); } - vector values = { 1, 2, 3, 4 }; - ParameterizedSuite parameterized(UnitTestSuite::GetSuiteName(), values); + SET_SUITE_PARAMETERS(parameterized, int) + { + parameters.push_back(1); + parameters.push_back(2); + parameters.push_back(3); + parameters.push_back(4); + } size_t lastIteration = -1; int lastValue = 0; @@ -46,8 +53,12 @@ SUITE(ParameterizedSuite) CHECK_EQUAL(parameterized.getIteration() + 1, parameterized.getCurrent()); } - vector values2 = { 1000, 2000 }; - ParameterizedSuite parameterized2(UnitTestSuite::GetSuiteName(), values2); + + SET_SUITE_PARAMETERS(parameterized2, int) + { + parameters.push_back(1000); + parameters.push_back(2000); + } TEST(OtherPSIgnoredFromFirstPS) { @@ -58,8 +69,9 @@ SUITE(ParameterizedSuite) SUITE(ParameterizedSuite_LessValues) { - vector noValues = {}; - ParameterizedSuite parameterizedEmpty(UnitTestSuite::GetSuiteName(), noValues); + SET_SUITE_PARAMETERS(parameterizedEmpty, int) + { + } TEST(WhenNoValue_zeroExecution) { @@ -67,9 +79,10 @@ SUITE(ParameterizedSuite_LessValues) throw exception("Should not have been reached"); } - - vector singleValue = { 2 }; - ParameterizedSuite parameterizedSingle(UnitTestSuite::GetSuiteName(), singleValue); + SET_SUITE_PARAMETERS(parameterizedSingle, int) + { + parameters.push_back(2); + } TEST(WhenSingleValue_singleExecution) { From 0a3c6991647a143ece7b22610234cf98095f4b08 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 13 May 2016 22:18:23 +0200 Subject: [PATCH 011/131] little macro syntax change --- UnitTest++/ParameterizedMacros.h | 5 +++-- tests/TestParameterizedSuite.cpp | 22 ++++++++-------------- 2 files changed, 11 insertions(+), 16 deletions(-) diff --git a/UnitTest++/ParameterizedMacros.h b/UnitTest++/ParameterizedMacros.h index 0a852c1..1e07912 100644 --- a/UnitTest++/ParameterizedMacros.h +++ b/UnitTest++/ParameterizedMacros.h @@ -4,7 +4,7 @@ #include "ParameterizedSuite.h" -#define SET_SUITE_PARAMETERS(Name, Type) \ +#define SET_SUITE_PARAMETERS(Name, Type, SetUpBody) \ class ParameterizedCreator ## Name\ { \ friend class ParameterizedSuite<## Type>; \ @@ -17,6 +17,7 @@ \ ParameterizedSuite<##Type> ## Name(UnitTestSuite::GetSuiteName(), parameterizedCreator ## Name ## Instance.parameters); \ \ - void ParameterizedCreator ## Name::create() + void ParameterizedCreator ## Name::create() \ + ## SetUpBody #endif diff --git a/tests/TestParameterizedSuite.cpp b/tests/TestParameterizedSuite.cpp index cf48e4a..040ff67 100644 --- a/tests/TestParameterizedSuite.cpp +++ b/tests/TestParameterizedSuite.cpp @@ -15,21 +15,18 @@ static int noValueSuiteSum = 0; SUITE(ParameterizedSuite) { - - TEST(TestsOfBelowAreIgnored) { ignoredCounter++; CHECK_EQUAL(1, ignoredCounter); } - SET_SUITE_PARAMETERS(parameterized, int) - { + SET_SUITE_PARAMETERS(parameterized, int, { parameters.push_back(1); parameters.push_back(2); parameters.push_back(3); parameters.push_back(4); - } + }) size_t lastIteration = -1; int lastValue = 0; @@ -54,11 +51,10 @@ SUITE(ParameterizedSuite) } - SET_SUITE_PARAMETERS(parameterized2, int) - { + SET_SUITE_PARAMETERS(parameterized2, int, { parameters.push_back(1000); parameters.push_back(2000); - } + }) TEST(OtherPSIgnoredFromFirstPS) { @@ -69,9 +65,8 @@ SUITE(ParameterizedSuite) SUITE(ParameterizedSuite_LessValues) { - SET_SUITE_PARAMETERS(parameterizedEmpty, int) - { - } + SET_SUITE_PARAMETERS(parameterizedEmpty, int, { + }) TEST(WhenNoValue_zeroExecution) { @@ -79,10 +74,9 @@ SUITE(ParameterizedSuite_LessValues) throw exception("Should not have been reached"); } - SET_SUITE_PARAMETERS(parameterizedSingle, int) - { + SET_SUITE_PARAMETERS(parameterizedSingle, int, { parameters.push_back(2); - } + }) TEST(WhenSingleValue_singleExecution) { From abb066719cd2dc75aa85ac78b845e7af0707d740 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 13 May 2016 22:25:22 +0200 Subject: [PATCH 012/131] created macro PARAMETERIZED_SUITE (usage is like SUITE marco) --- UnitTest++/ParameterizedMacros.h | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/UnitTest++/ParameterizedMacros.h b/UnitTest++/ParameterizedMacros.h index 1e07912..9430d74 100644 --- a/UnitTest++/ParameterizedMacros.h +++ b/UnitTest++/ParameterizedMacros.h @@ -4,20 +4,27 @@ #include "ParameterizedSuite.h" -#define SET_SUITE_PARAMETERS(Name, Type, SetUpBody) \ - class ParameterizedCreator ## Name\ +#define SET_SUITE_PARAMETERS(IterationName, Type, SetUpBody) \ + class ParameterizedCreator ## IterationName\ { \ friend class ParameterizedSuite<## Type>; \ public: \ - ParameterizedCreator ## Name() { create(); } \ + ParameterizedCreator ## IterationName() { create(); } \ vector<## Type> parameters; \ private: \ void create(); \ - } parameterizedCreator ## Name ## Instance; \ + } parameterizedCreator ## IterationName ## Instance; \ \ - ParameterizedSuite<##Type> ## Name(UnitTestSuite::GetSuiteName(), parameterizedCreator ## Name ## Instance.parameters); \ + ParameterizedSuite<##Type> ## IterationName(UnitTestSuite::GetSuiteName(), parameterizedCreator ## IterationName ## Instance.parameters); \ \ - void ParameterizedCreator ## Name::create() \ + void ParameterizedCreator ## IterationName::create() \ ## SetUpBody +#define PARAMETERIZED_SUITE(Name, IterationName, Type, SetUpBody) \ + SUITE(## Name) \ + { \ + SET_SUITE_PARAMETERS(## IterationName, ## Type, ## SetUpBody) \ + } \ + namespace Suite ## Name + #endif From 1966eee56c99417b068669e53764ee614168b56f Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 13 May 2016 22:25:39 +0200 Subject: [PATCH 013/131] created test --- tests/TestParameterizedSuite.cpp | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/tests/TestParameterizedSuite.cpp b/tests/TestParameterizedSuite.cpp index 040ff67..8bc9a30 100644 --- a/tests/TestParameterizedSuite.cpp +++ b/tests/TestParameterizedSuite.cpp @@ -5,7 +5,7 @@ using namespace std; using namespace UnitTest; - +static int simpleValuesSum = 0; static int valuesSum = 0; static int iterationsSum = 0; static int ignoredCounter = 0; @@ -13,6 +13,21 @@ static int otherParameterizedSuiteSum = 0; static int singleValueSuiteSum = 0; static int noValueSuiteSum = 0; + +PARAMETERIZED_SUITE(ParameterizedSuiteSimple, iVal, int, { + parameters.push_back(10); + parameters.push_back(20); + parameters.push_back(30); + parameters.push_back(40); +}) +{ + TEST(SimpleSum) + { + simpleValuesSum += iVal(); + } +} + + SUITE(ParameterizedSuite) { TEST(TestsOfBelowAreIgnored) @@ -90,6 +105,7 @@ SUITE(ParameterizedSuite_Validation) { TEST(ParameterizedSuiteHasBeenIterated) { + CHECK_EQUAL(100, simpleValuesSum); CHECK_EQUAL(1, ignoredCounter); CHECK_EQUAL(10, valuesSum); CHECK_EQUAL(4, iterationsSum); From 88005464a2c804d1ff94c3c1c817067c10320496 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 13 May 2016 22:27:50 +0200 Subject: [PATCH 014/131] changed params order --- UnitTest++/ParameterizedMacros.h | 7 ++++--- tests/TestParameterizedSuite.cpp | 10 +++++----- 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/UnitTest++/ParameterizedMacros.h b/UnitTest++/ParameterizedMacros.h index 9430d74..5abb32c 100644 --- a/UnitTest++/ParameterizedMacros.h +++ b/UnitTest++/ParameterizedMacros.h @@ -4,7 +4,7 @@ #include "ParameterizedSuite.h" -#define SET_SUITE_PARAMETERS(IterationName, Type, SetUpBody) \ +#define SET_SUITE_PARAMETERS(Type, IterationName, SetUpBody) \ class ParameterizedCreator ## IterationName\ { \ friend class ParameterizedSuite<## Type>; \ @@ -20,10 +20,11 @@ void ParameterizedCreator ## IterationName::create() \ ## SetUpBody -#define PARAMETERIZED_SUITE(Name, IterationName, Type, SetUpBody) \ + +#define PARAMETERIZED_SUITE(Name, Type, IterationName, SetUpBody) \ SUITE(## Name) \ { \ - SET_SUITE_PARAMETERS(## IterationName, ## Type, ## SetUpBody) \ + SET_SUITE_PARAMETERS(## Type, ## IterationName, ## SetUpBody) \ } \ namespace Suite ## Name diff --git a/tests/TestParameterizedSuite.cpp b/tests/TestParameterizedSuite.cpp index 8bc9a30..db906c2 100644 --- a/tests/TestParameterizedSuite.cpp +++ b/tests/TestParameterizedSuite.cpp @@ -14,7 +14,7 @@ static int singleValueSuiteSum = 0; static int noValueSuiteSum = 0; -PARAMETERIZED_SUITE(ParameterizedSuiteSimple, iVal, int, { +PARAMETERIZED_SUITE(ParameterizedSuiteSimple, int, iVal, { parameters.push_back(10); parameters.push_back(20); parameters.push_back(30); @@ -36,7 +36,7 @@ SUITE(ParameterizedSuite) CHECK_EQUAL(1, ignoredCounter); } - SET_SUITE_PARAMETERS(parameterized, int, { + SET_SUITE_PARAMETERS(int, parameterized, { parameters.push_back(1); parameters.push_back(2); parameters.push_back(3); @@ -66,7 +66,7 @@ SUITE(ParameterizedSuite) } - SET_SUITE_PARAMETERS(parameterized2, int, { + SET_SUITE_PARAMETERS(int, parameterized2, { parameters.push_back(1000); parameters.push_back(2000); }) @@ -80,7 +80,7 @@ SUITE(ParameterizedSuite) SUITE(ParameterizedSuite_LessValues) { - SET_SUITE_PARAMETERS(parameterizedEmpty, int, { + SET_SUITE_PARAMETERS(int, parameterizedEmpty, { }) TEST(WhenNoValue_zeroExecution) @@ -89,7 +89,7 @@ SUITE(ParameterizedSuite_LessValues) throw exception("Should not have been reached"); } - SET_SUITE_PARAMETERS(parameterizedSingle, int, { + SET_SUITE_PARAMETERS(int, parameterizedSingle, { parameters.push_back(2); }) From f9f3523ce3a082037f11ed1548e88d1903058835 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 13 May 2016 22:33:02 +0200 Subject: [PATCH 015/131] added some const methods --- UnitTest++/ParameterizedSuite.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/UnitTest++/ParameterizedSuite.h b/UnitTest++/ParameterizedSuite.h index 7c40d68..621c3c9 100644 --- a/UnitTest++/ParameterizedSuite.h +++ b/UnitTest++/ParameterizedSuite.h @@ -37,7 +37,7 @@ namespace UnitTest } } - size_t getIteration() + inline size_t getIteration() const { return _iteration; } @@ -45,7 +45,7 @@ namespace UnitTest protected: virtual void peekCurrentValue() = 0; - virtual size_t valuesSize() = 0; + virtual size_t valuesSize() const = 0; void ensureInitialized() { @@ -53,7 +53,7 @@ namespace UnitTest tryBranchUniqueTest(); } - bool hasMoreValues(int advance = 0) + bool hasMoreValues(int advance = 0) const { return (_iteration + advance < (int)valuesSize()); } From 17ec122775637c3ad8d534305d48fb2e6feb7fee Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 13 May 2016 22:40:55 +0200 Subject: [PATCH 016/131] splitted class in .h/.cpp --- UnitTest++/ParameterizedSuite.cpp | 166 ++++++++++++++++++++++++++++++ UnitTest++/ParameterizedSuite.h | 164 +++-------------------------- 2 files changed, 179 insertions(+), 151 deletions(-) create mode 100644 UnitTest++/ParameterizedSuite.cpp diff --git a/UnitTest++/ParameterizedSuite.cpp b/UnitTest++/ParameterizedSuite.cpp new file mode 100644 index 0000000..fa235e4 --- /dev/null +++ b/UnitTest++/ParameterizedSuite.cpp @@ -0,0 +1,166 @@ +#include "ParameterizedSuite.h" + +#include +#include +#include "TestList.h" + +using namespace std; +using namespace UnitTest; + + +ParameterizedSuiteAbstract::ParameterizedSuiteAbstract(const string & suiteName) + : _iterationBranched(false), + _iteration(0), + _suiteName(suiteName), + _testName(suiteName + "ParameterizedSuite_anchor"), + _firstOuterTest(nullptr), + _lastOfSuite(nullptr), + _testAnchor(nullptr) // Important, even if defined just above (please read comment) +{ + // WARNING: this is pointer because of memory problems with suiteName/testName.c_str(), + // the constructor does not initialize them in the right order + _testAnchor = new TestAnchor(*this); +} + + +ParameterizedSuiteAbstract::~ParameterizedSuiteAbstract() +{ + if (_testAnchor != nullptr) + { + delete _testAnchor; + _testAnchor = nullptr; + } +} + + +size_t ParameterizedSuiteAbstract::getIteration() const +{ + return _iteration; +} + + +void ParameterizedSuiteAbstract::ensureInitialized() +{ + tryPeekFirstValue(); + tryBranchUniqueTest(); +} + + +bool ParameterizedSuiteAbstract::hasMoreValues(int advance) const +{ + return (_iteration + advance < (int)valuesSize()); +} + + +bool ParameterizedSuiteAbstract::tryPeekFirstValue() +{ + if (_iterationBranched) + { + return false; + } + + peekCurrentValue(); + return false; +} + + +bool ParameterizedSuiteAbstract::tryBranchUniqueTest() +{ + if (_iterationBranched) + { + return false; + } + + //TODO find a way to allow single parameterized test execution + static bool messageDisplayed = false; + if (!messageDisplayed) + { + messageDisplayed = true; + cout << "WARNING: test of parameterized suite " << _suiteName + << " can not be executed alone, test will be executed with first value only." << endl; + } + + return true; +} + + +bool ParameterizedSuiteAbstract::branchTestsForIteration() +{ + if (_iterationBranched) + { + return false; + } + + for (Test* iTest = _testAnchor; iTest != nullptr; iTest = iTest->m_nextTest) + { + bool inSameSuite = (strcmp(iTest->m_details.suiteName, _suiteName.c_str()) == 0); + bool ownAnchor = (iTest == _testAnchor); + bool isOtherParameterizedSuite = (iTest != _testAnchor && dynamic_cast(iTest) != nullptr); + if (!inSameSuite || isOtherParameterizedSuite) + { + _firstOuterTest = iTest; + break; + } + _lastOfSuite = iTest; + } + + _lastOfSuite->m_nextTest = _testAnchor; + + _iterationBranched = true; + return true; +} + + +bool ParameterizedSuiteAbstract::unbranchIterationIfLast() +{ + if (!_iterationBranched) + { + return false; + } + + if (hasMoreValues(1)) + { + return false; + } + + _lastOfSuite->m_nextTest = _firstOuterTest; + return true; +} + + +void ParameterizedSuiteAbstract::onNewIteration() +{ + if (_iterationBranched) + { + _iteration++; + } + + bool justBranched = branchTestsForIteration(); + bool justUnbranched = unbranchIterationIfLast(); + + if (justBranched && justUnbranched) + { + // If no values to test, skip all tests + if (valuesSize() == 0) + { + _testAnchor->m_nextTest = _firstOuterTest; + return; + } + } + + peekCurrentValue(); +} + + +ParameterizedSuiteAbstract::TestAnchor::TestAnchor(ParameterizedSuiteAbstract & parameterized) + : Test(parameterized._testName.c_str(), parameterized._suiteName.c_str()), + _parameterized(parameterized) +{ + Test::GetTestList().Add(this); +} + + +void ParameterizedSuiteAbstract::TestAnchor::RunImpl() const +{ + _parameterized.onNewIteration(); +} diff --git a/UnitTest++/ParameterizedSuite.h b/UnitTest++/ParameterizedSuite.h index 621c3c9..7a8e9a5 100644 --- a/UnitTest++/ParameterizedSuite.h +++ b/UnitTest++/ParameterizedSuite.h @@ -2,8 +2,6 @@ #define UNITTEST_PARAMETERIZEDSUITE_H #include -#include - #include "Test.h" namespace UnitTest @@ -13,164 +11,31 @@ namespace UnitTest class ParameterizedSuiteAbstract { public: - - ParameterizedSuiteAbstract(const string & suiteName) - : _iterationBranched(false), - _iteration(0), - _suiteName(suiteName), - _testName(suiteName + "ParameterizedSuite_anchor"), - _firstOuterTest(nullptr), - _lastOfSuite(nullptr), - _testAnchor(nullptr) // Important, even if defined just above (please read comment) - { - // WARNING: this is pointer because of memory problems with suiteName/testName.c_str(), - // the constructor does not initialize them in the right order - _testAnchor = new TestAnchor(*this); - } - - virtual ~ParameterizedSuiteAbstract() - { - if (_testAnchor != nullptr) - { - delete _testAnchor; - _testAnchor = nullptr; - } - } - - inline size_t getIteration() const - { - return _iteration; - } + ParameterizedSuiteAbstract(const string & suiteName); + virtual ~ParameterizedSuiteAbstract(); + size_t getIteration() const; protected: - virtual void peekCurrentValue() = 0; virtual size_t valuesSize() const = 0; - - void ensureInitialized() - { - tryPeekFirstValue(); - tryBranchUniqueTest(); - } - - bool hasMoreValues(int advance = 0) const - { - return (_iteration + advance < (int)valuesSize()); - } + void ensureInitialized(); + bool hasMoreValues(int advance = 0) const; private: - class TestAnchor : public Test { public: - TestAnchor(ParameterizedSuiteAbstract & parameterized) - : Test(parameterized._testName.c_str(), parameterized._suiteName.c_str()), - _parameterized(parameterized) - { - Test::GetTestList().Add(this); - } - virtual void RunImpl() const override - { - _parameterized.onNewIteration(); - } + TestAnchor(ParameterizedSuiteAbstract & parameterized); + virtual void RunImpl() const override; private: ParameterizedSuiteAbstract & _parameterized; }; - bool tryPeekFirstValue() - { - if (_iterationBranched) - { - return false; - } - - peekCurrentValue(); - return false; - } - - bool tryBranchUniqueTest() - { - if (_iterationBranched) - { - return false; - } - - //TODO find a way to allow single parameterized test execution - static bool messageDisplayed = false; - if (!messageDisplayed) - { - messageDisplayed = true; - cout << "WARNING: test of parameterized suite " << _suiteName - << " can not be executed alone, test will be executed with first value only." << endl; - } - - return true; - } - - bool branchTestsForIteration() - { - if (_iterationBranched) - { - return false; - } - - for (Test* iTest = _testAnchor; iTest != nullptr; iTest = iTest->m_nextTest) - { - bool inSameSuite = (strcmp(iTest->m_details.suiteName, _suiteName.c_str()) == 0); - bool ownAnchor = (iTest == _testAnchor); - bool isOtherParameterizedSuite = (iTest != _testAnchor && dynamic_cast(iTest) != nullptr); - if (!inSameSuite || isOtherParameterizedSuite) - { - _firstOuterTest = iTest; - break; - } - _lastOfSuite = iTest; - } - - _lastOfSuite->m_nextTest = _testAnchor; - - _iterationBranched = true; - return true; - } - - bool unbranchIterationIfLast() - { - if (!_iterationBranched) - { - return false; - } - - if (hasMoreValues(1)) - { - return false; - } - - _lastOfSuite->m_nextTest = _firstOuterTest; - return true; - } - - void onNewIteration() - { - if (_iterationBranched) - { - _iteration++; - } - - bool justBranched = branchTestsForIteration(); - bool justUnbranched = unbranchIterationIfLast(); - - if (justBranched && justUnbranched) - { - // If no values to test, skip all tests - if (valuesSize() == 0) - { - _testAnchor->m_nextTest = _firstOuterTest; - return; - } - } - - peekCurrentValue(); - } + bool tryPeekFirstValue(); + bool tryBranchUniqueTest(); + bool branchTestsForIteration(); + bool unbranchIterationIfLast(); + void onNewIteration(); volatile bool _iterationBranched; size_t _iteration; @@ -229,22 +94,19 @@ namespace UnitTest virtual void peekCurrentValue() override { _currentValue = _values[getIteration()]; - if (_suiteIterationListener != nullptr) { _suiteIterationListener->onNextIteration(_currentValue, getIteration()); } } - virtual size_t valuesSize() override + virtual size_t valuesSize() const override { return _values.size(); } private: - ISuiteIterationListener* const _suiteIterationListener; - vector _values; T_Value _currentValue; }; From f6f07775af4411091f5e592cd63a94af7f49f267 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sat, 14 May 2016 10:42:20 +0200 Subject: [PATCH 017/131] created empty class ParameterizedTest --- UnitTest++/ParameterizedTest.cpp | 13 +++++++++++++ UnitTest++/ParameterizedTest.h | 14 ++++++++++++++ 2 files changed, 27 insertions(+) create mode 100644 UnitTest++/ParameterizedTest.cpp create mode 100644 UnitTest++/ParameterizedTest.h diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp new file mode 100644 index 0000000..7ab2d4b --- /dev/null +++ b/UnitTest++/ParameterizedTest.cpp @@ -0,0 +1,13 @@ +#include "ParameterizedTest.h" + +using namespace UnitTest; + + +ParameterizedTest::ParameterizedTest() +{ +} + + +ParameterizedTest::~ParameterizedTest() +{ +} diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h new file mode 100644 index 0000000..249198a --- /dev/null +++ b/UnitTest++/ParameterizedTest.h @@ -0,0 +1,14 @@ +#ifndef UNITTEST_PARAMETERIZEDTEST_H +#define UNITTEST_PARAMETERIZEDTEST_H + +namespace UnitTest +{ + class ParameterizedTest + { + public: + ParameterizedTest(); + virtual ~ParameterizedTest(); + }; +} + +#endif \ No newline at end of file From a1510a13a054d05296afb7695983f58d9044ac1b Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sat, 14 May 2016 11:25:03 +0200 Subject: [PATCH 018/131] method for retrieve a test from its details --- UnitTest++/ParameterizedTest.cpp | 40 ++++++++++++++++++++++++++++++++ UnitTest++/ParameterizedTest.h | 13 +++++++++++ 2 files changed, 53 insertions(+) diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index 7ab2d4b..1bff0b7 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -1,5 +1,9 @@ #include "ParameterizedTest.h" +#include "TestList.h" +#include "CurrentTest.h" + +using namespace std; using namespace UnitTest; @@ -11,3 +15,39 @@ ParameterizedTest::ParameterizedTest() ParameterizedTest::~ParameterizedTest() { } + + +Details2Test & ParameterizedTest::getFastSearchMap() +{ + static Details2Test storedMap; + return storedMap; +} + + +Test* const ParameterizedTest::retrieveCurrentTest() +{ + return retrieveTest(CurrentTest::Details()); +} + + +Test* const ParameterizedTest::retrieveTest(TestDetails const * const details) +{ + //TODO This workaround is too far complicated, why not simply add pointer to current test in class CurrentTest ? + Details2Test::iterator it = getFastSearchMap().find(details); + + if (it != getFastSearchMap().end()) + { + return it->second; + } + + for(Test* iTest = Test::GetTestList().GetHead() ; iTest!= nullptr ; iTest=iTest->m_nextTest) + { + if (&iTest->m_details == details) + { + getFastSearchMap()[details] = iTest; + return iTest; + } + } + + return nullptr; +} diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h index 249198a..0b4e6d4 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/ParameterizedTest.h @@ -1,13 +1,26 @@ #ifndef UNITTEST_PARAMETERIZEDTEST_H #define UNITTEST_PARAMETERIZEDTEST_H +#include +#include +#include "Test.h" + namespace UnitTest { + using namespace std; + + typedef map Details2Test; + class ParameterizedTest { public: ParameterizedTest(); virtual ~ParameterizedTest(); + + private: + static Details2Test & getFastSearchMap(); + static Test* const retrieveCurrentTest(); + static Test* const retrieveTest(TestDetails const * const details); }; } From 908f7b58469f95bafda2be189ea766c0f34e1965 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sat, 14 May 2016 11:27:42 +0200 Subject: [PATCH 019/131] throw exception if test not retrieved --- UnitTest++/ParameterizedTest.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index 1bff0b7..d4e2e8a 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -49,5 +49,5 @@ Test* const ParameterizedTest::retrieveTest(TestDetails const * const details) } } - return nullptr; + throw runtime_error(string("Impossible to retrieve test ") + details->testName); } From 0be4fefd7475d9c1dbe11b521c20440973f66c9f Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sat, 14 May 2016 23:38:09 +0200 Subject: [PATCH 020/131] non static members --- UnitTest++/ParameterizedTest.cpp | 13 +++---------- UnitTest++/ParameterizedTest.h | 6 +++--- 2 files changed, 6 insertions(+), 13 deletions(-) diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index d4e2e8a..0fc3e7e 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -17,13 +17,6 @@ ParameterizedTest::~ParameterizedTest() } -Details2Test & ParameterizedTest::getFastSearchMap() -{ - static Details2Test storedMap; - return storedMap; -} - - Test* const ParameterizedTest::retrieveCurrentTest() { return retrieveTest(CurrentTest::Details()); @@ -33,9 +26,9 @@ Test* const ParameterizedTest::retrieveCurrentTest() Test* const ParameterizedTest::retrieveTest(TestDetails const * const details) { //TODO This workaround is too far complicated, why not simply add pointer to current test in class CurrentTest ? - Details2Test::iterator it = getFastSearchMap().find(details); + Details2Test::iterator it = _tests.find(details); - if (it != getFastSearchMap().end()) + if (it != _tests.end()) { return it->second; } @@ -44,7 +37,7 @@ Test* const ParameterizedTest::retrieveTest(TestDetails const * const details) { if (&iTest->m_details == details) { - getFastSearchMap()[details] = iTest; + _tests[details] = iTest; return iTest; } } diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h index 0b4e6d4..05ff9cd 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/ParameterizedTest.h @@ -18,9 +18,9 @@ namespace UnitTest virtual ~ParameterizedTest(); private: - static Details2Test & getFastSearchMap(); - static Test* const retrieveCurrentTest(); - static Test* const retrieveTest(TestDetails const * const details); + Test* const retrieveCurrentTest(); + Test* const retrieveTest(TestDetails const * const details); + Details2Test _tests; }; } From 183209faf8c756dc53390f35eb97d90a1f91d7fe Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sun, 15 May 2016 01:01:29 +0200 Subject: [PATCH 021/131] coded feature --- UnitTest++/ParameterizedTest.cpp | 87 ++++++++++++++++++++++++++++++-- UnitTest++/ParameterizedTest.h | 63 +++++++++++++++++++++-- 2 files changed, 143 insertions(+), 7 deletions(-) diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index 0fc3e7e..df65de9 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -7,23 +7,57 @@ using namespace std; using namespace UnitTest; -ParameterizedTest::ParameterizedTest() +ParameterizedTestAbstract::ParameterizedTestAbstract() + : _iteration(0), + _testAnchor(nullptr), + _lastTest(nullptr), + _nextTestBackup(nullptr) { } -ParameterizedTest::~ParameterizedTest() +ParameterizedTestAbstract::~ParameterizedTestAbstract() { + if (_testAnchor != nullptr) + { + delete _testAnchor; + _testAnchor = nullptr; + } +} + + +size_t ParameterizedTestAbstract::getIteration() +{ + ensureInitialized(); + return _iteration; } -Test* const ParameterizedTest::retrieveCurrentTest() +void ParameterizedTestAbstract::ensureInitialized() +{ + Test* currentTest = retrieveCurrentTest(); + + if (_testAnchor == nullptr) + { + _testAnchor = new TestAnchor("ParameterizedTestAnchor", currentTest->m_details.suiteName, *this); + } + + if (_lastTest != currentTest) + { + _lastTest = currentTest; + _nextTestBackup = currentTest->m_nextTest; + onNewIteration(true); + } +} + + +Test* const ParameterizedTestAbstract::retrieveCurrentTest() { return retrieveTest(CurrentTest::Details()); } -Test* const ParameterizedTest::retrieveTest(TestDetails const * const details) +Test* const ParameterizedTestAbstract::retrieveTest(TestDetails const * const details) { //TODO This workaround is too far complicated, why not simply add pointer to current test in class CurrentTest ? Details2Test::iterator it = _tests.find(details); @@ -44,3 +78,48 @@ Test* const ParameterizedTest::retrieveTest(TestDetails const * const details) throw runtime_error(string("Impossible to retrieve test ") + details->testName); } + + +bool ParameterizedTestAbstract::hasMoreValues(int advance) const +{ + return (_iteration + advance < (int)valuesSize()); +} + + +void ParameterizedTestAbstract::onNewIteration(bool first) +{ + if (first) + { + _iteration = 0; + } + else + { + _iteration++; + } + + if (hasMoreValues(1)) + { + _lastTest->m_nextTest = _testAnchor; + _testAnchor->m_nextTest = _lastTest; + } + else + { + _lastTest->m_nextTest = _nextTestBackup; + _testAnchor->m_nextTest = nullptr; + } + + peekCurrentValue(_iteration); +} + + +ParameterizedTestAbstract::TestAnchor::TestAnchor(char const* testName, char const* suiteName, ParameterizedTestAbstract & pt) + : Test(testName, suiteName), + _pt(pt) +{ +} + + +void ParameterizedTestAbstract::TestAnchor::RunImpl() const +{ + _pt.onNewIteration(false); +} diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h index 05ff9cd..79582a9 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/ParameterizedTest.h @@ -3,6 +3,8 @@ #include #include +#include + #include "Test.h" namespace UnitTest @@ -11,17 +13,72 @@ namespace UnitTest typedef map Details2Test; - class ParameterizedTest + class ParameterizedTestAbstract { public: - ParameterizedTest(); - virtual ~ParameterizedTest(); + ParameterizedTestAbstract(); + virtual ~ParameterizedTestAbstract(); + size_t getIteration(); + + protected: + virtual void peekCurrentValue(size_t iteration) = 0; + virtual size_t valuesSize() const = 0; + void ensureInitialized(); private: + class TestAnchor : public Test + { + public: + TestAnchor(char const* testName, char const* suiteName, ParameterizedTestAbstract & pt); + virtual void RunImpl() const override; + private: + ParameterizedTestAbstract & _pt; + }; + Test* const retrieveCurrentTest(); Test* const retrieveTest(TestDetails const * const details); + + bool hasMoreValues(int advance = 0) const; + void onNewIteration(bool first); + + size_t _iteration; + Test* _lastTest; + Test* _nextTestBackup; + TestAnchor* _testAnchor; Details2Test _tests; }; + + + template + class ParameterizedTest : public ParameterizedTestAbstract + { + public: + ParameterizedTest(vector values) + : _values(values) + { + } + + T_Value operator()() + { + ensureInitialized(); + return _currentValue; + } + + protected: + virtual void peekCurrentValue(size_t iteration) override + { + _currentValue = _values[iteration]; + } + + virtual size_t valuesSize() const override + { + return _values.size(); + } + + private: + vector _values; + T_Value _currentValue; + }; } #endif \ No newline at end of file From e5254539111072c706be24151d8afbc9d5e22b2d Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sun, 15 May 2016 01:01:42 +0200 Subject: [PATCH 022/131] created simple test (not passing yet) --- tests/TestParameterizedTest.cpp | 38 +++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 tests/TestParameterizedTest.cpp diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp new file mode 100644 index 0000000..efe8606 --- /dev/null +++ b/tests/TestParameterizedTest.cpp @@ -0,0 +1,38 @@ +#include "UnitTest++/UnitTest++.h" + +#include +#include "UnitTest++/ParameterizedTest.h" + +using namespace std; +using namespace UnitTest; + +SUITE(ParameterizedTest) +{ + vector voyelleValues; + ParameterizedTest voyelle(voyelleValues); + + struct InitVoyelle + { + InitVoyelle() + { + voyelleValues.push_back("A"); + voyelleValues.push_back("E"); + voyelleValues.push_back("I"); + voyelleValues.push_back("O"); + voyelleValues.push_back("U"); + voyelleValues.push_back("Y"); + } + } InitVoyelleInstance; + + + static string buildVoyellesStringOutput; + TEST(BuildVoyellesString) + { + buildVoyellesStringOutput += voyelle(); + } + + TEST(CheckVoyelle) + { + CHECK_EQUAL("AEIOUY", buildVoyellesStringOutput); + } +} From 9ec57227ea465c829ad81e8205517090e367fb33 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sun, 15 May 2016 01:31:19 +0200 Subject: [PATCH 023/131] fixed test --- tests/TestParameterizedTest.cpp | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index efe8606..e2d445b 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -15,16 +15,20 @@ SUITE(ParameterizedTest) { InitVoyelle() { - voyelleValues.push_back("A"); - voyelleValues.push_back("E"); - voyelleValues.push_back("I"); - voyelleValues.push_back("O"); - voyelleValues.push_back("U"); - voyelleValues.push_back("Y"); + values.push_back("A"); + values.push_back("E"); + values.push_back("I"); + values.push_back("O"); + values.push_back("U"); + values.push_back("Y"); } + vector values; } InitVoyelleInstance; + ParameterizedTest voyelle(InitVoyelleInstance.values); + + static string buildVoyellesStringOutput; TEST(BuildVoyellesString) { From 1f2c10d9a7b587276cad9f604311b73ccfec59c9 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sun, 15 May 2016 01:40:20 +0200 Subject: [PATCH 024/131] prevent for empty values --- UnitTest++/ParameterizedTest.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index df65de9..2605a18 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -91,6 +91,10 @@ void ParameterizedTestAbstract::onNewIteration(bool first) if (first) { _iteration = 0; + if (!hasMoreValues()) + { + throw runtime_error("No values for parameterized test"); + } } else { From 77fef1dfc428342ef78a813141f222589125dd82 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sun, 15 May 2016 01:41:53 +0200 Subject: [PATCH 025/131] bug fix --- UnitTest++/ParameterizedTest.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index 2605a18..75865bb 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -101,7 +101,7 @@ void ParameterizedTestAbstract::onNewIteration(bool first) _iteration++; } - if (hasMoreValues(1)) + if (hasMoreValues()) { _lastTest->m_nextTest = _testAnchor; _testAnchor->m_nextTest = _lastTest; @@ -109,7 +109,8 @@ void ParameterizedTestAbstract::onNewIteration(bool first) else { _lastTest->m_nextTest = _nextTestBackup; - _testAnchor->m_nextTest = nullptr; + _testAnchor->m_nextTest = _nextTestBackup; + return; } peekCurrentValue(_iteration); From e558adac0637c7fd69efc80720301e75dac620e9 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sun, 15 May 2016 01:52:53 +0200 Subject: [PATCH 026/131] fix: nested tests --- UnitTest++/ParameterizedTest.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index 75865bb..9abaad8 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -109,6 +109,8 @@ void ParameterizedTestAbstract::onNewIteration(bool first) else { _lastTest->m_nextTest = _nextTestBackup; + _lastTest = nullptr; + _testAnchor->m_nextTest = _nextTestBackup; return; } From 2102d0585ba02c1eed1918e756d9a27387c2f732 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sun, 15 May 2016 02:05:42 +0200 Subject: [PATCH 027/131] updated macro for use test instead of suite --- UnitTest++/ParameterizedMacros.h | 13 +++---------- tests/TestParameterizedSuite.cpp | 33 ++++++++++++++++---------------- 2 files changed, 19 insertions(+), 27 deletions(-) diff --git a/UnitTest++/ParameterizedMacros.h b/UnitTest++/ParameterizedMacros.h index 5abb32c..56f4ab4 100644 --- a/UnitTest++/ParameterizedMacros.h +++ b/UnitTest++/ParameterizedMacros.h @@ -1,13 +1,13 @@ #ifndef UNITTEST_PARAMETERIZEDMACROS_H #define UNITTEST_PARAMETERIZEDMACROS_H -#include "ParameterizedSuite.h" +#include "ParameterizedTest.h" #define SET_SUITE_PARAMETERS(Type, IterationName, SetUpBody) \ class ParameterizedCreator ## IterationName\ { \ - friend class ParameterizedSuite<## Type>; \ + friend class ParameterizedTest<## Type>; \ public: \ ParameterizedCreator ## IterationName() { create(); } \ vector<## Type> parameters; \ @@ -15,17 +15,10 @@ void create(); \ } parameterizedCreator ## IterationName ## Instance; \ \ - ParameterizedSuite<##Type> ## IterationName(UnitTestSuite::GetSuiteName(), parameterizedCreator ## IterationName ## Instance.parameters); \ + ParameterizedTest<##Type> ## IterationName(parameterizedCreator ## IterationName ## Instance.parameters); \ \ void ParameterizedCreator ## IterationName::create() \ ## SetUpBody -#define PARAMETERIZED_SUITE(Name, Type, IterationName, SetUpBody) \ - SUITE(## Name) \ - { \ - SET_SUITE_PARAMETERS(## Type, ## IterationName, ## SetUpBody) \ - } \ - namespace Suite ## Name - #endif diff --git a/tests/TestParameterizedSuite.cpp b/tests/TestParameterizedSuite.cpp index db906c2..94829e9 100644 --- a/tests/TestParameterizedSuite.cpp +++ b/tests/TestParameterizedSuite.cpp @@ -11,16 +11,17 @@ static int iterationsSum = 0; static int ignoredCounter = 0; static int otherParameterizedSuiteSum = 0; static int singleValueSuiteSum = 0; -static int noValueSuiteSum = 0; -PARAMETERIZED_SUITE(ParameterizedSuiteSimple, int, iVal, { - parameters.push_back(10); - parameters.push_back(20); - parameters.push_back(30); - parameters.push_back(40); -}) +SUITE(ParameterizedSuiteSimpl) { + SET_SUITE_PARAMETERS(int, iVal, { + parameters.push_back(10); + parameters.push_back(20); + parameters.push_back(30); + parameters.push_back(40); + }) + TEST(SimpleSum) { simpleValuesSum += iVal(); @@ -55,14 +56,14 @@ SUITE(ParameterizedSuite) TEST(ValuesAreFollowing) { - CHECK_EQUAL(lastValue + 1, parameterized.getCurrent()); - lastValue = parameterized.getCurrent(); - valuesSum += parameterized.getCurrent(); + CHECK_EQUAL(lastValue + 1, parameterized()); + lastValue = parameterized(); + valuesSum += parameterized(); } TEST(ValueAndIterationAreSync) { - CHECK_EQUAL(parameterized.getIteration() + 1, parameterized.getCurrent()); + CHECK_EQUAL(parameterized.getIteration() + 1, parameterized()); } @@ -73,7 +74,7 @@ SUITE(ParameterizedSuite) TEST(OtherPSIgnoredFromFirstPS) { - otherParameterizedSuiteSum += parameterized2.getCurrent(); + otherParameterizedSuiteSum += parameterized2(); } } @@ -83,10 +84,9 @@ SUITE(ParameterizedSuite_LessValues) SET_SUITE_PARAMETERS(int, parameterizedEmpty, { }) - TEST(WhenNoValue_zeroExecution) + TEST(WhenNoValue_throwsException) { - noValueSuiteSum++; - throw exception("Should not have been reached"); + CHECK_THROW(parameterizedEmpty(), runtime_error); } SET_SUITE_PARAMETERS(int, parameterizedSingle, { @@ -95,7 +95,7 @@ SUITE(ParameterizedSuite_LessValues) TEST(WhenSingleValue_singleExecution) { - singleValueSuiteSum += parameterizedSingle.getCurrent(); + singleValueSuiteSum += parameterizedSingle(); CHECK_EQUAL(2, singleValueSuiteSum); } } @@ -111,6 +111,5 @@ SUITE(ParameterizedSuite_Validation) CHECK_EQUAL(4, iterationsSum); CHECK_EQUAL(3000, otherParameterizedSuiteSum); CHECK_EQUAL(2, singleValueSuiteSum); - CHECK_EQUAL(0, noValueSuiteSum); } } From 817fbc802260de3ee4fe442ce2d6343afb06491a Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sun, 15 May 2016 02:12:37 +0200 Subject: [PATCH 028/131] added callback feature --- UnitTest++/ParameterizedTest.cpp | 6 ++++++ UnitTest++/ParameterizedTest.h | 17 +++++++++++++++-- 2 files changed, 21 insertions(+), 2 deletions(-) diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index 9abaad8..b0c742d 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -33,6 +33,12 @@ size_t ParameterizedTestAbstract::getIteration() } +Test* const ParameterizedTestAbstract::getLastTest() const +{ + return _lastTest; +} + + void ParameterizedTestAbstract::ensureInitialized() { Test* currentTest = retrieveCurrentTest(); diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h index 79582a9..e297a13 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/ParameterizedTest.h @@ -24,6 +24,7 @@ namespace UnitTest virtual void peekCurrentValue(size_t iteration) = 0; virtual size_t valuesSize() const = 0; void ensureInitialized(); + Test* const getLastTest() const; private: class TestAnchor : public Test @@ -53,8 +54,14 @@ namespace UnitTest class ParameterizedTest : public ParameterizedTestAbstract { public: - ParameterizedTest(vector values) - : _values(values) + struct IParameterizedTestListener + { + virtual void onNextIteration(Test* const test, T_Value current, size_t iteration) = 0; + }; + + ParameterizedTest(vector values, IParameterizedTestListener* const listener = nullptr) + : _values(values), + _listener(listener) { } @@ -68,6 +75,11 @@ namespace UnitTest virtual void peekCurrentValue(size_t iteration) override { _currentValue = _values[iteration]; + + if (_listener != nullptr) + { + _listener->onNextIteration(getLastTest(), _currentValue, iteration); + } } virtual size_t valuesSize() const override @@ -78,6 +90,7 @@ namespace UnitTest private: vector _values; T_Value _currentValue; + IParameterizedTestListener* const _listener; }; } From 29bb78535837659272ab4f149cba5386ae2b252f Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sun, 15 May 2016 02:13:15 +0200 Subject: [PATCH 029/131] migrated tests --- tests/TestParameterizedSuite.cpp | 115 ----------------------------- tests/TestParameterizedTest.cpp | 121 +++++++++++++++++++++++++------ 2 files changed, 97 insertions(+), 139 deletions(-) delete mode 100644 tests/TestParameterizedSuite.cpp diff --git a/tests/TestParameterizedSuite.cpp b/tests/TestParameterizedSuite.cpp deleted file mode 100644 index 94829e9..0000000 --- a/tests/TestParameterizedSuite.cpp +++ /dev/null @@ -1,115 +0,0 @@ -#include "UnitTest++/UnitTest++.h" - -#include "UnitTest++/ParameterizedSuite.h" - -using namespace std; -using namespace UnitTest; - -static int simpleValuesSum = 0; -static int valuesSum = 0; -static int iterationsSum = 0; -static int ignoredCounter = 0; -static int otherParameterizedSuiteSum = 0; -static int singleValueSuiteSum = 0; - - -SUITE(ParameterizedSuiteSimpl) -{ - SET_SUITE_PARAMETERS(int, iVal, { - parameters.push_back(10); - parameters.push_back(20); - parameters.push_back(30); - parameters.push_back(40); - }) - - TEST(SimpleSum) - { - simpleValuesSum += iVal(); - } -} - - -SUITE(ParameterizedSuite) -{ - TEST(TestsOfBelowAreIgnored) - { - ignoredCounter++; - CHECK_EQUAL(1, ignoredCounter); - } - - SET_SUITE_PARAMETERS(int, parameterized, { - parameters.push_back(1); - parameters.push_back(2); - parameters.push_back(3); - parameters.push_back(4); - }) - - size_t lastIteration = -1; - int lastValue = 0; - - TEST(IterationsAreFollowing) - { - CHECK_EQUAL(lastIteration + 1, parameterized.getIteration()); - lastIteration = parameterized.getIteration(); - iterationsSum++; - } - - TEST(ValuesAreFollowing) - { - CHECK_EQUAL(lastValue + 1, parameterized()); - lastValue = parameterized(); - valuesSum += parameterized(); - } - - TEST(ValueAndIterationAreSync) - { - CHECK_EQUAL(parameterized.getIteration() + 1, parameterized()); - } - - - SET_SUITE_PARAMETERS(int, parameterized2, { - parameters.push_back(1000); - parameters.push_back(2000); - }) - - TEST(OtherPSIgnoredFromFirstPS) - { - otherParameterizedSuiteSum += parameterized2(); - } -} - - -SUITE(ParameterizedSuite_LessValues) -{ - SET_SUITE_PARAMETERS(int, parameterizedEmpty, { - }) - - TEST(WhenNoValue_throwsException) - { - CHECK_THROW(parameterizedEmpty(), runtime_error); - } - - SET_SUITE_PARAMETERS(int, parameterizedSingle, { - parameters.push_back(2); - }) - - TEST(WhenSingleValue_singleExecution) - { - singleValueSuiteSum += parameterizedSingle(); - CHECK_EQUAL(2, singleValueSuiteSum); - } -} - - -SUITE(ParameterizedSuite_Validation) -{ - TEST(ParameterizedSuiteHasBeenIterated) - { - CHECK_EQUAL(100, simpleValuesSum); - CHECK_EQUAL(1, ignoredCounter); - CHECK_EQUAL(10, valuesSum); - CHECK_EQUAL(4, iterationsSum); - CHECK_EQUAL(3000, otherParameterizedSuiteSum); - CHECK_EQUAL(2, singleValueSuiteSum); - } -} diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index e2d445b..7ee2858 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -1,42 +1,115 @@ #include "UnitTest++/UnitTest++.h" -#include #include "UnitTest++/ParameterizedTest.h" using namespace std; using namespace UnitTest; -SUITE(ParameterizedTest) +static int simpleValuesSum = 0; +static int valuesSum = 0; +static int iterationsSum = 0; +static int ignoredCounter = 0; +static int otherParameterizedSuiteSum = 0; +static int singleValueSuiteSum = 0; + + +SUITE(ParameterizedSuiteSimpl) +{ + SET_SUITE_PARAMETERS(int, iVal, { + parameters.push_back(10); + parameters.push_back(20); + parameters.push_back(30); + parameters.push_back(40); + }) + + TEST(SimpleSum) + { + simpleValuesSum += iVal(); + } +} + + +SUITE(ParameterizedSuite) { - vector voyelleValues; - ParameterizedTest voyelle(voyelleValues); + TEST(TestsOfBelowAreIgnored) + { + ignoredCounter++; + CHECK_EQUAL(1, ignoredCounter); + } + + SET_SUITE_PARAMETERS(int, parameterized, { + parameters.push_back(1); + parameters.push_back(2); + parameters.push_back(3); + parameters.push_back(4); + }) - struct InitVoyelle + size_t lastIteration = -1; + int lastValue = 0; + + TEST(IterationsAreFollowing) { - InitVoyelle() - { - values.push_back("A"); - values.push_back("E"); - values.push_back("I"); - values.push_back("O"); - values.push_back("U"); - values.push_back("Y"); - } - vector values; - } InitVoyelleInstance; + CHECK_EQUAL(lastIteration + 1, parameterized.getIteration()); + lastIteration = parameterized.getIteration(); + iterationsSum++; + } - - ParameterizedTest voyelle(InitVoyelleInstance.values); + TEST(ValuesAreFollowing) + { + CHECK_EQUAL(lastValue + 1, parameterized()); + lastValue = parameterized(); + valuesSum += parameterized(); + } - - static string buildVoyellesStringOutput; - TEST(BuildVoyellesString) + TEST(ValueAndIterationAreSync) { - buildVoyellesStringOutput += voyelle(); + CHECK_EQUAL(parameterized.getIteration() + 1, parameterized()); } - TEST(CheckVoyelle) + + SET_SUITE_PARAMETERS(int, parameterized2, { + parameters.push_back(1000); + parameters.push_back(2000); + }) + + TEST(OtherPSIgnoredFromFirstPS) + { + otherParameterizedSuiteSum += parameterized2(); + } +} + + +SUITE(ParameterizedSuite_LessValues) +{ + SET_SUITE_PARAMETERS(int, parameterizedEmpty, { + }) + + TEST(WhenNoValue_throwsException) + { + CHECK_THROW(parameterizedEmpty(), runtime_error); + } + + SET_SUITE_PARAMETERS(int, parameterizedSingle, { + parameters.push_back(2); + }) + + TEST(WhenSingleValue_singleExecution) + { + singleValueSuiteSum += parameterizedSingle(); + CHECK_EQUAL(2, singleValueSuiteSum); + } +} + + +SUITE(ParameterizedSuite_Validation) +{ + TEST(ParameterizedSuiteHasBeenIterated) { - CHECK_EQUAL("AEIOUY", buildVoyellesStringOutput); + CHECK_EQUAL(100, simpleValuesSum); + CHECK_EQUAL(1, ignoredCounter); + CHECK_EQUAL(10, valuesSum); + CHECK_EQUAL(4, iterationsSum); + CHECK_EQUAL(3000, otherParameterizedSuiteSum); + CHECK_EQUAL(2, singleValueSuiteSum); } } From 1a1e041a92f45fbf24ee13082497ea56ac435e66 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sun, 15 May 2016 02:15:28 +0200 Subject: [PATCH 030/131] totally removed class "ParameterizedSuite" --- UnitTest++/ParameterizedSuite.cpp | 166 ------------------------------ UnitTest++/ParameterizedSuite.h | 115 --------------------- tests/TestParameterizedTest.cpp | 16 +-- 3 files changed, 8 insertions(+), 289 deletions(-) delete mode 100644 UnitTest++/ParameterizedSuite.cpp delete mode 100644 UnitTest++/ParameterizedSuite.h diff --git a/UnitTest++/ParameterizedSuite.cpp b/UnitTest++/ParameterizedSuite.cpp deleted file mode 100644 index fa235e4..0000000 --- a/UnitTest++/ParameterizedSuite.cpp +++ /dev/null @@ -1,166 +0,0 @@ -#include "ParameterizedSuite.h" - -#include -#include -#include "TestList.h" - -using namespace std; -using namespace UnitTest; - - -ParameterizedSuiteAbstract::ParameterizedSuiteAbstract(const string & suiteName) - : _iterationBranched(false), - _iteration(0), - _suiteName(suiteName), - _testName(suiteName + "ParameterizedSuite_anchor"), - _firstOuterTest(nullptr), - _lastOfSuite(nullptr), - _testAnchor(nullptr) // Important, even if defined just above (please read comment) -{ - // WARNING: this is pointer because of memory problems with suiteName/testName.c_str(), - // the constructor does not initialize them in the right order - _testAnchor = new TestAnchor(*this); -} - - -ParameterizedSuiteAbstract::~ParameterizedSuiteAbstract() -{ - if (_testAnchor != nullptr) - { - delete _testAnchor; - _testAnchor = nullptr; - } -} - - -size_t ParameterizedSuiteAbstract::getIteration() const -{ - return _iteration; -} - - -void ParameterizedSuiteAbstract::ensureInitialized() -{ - tryPeekFirstValue(); - tryBranchUniqueTest(); -} - - -bool ParameterizedSuiteAbstract::hasMoreValues(int advance) const -{ - return (_iteration + advance < (int)valuesSize()); -} - - -bool ParameterizedSuiteAbstract::tryPeekFirstValue() -{ - if (_iterationBranched) - { - return false; - } - - peekCurrentValue(); - return false; -} - - -bool ParameterizedSuiteAbstract::tryBranchUniqueTest() -{ - if (_iterationBranched) - { - return false; - } - - //TODO find a way to allow single parameterized test execution - static bool messageDisplayed = false; - if (!messageDisplayed) - { - messageDisplayed = true; - cout << "WARNING: test of parameterized suite " << _suiteName - << " can not be executed alone, test will be executed with first value only." << endl; - } - - return true; -} - - -bool ParameterizedSuiteAbstract::branchTestsForIteration() -{ - if (_iterationBranched) - { - return false; - } - - for (Test* iTest = _testAnchor; iTest != nullptr; iTest = iTest->m_nextTest) - { - bool inSameSuite = (strcmp(iTest->m_details.suiteName, _suiteName.c_str()) == 0); - bool ownAnchor = (iTest == _testAnchor); - bool isOtherParameterizedSuite = (iTest != _testAnchor && dynamic_cast(iTest) != nullptr); - if (!inSameSuite || isOtherParameterizedSuite) - { - _firstOuterTest = iTest; - break; - } - _lastOfSuite = iTest; - } - - _lastOfSuite->m_nextTest = _testAnchor; - - _iterationBranched = true; - return true; -} - - -bool ParameterizedSuiteAbstract::unbranchIterationIfLast() -{ - if (!_iterationBranched) - { - return false; - } - - if (hasMoreValues(1)) - { - return false; - } - - _lastOfSuite->m_nextTest = _firstOuterTest; - return true; -} - - -void ParameterizedSuiteAbstract::onNewIteration() -{ - if (_iterationBranched) - { - _iteration++; - } - - bool justBranched = branchTestsForIteration(); - bool justUnbranched = unbranchIterationIfLast(); - - if (justBranched && justUnbranched) - { - // If no values to test, skip all tests - if (valuesSize() == 0) - { - _testAnchor->m_nextTest = _firstOuterTest; - return; - } - } - - peekCurrentValue(); -} - - -ParameterizedSuiteAbstract::TestAnchor::TestAnchor(ParameterizedSuiteAbstract & parameterized) - : Test(parameterized._testName.c_str(), parameterized._suiteName.c_str()), - _parameterized(parameterized) -{ - Test::GetTestList().Add(this); -} - - -void ParameterizedSuiteAbstract::TestAnchor::RunImpl() const -{ - _parameterized.onNewIteration(); -} diff --git a/UnitTest++/ParameterizedSuite.h b/UnitTest++/ParameterizedSuite.h deleted file mode 100644 index 7a8e9a5..0000000 --- a/UnitTest++/ParameterizedSuite.h +++ /dev/null @@ -1,115 +0,0 @@ -#ifndef UNITTEST_PARAMETERIZEDSUITE_H -#define UNITTEST_PARAMETERIZEDSUITE_H - -#include -#include "Test.h" - -namespace UnitTest -{ - using namespace std; - - class ParameterizedSuiteAbstract - { - public: - ParameterizedSuiteAbstract(const string & suiteName); - virtual ~ParameterizedSuiteAbstract(); - size_t getIteration() const; - - protected: - virtual void peekCurrentValue() = 0; - virtual size_t valuesSize() const = 0; - void ensureInitialized(); - bool hasMoreValues(int advance = 0) const; - - private: - class TestAnchor : public Test - { - public: - TestAnchor(ParameterizedSuiteAbstract & parameterized); - virtual void RunImpl() const override; - private: - ParameterizedSuiteAbstract & _parameterized; - }; - - bool tryPeekFirstValue(); - bool tryBranchUniqueTest(); - bool branchTestsForIteration(); - bool unbranchIterationIfLast(); - void onNewIteration(); - - volatile bool _iterationBranched; - size_t _iteration; - const string _suiteName; - const string _testName; - Test* _firstOuterTest; - Test* _lastOfSuite; - TestAnchor* _testAnchor; - }; - - - /** - * @brief Repeat full test suite and gives different values, like a for(:) loop - * TODO: iteration should be over tests instead over suite - * - * @code - * SUITE(Testing) { - * vector suitesParams { 1, 5, 10 }; - * ParameterizedSuite parameters(UnitTestSuite::GetSuiteName(), suitesParams); - * TEST(Show) - * { - * cout << parameters.getCurrent() << endl; - * } - * } - * @endcode - */ - template - class ParameterizedSuite : public ParameterizedSuiteAbstract - { - public: - struct ISuiteIterationListener - { - virtual void onNextIteration(T_Value current, size_t iteration) = 0; - }; - - ParameterizedSuite(const string & suiteName, vector values, ISuiteIterationListener* const suiteIterationListener = nullptr) - : ParameterizedSuiteAbstract(suiteName), - _values(values), - _suiteIterationListener(suiteIterationListener) - { - } - - T_Value getCurrent() - { - ensureInitialized(); - return _currentValue; - } - - T_Value operator()() - { - return getCurrent(); - } - - protected: - - virtual void peekCurrentValue() override - { - _currentValue = _values[getIteration()]; - if (_suiteIterationListener != nullptr) - { - _suiteIterationListener->onNextIteration(_currentValue, getIteration()); - } - } - - virtual size_t valuesSize() const override - { - return _values.size(); - } - - private: - ISuiteIterationListener* const _suiteIterationListener; - vector _values; - T_Value _currentValue; - }; -} - -#endif \ No newline at end of file diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index 7ee2858..59c57fd 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -9,11 +9,11 @@ static int simpleValuesSum = 0; static int valuesSum = 0; static int iterationsSum = 0; static int ignoredCounter = 0; -static int otherParameterizedSuiteSum = 0; +static int otherParameterizedTestSum = 0; static int singleValueSuiteSum = 0; -SUITE(ParameterizedSuiteSimpl) +SUITE(ParameterizedTestSimpl) { SET_SUITE_PARAMETERS(int, iVal, { parameters.push_back(10); @@ -29,7 +29,7 @@ SUITE(ParameterizedSuiteSimpl) } -SUITE(ParameterizedSuite) +SUITE(ParameterizedTest) { TEST(TestsOfBelowAreIgnored) { @@ -74,12 +74,12 @@ SUITE(ParameterizedSuite) TEST(OtherPSIgnoredFromFirstPS) { - otherParameterizedSuiteSum += parameterized2(); + otherParameterizedTestSum += parameterized2(); } } -SUITE(ParameterizedSuite_LessValues) +SUITE(ParameterizedTest_LessValues) { SET_SUITE_PARAMETERS(int, parameterizedEmpty, { }) @@ -101,15 +101,15 @@ SUITE(ParameterizedSuite_LessValues) } -SUITE(ParameterizedSuite_Validation) +SUITE(ParameterizedTest_Validation) { - TEST(ParameterizedSuiteHasBeenIterated) + TEST(ParameterizedTest_HasBeenIterated) { CHECK_EQUAL(100, simpleValuesSum); CHECK_EQUAL(1, ignoredCounter); CHECK_EQUAL(10, valuesSum); CHECK_EQUAL(4, iterationsSum); - CHECK_EQUAL(3000, otherParameterizedSuiteSum); + CHECK_EQUAL(3000, otherParameterizedTestSum); CHECK_EQUAL(2, singleValueSuiteSum); } } From 2bfb49d05bd0779617b36df3ffd4d1c936f95d27 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sun, 15 May 2016 11:36:47 +0200 Subject: [PATCH 031/131] improved tests --- tests/TestParameterizedTest.cpp | 130 ++++++++++++++------------------ 1 file changed, 56 insertions(+), 74 deletions(-) diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index 59c57fd..1019826 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -1,115 +1,97 @@ #include "UnitTest++/UnitTest++.h" +#include #include "UnitTest++/ParameterizedTest.h" using namespace std; using namespace UnitTest; -static int simpleValuesSum = 0; -static int valuesSum = 0; -static int iterationsSum = 0; -static int ignoredCounter = 0; -static int otherParameterizedTestSum = 0; -static int singleValueSuiteSum = 0; - -SUITE(ParameterizedTestSimpl) +SUITE(ParameterizedTestSimple) { - SET_SUITE_PARAMETERS(int, iVal, { - parameters.push_back(10); - parameters.push_back(20); - parameters.push_back(30); - parameters.push_back(40); - }) - - TEST(SimpleSum) + string simpleVowels; + int simpleVowelsHitCount = 0; + + SET_SUITE_PARAMETERS(string, vowel, { + parameters.push_back("A"); + parameters.push_back("E"); + parameters.push_back("I"); + parameters.push_back("O"); + parameters.push_back("U"); + parameters.push_back("Y"); + }); + + TEST(SimpleVoyelConcat) { - simpleValuesSum += iVal(); + simpleVowels += vowel(); + simpleVowelsHitCount++; } -} - -SUITE(ParameterizedTest) -{ - TEST(TestsOfBelowAreIgnored) + TEST(SimpleVoyelConcat_Verify) { - ignoredCounter++; - CHECK_EQUAL(1, ignoredCounter); + CHECK_EQUAL(parameterizedCreatorvowelInstance.parameters.size(), simpleVowelsHitCount); + CHECK_EQUAL("AEIOUY", simpleVowels); } - SET_SUITE_PARAMETERS(int, parameterized, { - parameters.push_back(1); - parameters.push_back(2); - parameters.push_back(3); - parameters.push_back(4); - }) - - size_t lastIteration = -1; - int lastValue = 0; + ////////// - TEST(IterationsAreFollowing) + int hitCountNonParameterized = 0; + TEST(NonParameterizedExecutedOnce) { - CHECK_EQUAL(lastIteration + 1, parameterized.getIteration()); - lastIteration = parameterized.getIteration(); - iterationsSum++; + hitCountNonParameterized++; + CHECK_EQUAL(1, hitCountNonParameterized); } - TEST(ValuesAreFollowing) - { - CHECK_EQUAL(lastValue + 1, parameterized()); - lastValue = parameterized(); - valuesSum += parameterized(); - } - - TEST(ValueAndIterationAreSync) - { - CHECK_EQUAL(parameterized.getIteration() + 1, parameterized()); - } + ////////// + bool enteredEmpty = false; + int hitCountEmpty = 0; - SET_SUITE_PARAMETERS(int, parameterized2, { - parameters.push_back(1000); - parameters.push_back(2000); - }) + SET_SUITE_PARAMETERS(int, parameterizedEmpty, { + }); - TEST(OtherPSIgnoredFromFirstPS) + TEST(WhenNoParameters_throwsException) { - otherParameterizedTestSum += parameterized2(); + enteredEmpty = true; + try + { + parameterizedEmpty(); + } + catch(runtime_error e) // Expected case + { + CHECK_EQUAL("No values for parameterized test", e.what()); + return; + } + + CHECK(false); + hitCountEmpty++; } -} - - -SUITE(ParameterizedTest_LessValues) -{ - SET_SUITE_PARAMETERS(int, parameterizedEmpty, { - }) - TEST(WhenNoValue_throwsException) + TEST(WhenNoParameters_throwsException_Verify) { - CHECK_THROW(parameterizedEmpty(), runtime_error); + CHECK_EQUAL(0, hitCountEmpty); + CHECK(enteredEmpty); } + ////////// + + int hitCountSingle = 0; + static int singleValueSuiteSum = 0; + SET_SUITE_PARAMETERS(int, parameterizedSingle, { parameters.push_back(2); - }) + }); TEST(WhenSingleValue_singleExecution) { singleValueSuiteSum += parameterizedSingle(); CHECK_EQUAL(2, singleValueSuiteSum); + hitCountSingle++; } -} - -SUITE(ParameterizedTest_Validation) -{ - TEST(ParameterizedTest_HasBeenIterated) + TEST(WhenSingleValue_singleExecution_Verification) { - CHECK_EQUAL(100, simpleValuesSum); - CHECK_EQUAL(1, ignoredCounter); - CHECK_EQUAL(10, valuesSum); - CHECK_EQUAL(4, iterationsSum); - CHECK_EQUAL(3000, otherParameterizedTestSum); CHECK_EQUAL(2, singleValueSuiteSum); + CHECK_EQUAL(1, hitCountSingle); } } From 6233fbc117dbf1bac2f7676c7cb87b92d6485c78 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sun, 15 May 2016 13:29:38 +0200 Subject: [PATCH 032/131] reuse & nested test --- tests/TestParameterizedTest.cpp | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index 1019826..5bca9eb 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -94,4 +94,36 @@ SUITE(ParameterizedTestSimple) CHECK_EQUAL(2, singleValueSuiteSum); CHECK_EQUAL(1, hitCountSingle); } + + ////////// + + string voyelReuse; + TEST(ReusePreviousParameterized) + { + voyelReuse += vowel() + "-"; // Add a separator for + } + + TEST(ReusePreviousParameterized_Verify) + { + CHECK_EQUAL("A-E-I-O-U-Y-", voyelReuse); + } + + ////////// + + SET_SUITE_PARAMETERS(string, xyz, { + parameters.push_back("X"); + parameters.push_back("Y"); + parameters.push_back("Z"); + }); + + string nestedParameters; + TEST(NestedParameters) + { + nestedParameters += vowel() + xyz(); // Add a separator for + } + + TEST(NestedParameters_Verify) + { + CHECK_EQUAL("AXEXIXOXUXYXAYEYIYOYUYYYAZEZIZOZUZYZ", nestedParameters); + } } From 6c565da6d004305f6261a776eccbd85bb12293b4 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 17 May 2016 11:39:07 +0200 Subject: [PATCH 033/131] created class TestListNode --- UnitTest++/TestList.cpp | 6 ++++++ UnitTest++/TestList.h | 8 ++++++++ 2 files changed, 14 insertions(+) diff --git a/UnitTest++/TestList.cpp b/UnitTest++/TestList.cpp index a2bc4b7..e598330 100644 --- a/UnitTest++/TestList.cpp +++ b/UnitTest++/TestList.cpp @@ -5,6 +5,12 @@ namespace UnitTest { + TestListNode::TestListNode(Test* test) + : m_test(test), + m_next(0) + { + } + TestList::TestList() : m_head(0) , m_tail(0) diff --git a/UnitTest++/TestList.h b/UnitTest++/TestList.h index d52ab51..a366c19 100644 --- a/UnitTest++/TestList.h +++ b/UnitTest++/TestList.h @@ -7,6 +7,14 @@ namespace UnitTest { class Test; + class UNITTEST_LINKAGE TestListNode + { + public: + TestListNode(Test* test); + Test* m_test; + TestListNode* m_next; + }; + class UNITTEST_LINKAGE TestList { public: From fe90cf015d736f83bea6180fef4b0bdb76601ee7 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 17 May 2016 11:40:06 +0200 Subject: [PATCH 034/131] moved usage Test::m_nextTest -> TestListNode::m_next --- UnitTest++/Test.cpp | 1 - UnitTest++/Test.h | 1 - UnitTest++/TestList.cpp | 16 ++++++++++------ UnitTest++/TestList.h | 8 ++++---- UnitTest++/TestRunner.h | 8 ++++---- 5 files changed, 18 insertions(+), 16 deletions(-) diff --git a/UnitTest++/Test.cpp b/UnitTest++/Test.cpp index 82ed710..2258899 100644 --- a/UnitTest++/Test.cpp +++ b/UnitTest++/Test.cpp @@ -20,7 +20,6 @@ namespace UnitTest { Test::Test(char const* testName, char const* suiteName, char const* filename, int lineNumber) : m_details(testName, suiteName, filename, lineNumber) - , m_nextTest(0) , m_isMockTest(false) {} diff --git a/UnitTest++/Test.h b/UnitTest++/Test.h index beb0769..5250452 100644 --- a/UnitTest++/Test.h +++ b/UnitTest++/Test.h @@ -16,7 +16,6 @@ namespace UnitTest { void Run(); TestDetails const m_details; - Test* m_nextTest; mutable bool m_isMockTest; diff --git a/UnitTest++/TestList.cpp b/UnitTest++/TestList.cpp index e598330..75946f9 100644 --- a/UnitTest++/TestList.cpp +++ b/UnitTest++/TestList.cpp @@ -16,22 +16,26 @@ namespace UnitTest { , m_tail(0) {} - void TestList::Add(Test* test) + TestListNode* TestList::Add(Test* test) { + TestListNode* node = 0; if (m_tail == 0) { assert(m_head == 0); - m_head = test; - m_tail = test; + node = new TestListNode(test); + m_head = node; + m_tail = node; } else { - m_tail->m_nextTest = test; - m_tail = test; + node = new TestListNode(test); + m_tail->m_next = node; + m_tail = node; } + return node; } - Test* TestList::GetHead() const + TestListNode* TestList::GetHead() const { return m_head; } diff --git a/UnitTest++/TestList.h b/UnitTest++/TestList.h index a366c19..21c0dab 100644 --- a/UnitTest++/TestList.h +++ b/UnitTest++/TestList.h @@ -19,13 +19,13 @@ namespace UnitTest { { public: TestList(); - void Add (Test* test); + TestListNode* Add(Test* test); - Test* GetHead() const; + TestListNode* GetHead() const; private: - Test* m_head; - Test* m_tail; + TestListNode* m_head; + TestListNode* m_tail; }; diff --git a/UnitTest++/TestRunner.h b/UnitTest++/TestRunner.h index 914249a..51ebefd 100644 --- a/UnitTest++/TestRunner.h +++ b/UnitTest++/TestRunner.h @@ -31,14 +31,14 @@ namespace UnitTest { int RunTestsIf(TestList const& list, char const* suiteName, const Predicate& predicate, int maxTestTimeInMs) const { - Test* curTest = list.GetHead(); + TestListNode* curTest = list.GetHead(); while (curTest != 0) { - if (IsTestInSuite(curTest, suiteName) && predicate(curTest)) - RunTest(m_result, curTest, maxTestTimeInMs); + if (IsTestInSuite(curTest->m_test, suiteName) && predicate(curTest->m_test)) + RunTest(m_result, curTest->m_test, maxTestTimeInMs); - curTest = curTest->m_nextTest; + curTest = curTest->m_next; } return Finish(); From a6eb17fb486886784a6d5731dd98e45937ef26ec Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 17 May 2016 11:40:14 +0200 Subject: [PATCH 035/131] updated tests --- tests/TestTestList.cpp | 18 +++++++++--------- tests/TestTestMacros.cpp | 18 +++++++++--------- 2 files changed, 18 insertions(+), 18 deletions(-) diff --git a/tests/TestTestList.cpp b/tests/TestTestList.cpp index 4a0bdcb..7b4faad 100644 --- a/tests/TestTestList.cpp +++ b/tests/TestTestList.cpp @@ -18,8 +18,8 @@ namespace { TestList list; list.Add(&test); - CHECK(list.GetHead() == &test); - CHECK(test.m_nextTest == 0); + CHECK(list.GetHead()->m_test == &test); + CHECK(list.GetHead()->m_next == 0); } TEST(AddingSecondTestAddsItToEndOfList) @@ -28,12 +28,12 @@ namespace { Test test2("test2"); TestList list; - list.Add(&test1); - list.Add(&test2); + TestListNode* test1Node = list.Add(&test1); + TestListNode* test2Node = list.Add(&test2); - CHECK(list.GetHead() == &test1); - CHECK(test1.m_nextTest == &test2); - CHECK(test2.m_nextTest == 0); + CHECK(list.GetHead()->m_test == &test1); + CHECK(test1Node->m_next->m_test == &test2); + CHECK(test2Node->m_next == 0); } TEST(ListAdderAddsTestToList) @@ -43,8 +43,8 @@ namespace { Test test(""); ListAdder adder(list, &test); - CHECK(list.GetHead() == &test); - CHECK(test.m_nextTest == 0); + CHECK(list.GetHead()->m_test == &test); + CHECK(list.GetHead()->m_next == 0); } } diff --git a/tests/TestTestMacros.cpp b/tests/TestTestMacros.cpp index 4a13316..34fa5ed 100644 --- a/tests/TestTestMacros.cpp +++ b/tests/TestTestMacros.cpp @@ -52,7 +52,7 @@ namespace { TEST (TestsAreAddedToTheListThroughMacro) { CHECK(list1.GetHead() != 0); - CHECK(list1.GetHead()->m_nextTest == 0); + CHECK(list1.GetHead()->m_next == 0); } #ifndef UNITTEST_NO_EXCEPTIONS @@ -78,7 +78,7 @@ namespace { TestResults result(&reporter); { ScopedCurrentTest scopedResults(result); - list2.GetHead()->Run(); + list2.GetHead()->m_test->Run(); } CHECK(strstr(reporter.lastFailedMessage, "xception")); @@ -119,8 +119,8 @@ namespace { TEST(TestAddedWithTEST_EXMacroGetsDefaultSuite) { CHECK(macroTestList1.GetHead() != NULL); - CHECK_EQUAL ("MacroTestHelper1", macroTestList1.GetHead()->m_details.testName); - CHECK_EQUAL ("DefaultSuite", macroTestList1.GetHead()->m_details.suiteName); + CHECK_EQUAL ("MacroTestHelper1", macroTestList1.GetHead()->m_test->m_details.testName); + CHECK_EQUAL ("DefaultSuite", macroTestList1.GetHead()->m_test->m_details.suiteName); } TestList macroTestList2; @@ -130,8 +130,8 @@ namespace { TEST(TestAddedWithTEST_FIXTURE_EXMacroGetsDefaultSuite) { CHECK(macroTestList2.GetHead() != NULL); - CHECK_EQUAL ("MacroTestHelper2", macroTestList2.GetHead()->m_details.testName); - CHECK_EQUAL ("DefaultSuite", macroTestList2.GetHead()->m_details.suiteName); + CHECK_EQUAL ("MacroTestHelper2", macroTestList2.GetHead()->m_test->m_details.testName); + CHECK_EQUAL ("DefaultSuite", macroTestList2.GetHead()->m_test->m_details.suiteName); } #ifndef UNITTEST_NO_EXCEPTIONS @@ -154,7 +154,7 @@ namespace { TestResults result(&reporter); { ScopedCurrentTest scopedResult(result); - throwingFixtureTestList1.GetHead()->Run(); + throwingFixtureTestList1.GetHead()->m_test->Run(); } int const failureCount = result.GetFailedTestCount(); @@ -181,7 +181,7 @@ namespace { TestResults result(&reporter); { ScopedCurrentTest scopedResult(result); - throwingFixtureTestList2.GetHead()->Run(); + throwingFixtureTestList2.GetHead()->m_test->Run(); } int const failureCount = result.GetFailedTestCount(); @@ -209,7 +209,7 @@ namespace { TestResults result(&reporter); { ScopedCurrentTest scopedResults(result); - ctorAssertFixtureTestList.GetHead()->Run(); + ctorAssertFixtureTestList.GetHead()->m_test->Run(); } const int failureCount = result.GetFailedTestCount(); From d584ccfd22ddb690fc915a9520e069d15151db60 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 17 May 2016 13:55:17 +0200 Subject: [PATCH 036/131] created SuitePredicate --- UnitTest++/SuitePredicate.cpp | 58 +++++++++++++++++++++++++++++++++++ UnitTest++/SuitePredicate.h | 32 +++++++++++++++++++ 2 files changed, 90 insertions(+) create mode 100644 UnitTest++/SuitePredicate.cpp create mode 100644 UnitTest++/SuitePredicate.h diff --git a/UnitTest++/SuitePredicate.cpp b/UnitTest++/SuitePredicate.cpp new file mode 100644 index 0000000..6ad99f8 --- /dev/null +++ b/UnitTest++/SuitePredicate.cpp @@ -0,0 +1,58 @@ +#include "SuitePredicate.h" + +using namespace std; +using namespace UnitTest; + + +SuitePredicate::SuitePredicate() +{ +} + + +SuitePredicate::~SuitePredicate() +{ +} + + +void SuitePredicate::addSuite(const string & suiteName) +{ + _suiteNames.push_back(suiteName); +} + + +void SuitePredicate::addTest(const string & testName) +{ + _testNames.push_back(testName); +} + + +bool SuitePredicate::operator()(Test const * const test) const +{ + 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 new file mode 100644 index 0000000..8df7647 --- /dev/null +++ b/UnitTest++/SuitePredicate.h @@ -0,0 +1,32 @@ +#ifndef UNITTEST_SUITEPREDICATE_H +#define UNITTEST_SUITEPREDICATE_H + +#include +#include +#include "Test.h" + +namespace UnitTest +{ + using namespace std; + + class SuitePredicate + { + public: + SuitePredicate(); + virtual ~SuitePredicate(); + + void addSuite(const string & suiteName); + void addTest(const string & testName); + + bool operator()(Test const * const test) const; + + private: + bool mustExecuteSuite(Test const * const test) const; + bool mustExecuteTest(Test const * const test) const; + + vector _suiteNames; + vector _testNames; + }; +} + +#endif \ No newline at end of file From ead64fc6a32007019599bfb8a8df27298c454329 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 17 May 2016 13:56:55 +0200 Subject: [PATCH 037/131] created RunTestsCmd for easyly run test(s) or suite(s) (use command "--suite") --- UnitTest++/TestRunner.cpp | 32 ++++++++++++++++++++++++++++++++ UnitTest++/TestRunner.h | 1 + 2 files changed, 33 insertions(+) diff --git a/UnitTest++/TestRunner.cpp b/UnitTest++/TestRunner.cpp index 8e0581d..f416659 100644 --- a/UnitTest++/TestRunner.cpp +++ b/UnitTest++/TestRunner.cpp @@ -4,6 +4,7 @@ #include "TestReporterStdout.h" #include "TimeHelpers.h" #include "MemoryOutStream.h" +#include "SuitePredicate.h" #include @@ -17,6 +18,37 @@ namespace UnitTest { return runner.RunTestsIf(Test::GetTestList(), NULL, True(), 0); } + int RunTestsCmd(int argc, char**argv, char const* suiteArgument) + { + if (argc <= 1) + { + return UnitTest::RunAllTests(); + } + + //if first arg is "--suite", we search for suite names instead of test names + const bool suite = strcmp(suiteArgument, argv[1]) == 0; + + SuitePredicate predicate; + int from = (suite) ? 2 : 1; + for (int i = from; i < argc; ++i) + { + string name = argv[i]; + if (suite) + { + predicate.addSuite(name); + } + else + { + predicate.addTest(name); + } + } + + //run selected test(s) only + TestReporterStdout reporter; + TestRunner runner(reporter); + + return runner.RunTestsIf(Test::GetTestList(), 0, predicate, 0); + } TestRunner::TestRunner(TestReporter& reporter) : m_reporter(&reporter) diff --git a/UnitTest++/TestRunner.h b/UnitTest++/TestRunner.h index 51ebefd..08780bc 100644 --- a/UnitTest++/TestRunner.h +++ b/UnitTest++/TestRunner.h @@ -12,6 +12,7 @@ namespace UnitTest { class Timer; UNITTEST_LINKAGE int RunAllTests(); + UNITTEST_LINKAGE int RunTestsCmd(int argc, char**argv, char const* suiteArgument = "--suite"); struct True { From dabb1d28ff202615021e446639ccc0ec999872c0 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 17 May 2016 13:57:22 +0200 Subject: [PATCH 038/131] applyed to main --- tests/Main.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/Main.cpp b/tests/Main.cpp index 4a0f402..3a629a4 100644 --- a/tests/Main.cpp +++ b/tests/Main.cpp @@ -1,6 +1,6 @@ #include "UnitTest++/UnitTestPP.h" -int main(int, char const *[]) +int main(int argc, char**argv) { - return UnitTest::RunAllTests(); + return UnitTest::RunTestsCmd(argc, argv); } From cb852cb53fdf57525cb224ac99229458fbbdacb2 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 17 May 2016 14:18:52 +0200 Subject: [PATCH 039/131] use char* instead of string (for dll export) --- UnitTest++/SuitePredicate.cpp | 4 ++-- UnitTest++/SuitePredicate.h | 6 +++--- UnitTest++/TestRunner.cpp | 5 ++--- 3 files changed, 7 insertions(+), 8 deletions(-) diff --git a/UnitTest++/SuitePredicate.cpp b/UnitTest++/SuitePredicate.cpp index 6ad99f8..e2876d8 100644 --- a/UnitTest++/SuitePredicate.cpp +++ b/UnitTest++/SuitePredicate.cpp @@ -14,13 +14,13 @@ SuitePredicate::~SuitePredicate() } -void SuitePredicate::addSuite(const string & suiteName) +void SuitePredicate::addSuite(char const* suiteName) { _suiteNames.push_back(suiteName); } -void SuitePredicate::addTest(const string & testName) +void SuitePredicate::addTest(char const* testName) { _testNames.push_back(testName); } diff --git a/UnitTest++/SuitePredicate.h b/UnitTest++/SuitePredicate.h index 8df7647..c9cf8c7 100644 --- a/UnitTest++/SuitePredicate.h +++ b/UnitTest++/SuitePredicate.h @@ -9,14 +9,14 @@ namespace UnitTest { using namespace std; - class SuitePredicate + class UNITTEST_LINKAGE SuitePredicate { public: SuitePredicate(); virtual ~SuitePredicate(); - void addSuite(const string & suiteName); - void addTest(const string & testName); + void addSuite(char const* suiteName); + void addTest(char const* testName); bool operator()(Test const * const test) const; diff --git a/UnitTest++/TestRunner.cpp b/UnitTest++/TestRunner.cpp index f416659..1fe598e 100644 --- a/UnitTest++/TestRunner.cpp +++ b/UnitTest++/TestRunner.cpp @@ -32,14 +32,13 @@ namespace UnitTest { int from = (suite) ? 2 : 1; for (int i = from; i < argc; ++i) { - string name = argv[i]; if (suite) { - predicate.addSuite(name); + predicate.addSuite(argv[i]); } else { - predicate.addTest(name); + predicate.addTest(argv[i]); } } From bbdf7c739287f3927b7f5e83d2fb2ac226a29067 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 17 May 2016 14:56:03 +0200 Subject: [PATCH 040/131] updated for using new TestListNode --- UnitTest++/ParameterizedTest.cpp | 39 ++++++++++++++++++++------------ UnitTest++/ParameterizedTest.h | 12 ++++++---- 2 files changed, 31 insertions(+), 20 deletions(-) diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index b0c742d..fa28017 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -1,6 +1,5 @@ #include "ParameterizedTest.h" -#include "TestList.h" #include "CurrentTest.h" using namespace std; @@ -10,6 +9,7 @@ using namespace UnitTest; ParameterizedTestAbstract::ParameterizedTestAbstract() : _iteration(0), _testAnchor(nullptr), + _testAnchorNode(nullptr), _lastTest(nullptr), _nextTestBackup(nullptr) { @@ -23,6 +23,11 @@ ParameterizedTestAbstract::~ParameterizedTestAbstract() delete _testAnchor; _testAnchor = nullptr; } + if (_testAnchorNode != nullptr) + { + delete _testAnchorNode; + _testAnchorNode = nullptr; + } } @@ -35,35 +40,39 @@ size_t ParameterizedTestAbstract::getIteration() Test* const ParameterizedTestAbstract::getLastTest() const { - return _lastTest; + return _lastTest->m_test; } void ParameterizedTestAbstract::ensureInitialized() { - Test* currentTest = retrieveCurrentTest(); + TestListNode* currentTest = retrieveCurrentTest(); if (_testAnchor == nullptr) { - _testAnchor = new TestAnchor("ParameterizedTestAnchor", currentTest->m_details.suiteName, *this); + _testAnchor = new TestAnchor("ParameterizedTestAnchor", currentTest->m_test->m_details.suiteName, *this); + } + if (_testAnchorNode == nullptr) + { + _testAnchorNode = new TestListNode(_testAnchor); } if (_lastTest != currentTest) { _lastTest = currentTest; - _nextTestBackup = currentTest->m_nextTest; + _nextTestBackup = currentTest->m_next; onNewIteration(true); } } -Test* const ParameterizedTestAbstract::retrieveCurrentTest() +TestListNode* const ParameterizedTestAbstract::retrieveCurrentTest() { return retrieveTest(CurrentTest::Details()); } -Test* const ParameterizedTestAbstract::retrieveTest(TestDetails const * const details) +TestListNode* const ParameterizedTestAbstract::retrieveTest(TestDetails const * const details) { //TODO This workaround is too far complicated, why not simply add pointer to current test in class CurrentTest ? Details2Test::iterator it = _tests.find(details); @@ -73,12 +82,12 @@ Test* const ParameterizedTestAbstract::retrieveTest(TestDetails const * const de return it->second; } - for(Test* iTest = Test::GetTestList().GetHead() ; iTest!= nullptr ; iTest=iTest->m_nextTest) + for (TestListNode* iNode = Test::GetTestList().GetHead(); iNode != nullptr; iNode = iNode->m_next) { - if (&iTest->m_details == details) + if (&iNode->m_test->m_details == details) { - _tests[details] = iTest; - return iTest; + _tests[details] = iNode; + return iNode; } } @@ -109,15 +118,15 @@ void ParameterizedTestAbstract::onNewIteration(bool first) if (hasMoreValues()) { - _lastTest->m_nextTest = _testAnchor; - _testAnchor->m_nextTest = _lastTest; + _lastTest->m_next = _testAnchorNode; + _testAnchorNode->m_next = _lastTest; } else { - _lastTest->m_nextTest = _nextTestBackup; + _lastTest->m_next= _nextTestBackup; _lastTest = nullptr; - _testAnchor->m_nextTest = _nextTestBackup; + _testAnchorNode->m_next = _nextTestBackup; return; } diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h index e297a13..238e6dc 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/ParameterizedTest.h @@ -6,12 +6,13 @@ #include #include "Test.h" +#include "TestList.h" namespace UnitTest { using namespace std; - typedef map Details2Test; + typedef map Details2Test; class ParameterizedTestAbstract { @@ -36,15 +37,16 @@ namespace UnitTest ParameterizedTestAbstract & _pt; }; - Test* const retrieveCurrentTest(); - Test* const retrieveTest(TestDetails const * const details); + TestListNode* const retrieveCurrentTest(); + TestListNode* const retrieveTest(TestDetails const * const details); bool hasMoreValues(int advance = 0) const; void onNewIteration(bool first); size_t _iteration; - Test* _lastTest; - Test* _nextTestBackup; + TestListNode* _lastTest; + TestListNode* _nextTestBackup; + TestListNode* _testAnchorNode; TestAnchor* _testAnchor; Details2Test _tests; }; From d49ddee296f023c4cfcc0856e268775eaa39e821 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 17 May 2016 15:07:03 +0200 Subject: [PATCH 041/131] Create anchor with exactly same details than original test for ensure it will pass all test filters the same way as original --- UnitTest++/ParameterizedTest.cpp | 27 ++++++++++++++++++--------- UnitTest++/ParameterizedTest.h | 1 + 2 files changed, 19 insertions(+), 9 deletions(-) diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index fa28017..c66394a 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -48,15 +48,6 @@ void ParameterizedTestAbstract::ensureInitialized() { TestListNode* currentTest = retrieveCurrentTest(); - if (_testAnchor == nullptr) - { - _testAnchor = new TestAnchor("ParameterizedTestAnchor", currentTest->m_test->m_details.suiteName, *this); - } - if (_testAnchorNode == nullptr) - { - _testAnchorNode = new TestListNode(_testAnchor); - } - if (_lastTest != currentTest) { _lastTest = currentTest; @@ -110,6 +101,7 @@ void ParameterizedTestAbstract::onNewIteration(bool first) { throw runtime_error("No values for parameterized test"); } + newAnchor(); } else { @@ -134,6 +126,23 @@ void ParameterizedTestAbstract::onNewIteration(bool first) } +void ParameterizedTestAbstract::newAnchor() +{ + if (_testAnchor != nullptr) + { + delete _testAnchor; + } + if (_testAnchorNode != nullptr) + { + delete _testAnchorNode; + } + + // Important: create anchor with exactly same details than original test for ensure it will pass all test filters the same way as original + _testAnchor = new TestAnchor(_lastTest->m_test->m_details.testName, _lastTest->m_test->m_details.suiteName, *this); + _testAnchorNode = new TestListNode(_testAnchor); +} + + ParameterizedTestAbstract::TestAnchor::TestAnchor(char const* testName, char const* suiteName, ParameterizedTestAbstract & pt) : Test(testName, suiteName), _pt(pt) diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h index 238e6dc..6fa4632 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/ParameterizedTest.h @@ -42,6 +42,7 @@ namespace UnitTest bool hasMoreValues(int advance = 0) const; void onNewIteration(bool first); + void newAnchor(); size_t _iteration; TestListNode* _lastTest; From 62941baf724d78a9a1232aa5f2ee3299ea1255d5 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 17 May 2016 15:11:54 +0200 Subject: [PATCH 042/131] minor simplification --- UnitTest++/ParameterizedTest.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index c66394a..144b4b7 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -96,11 +96,11 @@ void ParameterizedTestAbstract::onNewIteration(bool first) { if (first) { - _iteration = 0; - if (!hasMoreValues()) + if (valuesSize() == 0) { throw runtime_error("No values for parameterized test"); } + _iteration = 0; newAnchor(); } else From ab89bf3a0f0c4a7ae0f75f522af80a5ef9011ae2 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 18 May 2016 11:13:17 +0200 Subject: [PATCH 043/131] do not store current value for avoir problem "no default constructor for T_Value" --- UnitTest++/ParameterizedTest.h | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h index 6fa4632..3d41cc5 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/ParameterizedTest.h @@ -70,18 +70,15 @@ namespace UnitTest T_Value operator()() { - ensureInitialized(); - return _currentValue; + return _values[getIteration()]; } protected: virtual void peekCurrentValue(size_t iteration) override { - _currentValue = _values[iteration]; - if (_listener != nullptr) { - _listener->onNextIteration(getLastTest(), _currentValue, iteration); + _listener->onNextIteration(getLastTest(), _values[iteration], iteration); } } @@ -92,7 +89,6 @@ namespace UnitTest private: vector _values; - T_Value _currentValue; IParameterizedTestListener* const _listener; }; } From d17a772b50585162da2ccf848cac82bc6afe7f4f Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Thu, 19 May 2016 10:33:58 +0200 Subject: [PATCH 044/131] renamed "value" to "parameter" --- UnitTest++/ParameterizedTest.cpp | 10 +++++----- UnitTest++/ParameterizedTest.h | 33 ++++++++++++++++++-------------- 2 files changed, 24 insertions(+), 19 deletions(-) diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index 144b4b7..2563275 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -86,9 +86,9 @@ TestListNode* const ParameterizedTestAbstract::retrieveTest(TestDetails const * } -bool ParameterizedTestAbstract::hasMoreValues(int advance) const +bool ParameterizedTestAbstract::hasMoreParameters(int advance) const { - return (_iteration + advance < (int)valuesSize()); + return (_iteration + advance < (int)parametersCount()); } @@ -96,7 +96,7 @@ void ParameterizedTestAbstract::onNewIteration(bool first) { if (first) { - if (valuesSize() == 0) + if (parametersCount() == 0) { throw runtime_error("No values for parameterized test"); } @@ -108,7 +108,7 @@ void ParameterizedTestAbstract::onNewIteration(bool first) _iteration++; } - if (hasMoreValues()) + if (hasMoreParameters()) { _lastTest->m_next = _testAnchorNode; _testAnchorNode->m_next = _lastTest; @@ -122,7 +122,7 @@ void ParameterizedTestAbstract::onNewIteration(bool first) return; } - peekCurrentValue(_iteration); + peekCurrentParameter(_iteration); } diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h index 3d41cc5..7650edc 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/ParameterizedTest.h @@ -22,8 +22,8 @@ namespace UnitTest size_t getIteration(); protected: - virtual void peekCurrentValue(size_t iteration) = 0; - virtual size_t valuesSize() const = 0; + virtual void peekCurrentParameter(size_t iteration) = 0; + virtual size_t parametersCount() const = 0; void ensureInitialized(); Test* const getLastTest() const; @@ -40,7 +40,7 @@ namespace UnitTest TestListNode* const retrieveCurrentTest(); TestListNode* const retrieveTest(TestDetails const * const details); - bool hasMoreValues(int advance = 0) const; + bool hasMoreParameters(int advance = 0) const; void onNewIteration(bool first); void newAnchor(); @@ -53,42 +53,47 @@ namespace UnitTest }; - template + template class ParameterizedTest : public ParameterizedTestAbstract { public: struct IParameterizedTestListener { - virtual void onNextIteration(Test* const test, T_Value current, size_t iteration) = 0; + virtual void onNextIteration(Test* const test, T_Parameter current, size_t iteration) = 0; }; - ParameterizedTest(vector values, IParameterizedTestListener* const listener = nullptr) - : _values(values), + ParameterizedTest(vector parameters, IParameterizedTestListener* const listener = nullptr) + : _parameters(parameters), _listener(listener) { } - T_Value operator()() + T_Parameter operator()() { - return _values[getIteration()]; + return _parameters[getIteration()]; + } + + const vector & parameters() const + { + return _parameters; } protected: - virtual void peekCurrentValue(size_t iteration) override + virtual void peekCurrentParameter(size_t iteration) override { if (_listener != nullptr) { - _listener->onNextIteration(getLastTest(), _values[iteration], iteration); + _listener->onNextIteration(getLastTest(), _parameters[iteration], iteration); } } - virtual size_t valuesSize() const override + virtual size_t parametersCount() const override { - return _values.size(); + return _parameters.size(); } private: - vector _values; + vector _parameters; IParameterizedTestListener* const _listener; }; } From 7a01101cac708a98eadd439330d2a420812d0b4b Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 20 May 2016 11:49:41 +0200 Subject: [PATCH 045/131] fixed macro: no more friend class, use namespace, method defined inside the class --- UnitTest++/ParameterizedMacros.h | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/UnitTest++/ParameterizedMacros.h b/UnitTest++/ParameterizedMacros.h index 56f4ab4..96e15a0 100644 --- a/UnitTest++/ParameterizedMacros.h +++ b/UnitTest++/ParameterizedMacros.h @@ -7,18 +7,15 @@ #define SET_SUITE_PARAMETERS(Type, IterationName, SetUpBody) \ class ParameterizedCreator ## IterationName\ { \ - friend class ParameterizedTest<## Type>; \ public: \ ParameterizedCreator ## IterationName() { create(); } \ vector<## Type> parameters; \ private: \ - void create(); \ + void create() \ + ## SetUpBody \ } parameterizedCreator ## IterationName ## Instance; \ \ - ParameterizedTest<##Type> ## IterationName(parameterizedCreator ## IterationName ## Instance.parameters); \ - \ - void ParameterizedCreator ## IterationName::create() \ - ## SetUpBody + UnitTest::ParameterizedTest<## Type> ## IterationName(parameterizedCreator ## IterationName ## Instance.parameters); -#endif +#endif \ No newline at end of file From 1096f193ee3b231fef0905644516be2a18232177 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 20 May 2016 12:13:56 +0200 Subject: [PATCH 046/131] use static vars for give possibility to create common instances --- UnitTest++/ParameterizedMacros.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/UnitTest++/ParameterizedMacros.h b/UnitTest++/ParameterizedMacros.h index 96e15a0..a32bc6d 100644 --- a/UnitTest++/ParameterizedMacros.h +++ b/UnitTest++/ParameterizedMacros.h @@ -13,9 +13,9 @@ private: \ void create() \ ## SetUpBody \ - } parameterizedCreator ## IterationName ## Instance; \ + } static parameterizedCreator ## IterationName ## Instance; \ \ - UnitTest::ParameterizedTest<## Type> ## IterationName(parameterizedCreator ## IterationName ## Instance.parameters); + static UnitTest::ParameterizedTest<## Type> ## IterationName(parameterizedCreator ## IterationName ## Instance.parameters); #endif \ No newline at end of file From 2ba324ff1cdaed05dd69c7dd5551e775291deae8 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 24 May 2016 14:13:34 +0200 Subject: [PATCH 047/131] changed "int count" to "size_t count" for 64 bit portability (remove warning C4267: 'argument' : conversion from 'size_t' to 'const int', possible loss of data) --- UnitTest++/Checks.h | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/UnitTest++/Checks.h b/UnitTest++/Checks.h index 5b09768..e1c0462 100644 --- a/UnitTest++/Checks.h +++ b/UnitTest++/Checks.h @@ -57,10 +57,10 @@ namespace UnitTest { template< typename Expected, typename Actual > void CheckArrayEqual(TestResults& results, Expected const& expected, Actual const& actual, - int const count, TestDetails const& details) + size_t const count, TestDetails const& details) { bool equal = true; - for (int i = 0; i < count; ++i) + for (size_t i = 0; i < count; ++i) equal &= (expected[i] == actual[i]); if (!equal) @@ -69,12 +69,12 @@ namespace UnitTest { stream << "Expected [ "; - for (int expectedIndex = 0; expectedIndex < count; ++expectedIndex) + for (size_t expectedIndex = 0; expectedIndex < count; ++expectedIndex) stream << expected[expectedIndex] << " "; stream << "] but was [ "; - for (int actualIndex = 0; actualIndex < count; ++actualIndex) + for (size_t actualIndex = 0; actualIndex < count; ++actualIndex) stream << actual[actualIndex] << " "; stream << "]"; @@ -84,17 +84,17 @@ namespace UnitTest { } template< typename Expected, typename Actual, typename Tolerance > - bool ArrayAreClose(Expected const& expected, Actual const& actual, int const count, Tolerance const& tolerance) + bool ArrayAreClose(Expected const& expected, Actual const& actual, size_t const count, Tolerance const& tolerance) { bool equal = true; - for (int i = 0; i < count; ++i) + for (size_t i = 0; i < count; ++i) equal &= AreClose(expected[i], actual[i], tolerance); return equal; } template< typename Expected, typename Actual, typename Tolerance > void CheckArrayClose(TestResults& results, Expected const& expected, Actual const& actual, - int const count, Tolerance const& tolerance, TestDetails const& details) + size_t const count, Tolerance const& tolerance, TestDetails const& details) { bool equal = ArrayAreClose(expected, actual, count, tolerance); @@ -103,11 +103,11 @@ namespace UnitTest { UnitTest::MemoryOutStream stream; stream << "Expected [ "; - for (int expectedIndex = 0; expectedIndex < count; ++expectedIndex) + for (size_t expectedIndex = 0; expectedIndex < count; ++expectedIndex) stream << expected[expectedIndex] << " "; stream << "] +/- " << tolerance << " but was [ "; - for (int actualIndex = 0; actualIndex < count; ++actualIndex) + for (size_t actualIndex = 0; actualIndex < count; ++actualIndex) stream << actual[actualIndex] << " "; stream << "]"; @@ -117,10 +117,10 @@ namespace UnitTest { template< typename Expected, typename Actual, typename Tolerance > void CheckArray2DClose(TestResults& results, Expected const& expected, Actual const& actual, - int const rows, int const columns, Tolerance const& tolerance, TestDetails const& details) + size_t const rows, size_t const columns, Tolerance const& tolerance, TestDetails const& details) { bool equal = true; - for (int i = 0; i < rows; ++i) + for (size_t i = 0; i < rows; ++i) equal &= ArrayAreClose(expected[i], actual[i], columns, tolerance); if (!equal) @@ -129,20 +129,20 @@ namespace UnitTest { stream << "Expected [ "; - for (int expectedRow = 0; expectedRow < rows; ++expectedRow) + for (size_t expectedRow = 0; expectedRow < rows; ++expectedRow) { stream << "[ "; - for (int expectedColumn = 0; expectedColumn < columns; ++expectedColumn) + for (size_t expectedColumn = 0; expectedColumn < columns; ++expectedColumn) stream << expected[expectedRow][expectedColumn] << " "; stream << "] "; } stream << "] +/- " << tolerance << " but was [ "; - for (int actualRow = 0; actualRow < rows; ++actualRow) + for (size_t actualRow = 0; actualRow < rows; ++actualRow) { stream << "[ "; - for (int actualColumn = 0; actualColumn < columns; ++actualColumn) + for (size_t actualColumn = 0; actualColumn < columns; ++actualColumn) stream << actual[actualRow][actualColumn] << " "; stream << "] "; } From 5399af72a29eefeeac2fa750fce3f7c438362151 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sun, 5 Jun 2016 17:23:35 +0200 Subject: [PATCH 048/131] little test simplification --- tests/TestParameterizedTest.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index 5bca9eb..f4b4779 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -110,20 +110,20 @@ SUITE(ParameterizedTestSimple) ////////// - SET_SUITE_PARAMETERS(string, xyz, { - parameters.push_back("X"); - parameters.push_back("Y"); - parameters.push_back("Z"); + SET_SUITE_PARAMETERS(string, oneTwo, { + parameters.push_back("1"); + parameters.push_back("2"); }); string nestedParameters; TEST(NestedParameters) { - nestedParameters += vowel() + xyz(); // Add a separator for + nestedParameters += vowel(); + nestedParameters += oneTwo(); } TEST(NestedParameters_Verify) { - CHECK_EQUAL("AXEXIXOXUXYXAYEYIYOYUYYYAZEZIZOZUZYZ", nestedParameters); + CHECK_EQUAL("A1A2E1E2I1I2O1O2U1U2Y1Y2", nestedParameters); } } From ab3298bc66ca2fcb4bbb888d579c81364538f21f Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 7 Jun 2016 14:31:02 +0200 Subject: [PATCH 049/131] created class ParameterizedManager --- UnitTest++/ParameterizedManager.cpp | 22 ++++++++++++++++++++++ UnitTest++/ParameterizedManager.h | 19 +++++++++++++++++++ 2 files changed, 41 insertions(+) create mode 100644 UnitTest++/ParameterizedManager.cpp create mode 100644 UnitTest++/ParameterizedManager.h diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp new file mode 100644 index 0000000..a800f2c --- /dev/null +++ b/UnitTest++/ParameterizedManager.cpp @@ -0,0 +1,22 @@ +#include "ParameterizedManager.h" + + +using namespace std; +using namespace UnitTest; + + +ParameterizedManager::ParameterizedManager() +{ +} + + +ParameterizedManager::~ParameterizedManager() +{ +} + + +ParameterizedManager & ParameterizedManager::getInstance() +{ + static ParameterizedManager stored; + return stored; +} diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h new file mode 100644 index 0000000..9362adb --- /dev/null +++ b/UnitTest++/ParameterizedManager.h @@ -0,0 +1,19 @@ +#ifndef UNITTEST_PARAMETERIZEDMANAGER_H +#define UNITTEST_PARAMETERIZEDMANAGER_H + +namespace UnitTest +{ + using namespace std; + + class ParameterizedManager + { + public: + static ParameterizedManager & getInstance(); + + private: + ParameterizedManager(); + virtual ~ParameterizedManager(); + }; +} + +#endif \ No newline at end of file From b459589096a8cfd5571035605d0b8da263ba535e Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 7 Jun 2016 14:40:25 +0200 Subject: [PATCH 050/131] moved test retriever --- UnitTest++/ParameterizedManager.cpp | 24 ++++++++++++++++++++++ UnitTest++/ParameterizedManager.h | 9 ++++++++ UnitTest++/ParameterizedTest.cpp | 32 ++--------------------------- UnitTest++/ParameterizedTest.h | 7 ------- 4 files changed, 35 insertions(+), 37 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index a800f2c..4a49b3c 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -1,5 +1,6 @@ #include "ParameterizedManager.h" +#include "Test.h" using namespace std; using namespace UnitTest; @@ -20,3 +21,26 @@ ParameterizedManager & ParameterizedManager::getInstance() static ParameterizedManager stored; return stored; } + + +TestListNode* const ParameterizedManager::retrieveTest(TestDetails const * const details) +{ + //TODO This workaround is too far complicated, why not simply add pointer to current test in class CurrentTest ? + Details2Test::iterator it = _tests.find(details); + + if (it != _tests.end()) + { + return it->second; + } + + for (TestListNode* iNode = Test::GetTestList().GetHead(); iNode != nullptr; iNode = iNode->m_next) + { + if (&iNode->m_test->m_details == details) + { + _tests[details] = iNode; + return iNode; + } + } + + throw runtime_error(string("Impossible to retrieve test ") + details->testName); +} diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index 9362adb..bcd5fd2 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -1,18 +1,27 @@ #ifndef UNITTEST_PARAMETERIZEDMANAGER_H #define UNITTEST_PARAMETERIZEDMANAGER_H +#include +#include "TestDetails.h" +#include "TestList.h" + namespace UnitTest { using namespace std; + typedef map Details2Test; + class ParameterizedManager { public: static ParameterizedManager & getInstance(); + TestListNode* const retrieveTest(TestDetails const * const details); private: ParameterizedManager(); virtual ~ParameterizedManager(); + + Details2Test _tests; }; } diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index 2563275..32fb31a 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -1,6 +1,7 @@ #include "ParameterizedTest.h" #include "CurrentTest.h" +#include "ParameterizedManager.h" using namespace std; using namespace UnitTest; @@ -46,7 +47,7 @@ Test* const ParameterizedTestAbstract::getLastTest() const void ParameterizedTestAbstract::ensureInitialized() { - TestListNode* currentTest = retrieveCurrentTest(); + TestListNode* currentTest = ParameterizedManager::getInstance().retrieveTest(CurrentTest::Details()); if (_lastTest != currentTest) { @@ -57,35 +58,6 @@ void ParameterizedTestAbstract::ensureInitialized() } -TestListNode* const ParameterizedTestAbstract::retrieveCurrentTest() -{ - return retrieveTest(CurrentTest::Details()); -} - - -TestListNode* const ParameterizedTestAbstract::retrieveTest(TestDetails const * const details) -{ - //TODO This workaround is too far complicated, why not simply add pointer to current test in class CurrentTest ? - Details2Test::iterator it = _tests.find(details); - - if (it != _tests.end()) - { - return it->second; - } - - for (TestListNode* iNode = Test::GetTestList().GetHead(); iNode != nullptr; iNode = iNode->m_next) - { - if (&iNode->m_test->m_details == details) - { - _tests[details] = iNode; - return iNode; - } - } - - throw runtime_error(string("Impossible to retrieve test ") + details->testName); -} - - bool ParameterizedTestAbstract::hasMoreParameters(int advance) const { return (_iteration + advance < (int)parametersCount()); diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h index 7650edc..f672cb5 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/ParameterizedTest.h @@ -2,7 +2,6 @@ #define UNITTEST_PARAMETERIZEDTEST_H #include -#include #include #include "Test.h" @@ -12,8 +11,6 @@ namespace UnitTest { using namespace std; - typedef map Details2Test; - class ParameterizedTestAbstract { public: @@ -37,9 +34,6 @@ namespace UnitTest ParameterizedTestAbstract & _pt; }; - TestListNode* const retrieveCurrentTest(); - TestListNode* const retrieveTest(TestDetails const * const details); - bool hasMoreParameters(int advance = 0) const; void onNewIteration(bool first); void newAnchor(); @@ -49,7 +43,6 @@ namespace UnitTest TestListNode* _nextTestBackup; TestListNode* _testAnchorNode; TestAnchor* _testAnchor; - Details2Test _tests; }; From ba7c47229141e4aa10fe4457d4294e8999108e3b Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 7 Jun 2016 16:46:47 +0200 Subject: [PATCH 051/131] implemented manager --- UnitTest++/ExecuteTest.h | 3 ++ UnitTest++/ParameterizedManager.cpp | 60 +++++++++++++++++++++++ UnitTest++/ParameterizedManager.h | 17 +++++++ UnitTest++/ParameterizedTest.cpp | 76 ++++------------------------- UnitTest++/ParameterizedTest.h | 15 +----- 5 files changed, 90 insertions(+), 81 deletions(-) diff --git a/UnitTest++/ExecuteTest.h b/UnitTest++/ExecuteTest.h index 8e516db..3c62b90 100644 --- a/UnitTest++/ExecuteTest.h +++ b/UnitTest++/ExecuteTest.h @@ -9,6 +9,7 @@ #include "AssertException.h" #include "RequiredCheckException.h" #include "CurrentTest.h" +#include "ParameterizedManager.h" #ifdef UNITTEST_NO_EXCEPTIONS #include "ReportAssertImpl.h" @@ -26,6 +27,7 @@ namespace UnitTest { if (isMockTest == false) CurrentTest::Details() = &details; + ParameterizedManager::getInstance().beginExecute(&details); #ifdef UNITTEST_NO_EXCEPTIONS if (UNITTEST_SET_ASSERT_JUMP_TARGET() == 0) { @@ -54,6 +56,7 @@ namespace UnitTest { #ifdef UNITTEST_NO_EXCEPTIONS } #endif + ParameterizedManager::getInstance().finishExecute(&details); } } diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 4a49b3c..09556c5 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -1,12 +1,15 @@ #include "ParameterizedManager.h" #include "Test.h" +#include "ParameterizedTest.h" using namespace std; using namespace UnitTest; ParameterizedManager::ParameterizedManager() + : _currentTest(nullptr), + _nextTestBackup(nullptr) { } @@ -44,3 +47,60 @@ TestListNode* const ParameterizedManager::retrieveTest(TestDetails const * const throw runtime_error(string("Impossible to retrieve test ") + details->testName); } + + +Test* const ParameterizedManager::getCurrentTest() const +{ + return (_currentTest != nullptr) ? _currentTest->m_test : nullptr; +} + + +void ParameterizedManager::beginExecute(TestDetails const * const details) +{ + TestListNode* test = retrieveTest(details); + if (_currentTest != test) + { + _currentTest = test; + _nextTestBackup = _currentTest->m_next; + _currentTest->m_next = _currentTest; // Loop itself + } +} + + +void ParameterizedManager::finishExecute(TestDetails const * const details) +{ + while (!_stack.empty()) + { + ParameterizedTestAbstract* iParameterized = _stack.back(); + if (iParameterized->hasMoreParameters(1)) + { + break; + } + else + { + _stack.pop_back(); + } + } + + if (_stack.empty()) + { + _currentTest->m_next = _nextTestBackup; + _currentTest = nullptr; + _nextTestBackup = nullptr; + } +} + + +ParameterizedManager::RegisterThen ParameterizedManager::registerParameter(ParameterizedTestAbstract* const parameterized) +{ + if (!_stack.empty() && _stack.back() == parameterized) + { + return RegisterThen::ITERATE; + } + if (find(_stack.begin(), _stack.end(), parameterized) == _stack.end()) + { + _stack.push_back(parameterized); + return RegisterThen::FIRST; + } + return RegisterThen::IDLE; +} diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index bcd5fd2..ef607a0 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -1,6 +1,7 @@ #ifndef UNITTEST_PARAMETERIZEDMANAGER_H #define UNITTEST_PARAMETERIZEDMANAGER_H +#include #include #include "TestDetails.h" #include "TestList.h" @@ -8,20 +9,36 @@ namespace UnitTest { using namespace std; + + class ParameterizedTestAbstract; typedef map Details2Test; class ParameterizedManager { public: + enum RegisterThen + { + FIRST, + ITERATE, + IDLE + }; + static ParameterizedManager & getInstance(); TestListNode* const retrieveTest(TestDetails const * const details); + Test* const getCurrentTest() const; + void beginExecute(TestDetails const * const details); + void finishExecute(TestDetails const * const details); + RegisterThen registerParameter(ParameterizedTestAbstract* const parameterized); private: ParameterizedManager(); virtual ~ParameterizedManager(); + TestListNode* _currentTest; + TestListNode* _nextTestBackup; Details2Test _tests; + vector _stack; }; } diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index 32fb31a..e43b0d3 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -8,27 +8,13 @@ using namespace UnitTest; ParameterizedTestAbstract::ParameterizedTestAbstract() - : _iteration(0), - _testAnchor(nullptr), - _testAnchorNode(nullptr), - _lastTest(nullptr), - _nextTestBackup(nullptr) + : _iteration(0) { } ParameterizedTestAbstract::~ParameterizedTestAbstract() { - if (_testAnchor != nullptr) - { - delete _testAnchor; - _testAnchor = nullptr; - } - if (_testAnchorNode != nullptr) - { - delete _testAnchorNode; - _testAnchorNode = nullptr; - } } @@ -41,20 +27,21 @@ size_t ParameterizedTestAbstract::getIteration() Test* const ParameterizedTestAbstract::getLastTest() const { - return _lastTest->m_test; + return ParameterizedManager::getInstance().getCurrentTest(); } void ParameterizedTestAbstract::ensureInitialized() { - TestListNode* currentTest = ParameterizedManager::getInstance().retrieveTest(CurrentTest::Details()); - - if (_lastTest != currentTest) + ParameterizedManager::RegisterThen then = ParameterizedManager::getInstance().registerParameter(this); + if (then == ParameterizedManager::FIRST) { - _lastTest = currentTest; - _nextTestBackup = currentTest->m_next; onNewIteration(true); } + else if (then == ParameterizedManager::ITERATE) + { + onNewIteration(false); + } } @@ -73,56 +60,11 @@ void ParameterizedTestAbstract::onNewIteration(bool first) throw runtime_error("No values for parameterized test"); } _iteration = 0; - newAnchor(); - } - else - { - _iteration++; - } - - if (hasMoreParameters()) - { - _lastTest->m_next = _testAnchorNode; - _testAnchorNode->m_next = _lastTest; } else { - _lastTest->m_next= _nextTestBackup; - _lastTest = nullptr; - - _testAnchorNode->m_next = _nextTestBackup; - return; + _iteration = (hasMoreParameters(1)) ? _iteration + 1 : 0; } peekCurrentParameter(_iteration); } - - -void ParameterizedTestAbstract::newAnchor() -{ - if (_testAnchor != nullptr) - { - delete _testAnchor; - } - if (_testAnchorNode != nullptr) - { - delete _testAnchorNode; - } - - // Important: create anchor with exactly same details than original test for ensure it will pass all test filters the same way as original - _testAnchor = new TestAnchor(_lastTest->m_test->m_details.testName, _lastTest->m_test->m_details.suiteName, *this); - _testAnchorNode = new TestListNode(_testAnchor); -} - - -ParameterizedTestAbstract::TestAnchor::TestAnchor(char const* testName, char const* suiteName, ParameterizedTestAbstract & pt) - : Test(testName, suiteName), - _pt(pt) -{ -} - - -void ParameterizedTestAbstract::TestAnchor::RunImpl() const -{ - _pt.onNewIteration(false); -} diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h index f672cb5..057e147 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/ParameterizedTest.h @@ -13,6 +13,7 @@ namespace UnitTest class ParameterizedTestAbstract { + friend class ParameterizedManager; public: ParameterizedTestAbstract(); virtual ~ParameterizedTestAbstract(); @@ -25,24 +26,10 @@ namespace UnitTest Test* const getLastTest() const; private: - class TestAnchor : public Test - { - public: - TestAnchor(char const* testName, char const* suiteName, ParameterizedTestAbstract & pt); - virtual void RunImpl() const override; - private: - ParameterizedTestAbstract & _pt; - }; - bool hasMoreParameters(int advance = 0) const; void onNewIteration(bool first); - void newAnchor(); size_t _iteration; - TestListNode* _lastTest; - TestListNode* _nextTestBackup; - TestListNode* _testAnchorNode; - TestAnchor* _testAnchor; }; From 807cc813fce8a40fd074b2150d9c3d7634366a0c Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 7 Jun 2016 17:03:10 +0200 Subject: [PATCH 052/131] added test for working with fixtures (not passing yet) --- tests/TestParameterizedTest.cpp | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index f4b4779..0943b0b 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -57,7 +57,7 @@ SUITE(ParameterizedTestSimple) { parameterizedEmpty(); } - catch(runtime_error e) // Expected case + catch (runtime_error e) // Expected case { CHECK_EQUAL("No values for parameterized test", e.what()); return; @@ -126,4 +126,19 @@ SUITE(ParameterizedTestSimple) { CHECK_EQUAL("A1A2E1E2I1I2O1O2U1U2Y1Y2", nestedParameters); } + + ////////// + + struct Fixture {}; + + string withFixture; + TEST_FIXTURE(Fixture, WorksWithFixture) + { + withFixture += oneTwo(); + } + + TEST(WorksWithFixture_Verify) + { + CHECK_EQUAL("12", withFixture); + } } From 60165e44a0556a12c9eeb6c4b1745864425c2ee2 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 7 Jun 2016 17:23:07 +0200 Subject: [PATCH 053/131] fixed execution failure with Fixture --- UnitTest++/ExecuteTest.h | 10 +++++++--- UnitTest++/Test.cpp | 2 +- UnitTest++/TestMacros.h | 2 +- 3 files changed, 9 insertions(+), 5 deletions(-) diff --git a/UnitTest++/ExecuteTest.h b/UnitTest++/ExecuteTest.h index 3c62b90..6e20b7d 100644 --- a/UnitTest++/ExecuteTest.h +++ b/UnitTest++/ExecuteTest.h @@ -21,13 +21,16 @@ namespace UnitTest { + //TODO remove template and parameter "templateIsTest", replace with an interface template< typename T > - void ExecuteTest(T& testObject, TestDetails const& details, bool isMockTest) + void ExecuteTest(T& testObject, TestDetails const& details, bool isMockTest, bool templateIsTest) { if (isMockTest == false) CurrentTest::Details() = &details; - ParameterizedManager::getInstance().beginExecute(&details); + if (templateIsTest) + ParameterizedManager::getInstance().beginExecute(&details); + #ifdef UNITTEST_NO_EXCEPTIONS if (UNITTEST_SET_ASSERT_JUMP_TARGET() == 0) { @@ -56,7 +59,8 @@ namespace UnitTest { #ifdef UNITTEST_NO_EXCEPTIONS } #endif - ParameterizedManager::getInstance().finishExecute(&details); + if (templateIsTest) + ParameterizedManager::getInstance().finishExecute(&details); } } diff --git a/UnitTest++/Test.cpp b/UnitTest++/Test.cpp index 2258899..889960e 100644 --- a/UnitTest++/Test.cpp +++ b/UnitTest++/Test.cpp @@ -28,7 +28,7 @@ namespace UnitTest { void Test::Run() { - ExecuteTest(*this, m_details, m_isMockTest); + ExecuteTest(*this, m_details, m_isMockTest, true); } void Test::RunImpl() const diff --git a/UnitTest++/TestMacros.h b/UnitTest++/TestMacros.h index 738c56b..6bc925f 100644 --- a/UnitTest++/TestMacros.h +++ b/UnitTest++/TestMacros.h @@ -83,7 +83,7 @@ ({ \ Fixture ## Name ## Helper fixtureHelper(m_details); \ ctorOk = true; \ - UnitTest::ExecuteTest(fixtureHelper, m_details, false); \ + UnitTest::ExecuteTest(fixtureHelper, m_details, false, false); \ }) \ UT_CATCH (UnitTest::AssertException, e, \ { \ From bd67474ae9d17e418e2cb43fb5dec0693877f016 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 7 Jun 2016 17:32:56 +0200 Subject: [PATCH 054/131] protection against nested test --- UnitTest++/ParameterizedManager.cpp | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 09556c5..fa584a5 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -57,18 +57,24 @@ Test* const ParameterizedManager::getCurrentTest() const void ParameterizedManager::beginExecute(TestDetails const * const details) { - TestListNode* test = retrieveTest(details); - if (_currentTest != test) + if (_currentTest != nullptr) { - _currentTest = test; - _nextTestBackup = _currentTest->m_next; - _currentTest->m_next = _currentTest; // Loop itself + return; } + _currentTest = retrieveTest(details); + _nextTestBackup = _currentTest->m_next; + _currentTest->m_next = _currentTest; // Loop itself } void ParameterizedManager::finishExecute(TestDetails const * const details) { + // Protection against nested tests + if (&_currentTest->m_test->m_details != details) + { + return; + } + while (!_stack.empty()) { ParameterizedTestAbstract* iParameterized = _stack.back(); From bbe4c889e70879a3613b800377d15a2a20276903 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 7 Jun 2016 17:35:14 +0200 Subject: [PATCH 055/131] Revert "fixed execution failure with Fixture" This reverts commit 60165e44a0556a12c9eeb6c4b1745864425c2ee2. --- UnitTest++/ExecuteTest.h | 10 +++------- UnitTest++/Test.cpp | 2 +- UnitTest++/TestMacros.h | 2 +- 3 files changed, 5 insertions(+), 9 deletions(-) diff --git a/UnitTest++/ExecuteTest.h b/UnitTest++/ExecuteTest.h index 6e20b7d..3c62b90 100644 --- a/UnitTest++/ExecuteTest.h +++ b/UnitTest++/ExecuteTest.h @@ -21,16 +21,13 @@ namespace UnitTest { - //TODO remove template and parameter "templateIsTest", replace with an interface template< typename T > - void ExecuteTest(T& testObject, TestDetails const& details, bool isMockTest, bool templateIsTest) + void ExecuteTest(T& testObject, TestDetails const& details, bool isMockTest) { if (isMockTest == false) CurrentTest::Details() = &details; - if (templateIsTest) - ParameterizedManager::getInstance().beginExecute(&details); - + ParameterizedManager::getInstance().beginExecute(&details); #ifdef UNITTEST_NO_EXCEPTIONS if (UNITTEST_SET_ASSERT_JUMP_TARGET() == 0) { @@ -59,8 +56,7 @@ namespace UnitTest { #ifdef UNITTEST_NO_EXCEPTIONS } #endif - if (templateIsTest) - ParameterizedManager::getInstance().finishExecute(&details); + ParameterizedManager::getInstance().finishExecute(&details); } } diff --git a/UnitTest++/Test.cpp b/UnitTest++/Test.cpp index 889960e..2258899 100644 --- a/UnitTest++/Test.cpp +++ b/UnitTest++/Test.cpp @@ -28,7 +28,7 @@ namespace UnitTest { void Test::Run() { - ExecuteTest(*this, m_details, m_isMockTest, true); + ExecuteTest(*this, m_details, m_isMockTest); } void Test::RunImpl() const diff --git a/UnitTest++/TestMacros.h b/UnitTest++/TestMacros.h index 6bc925f..738c56b 100644 --- a/UnitTest++/TestMacros.h +++ b/UnitTest++/TestMacros.h @@ -83,7 +83,7 @@ ({ \ Fixture ## Name ## Helper fixtureHelper(m_details); \ ctorOk = true; \ - UnitTest::ExecuteTest(fixtureHelper, m_details, false, false); \ + UnitTest::ExecuteTest(fixtureHelper, m_details, false); \ }) \ UT_CATCH (UnitTest::AssertException, e, \ { \ From 94295a0a7d1f93bf99558aa79466305c01d85680 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 7 Jun 2016 17:38:57 +0200 Subject: [PATCH 056/131] improved protection (revert prev commit was not suffisciant) --- UnitTest++/ParameterizedManager.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index fa584a5..ca24cca 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -70,7 +70,7 @@ void ParameterizedManager::beginExecute(TestDetails const * const details) void ParameterizedManager::finishExecute(TestDetails const * const details) { // Protection against nested tests - if (&_currentTest->m_test->m_details != details) + if (_currentTest == nullptr || &_currentTest->m_test->m_details != details) { return; } From 4247f7889ae11451d37f512ae261b15676b9d058 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 7 Jun 2016 17:54:25 +0200 Subject: [PATCH 057/131] removed warning "size_t to int conversion possible loss of data" --- tests/TestExceptions.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/TestExceptions.cpp b/tests/TestExceptions.cpp index 972e64d..08f6547 100644 --- a/tests/TestExceptions.cpp +++ b/tests/TestExceptions.cpp @@ -253,7 +253,7 @@ namespace { class ThrowingObject { public: - float operator[](int) const + float operator[](size_t) const { throw "Test throw"; } @@ -262,7 +262,7 @@ namespace { class StdThrowingObject { public: - float operator[](int) const + float operator[](size_t) const { throw std::runtime_error("Test throw"); } @@ -451,7 +451,7 @@ namespace { class ThrowingObject2D { public: - float* operator[](int) const + float* operator[](size_t) const { throw "Test throw"; } @@ -460,7 +460,7 @@ namespace { class StdThrowingObject2D { public: - float* operator[](int) const + float* operator[](size_t) const { throw std::runtime_error("Test throw"); } From 2991b08cc78aaee757974c1f6fa18a5712eb85cb Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 7 Jun 2016 18:14:29 +0200 Subject: [PATCH 058/131] removed tests storage (now useless because of begin/finish notion) --- UnitTest++/ParameterizedManager.cpp | 10 +--------- UnitTest++/ParameterizedManager.h | 2 -- 2 files changed, 1 insertion(+), 11 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index ca24cca..0a31436 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -28,19 +28,11 @@ ParameterizedManager & ParameterizedManager::getInstance() TestListNode* const ParameterizedManager::retrieveTest(TestDetails const * const details) { - //TODO This workaround is too far complicated, why not simply add pointer to current test in class CurrentTest ? - Details2Test::iterator it = _tests.find(details); - - if (it != _tests.end()) - { - return it->second; - } - + //TODO This workaround is a bit too complicated, why not simply add pointer to current test in class CurrentTest ? for (TestListNode* iNode = Test::GetTestList().GetHead(); iNode != nullptr; iNode = iNode->m_next) { if (&iNode->m_test->m_details == details) { - _tests[details] = iNode; return iNode; } } diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index ef607a0..3a2d1b1 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -12,7 +12,6 @@ namespace UnitTest class ParameterizedTestAbstract; - typedef map Details2Test; class ParameterizedManager { @@ -37,7 +36,6 @@ namespace UnitTest TestListNode* _currentTest; TestListNode* _nextTestBackup; - Details2Test _tests; vector _stack; }; } From 3236f62ddc9ac8db83d59bc168f8ceade9ec3277 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 7 Jun 2016 18:14:58 +0200 Subject: [PATCH 059/131] code cleaning --- UnitTest++/ExecuteTest.h | 2 +- UnitTest++/ParameterizedManager.cpp | 2 +- UnitTest++/ParameterizedManager.h | 6 ++---- UnitTest++/ParameterizedTest.cpp | 19 ++++++++----------- UnitTest++/ParameterizedTest.h | 6 +++--- 5 files changed, 15 insertions(+), 20 deletions(-) diff --git a/UnitTest++/ExecuteTest.h b/UnitTest++/ExecuteTest.h index 3c62b90..d0e17ba 100644 --- a/UnitTest++/ExecuteTest.h +++ b/UnitTest++/ExecuteTest.h @@ -56,7 +56,7 @@ namespace UnitTest { #ifdef UNITTEST_NO_EXCEPTIONS } #endif - ParameterizedManager::getInstance().finishExecute(&details); + ParameterizedManager::getInstance().endExecute(&details); } } diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 0a31436..aa8688a 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -59,7 +59,7 @@ void ParameterizedManager::beginExecute(TestDetails const * const details) } -void ParameterizedManager::finishExecute(TestDetails const * const details) +void ParameterizedManager::endExecute(TestDetails const * const details) { // Protection against nested tests if (_currentTest == nullptr || &_currentTest->m_test->m_details != details) diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index 3a2d1b1..ff9ad57 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -9,10 +9,8 @@ namespace UnitTest { using namespace std; - class ParameterizedTestAbstract; - class ParameterizedManager { public: @@ -24,15 +22,15 @@ namespace UnitTest }; static ParameterizedManager & getInstance(); - TestListNode* const retrieveTest(TestDetails const * const details); Test* const getCurrentTest() const; void beginExecute(TestDetails const * const details); - void finishExecute(TestDetails const * const details); + void endExecute(TestDetails const * const details); RegisterThen registerParameter(ParameterizedTestAbstract* const parameterized); private: ParameterizedManager(); virtual ~ParameterizedManager(); + TestListNode* const retrieveTest(TestDetails const * const details); TestListNode* _currentTest; TestListNode* _nextTestBackup; diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index e43b0d3..77aa2bd 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -1,7 +1,5 @@ #include "ParameterizedTest.h" -#include "CurrentTest.h" -#include "ParameterizedManager.h" using namespace std; using namespace UnitTest; @@ -20,18 +18,12 @@ ParameterizedTestAbstract::~ParameterizedTestAbstract() size_t ParameterizedTestAbstract::getIteration() { - ensureInitialized(); + updateIteration(); return _iteration; } -Test* const ParameterizedTestAbstract::getLastTest() const -{ - return ParameterizedManager::getInstance().getCurrentTest(); -} - - -void ParameterizedTestAbstract::ensureInitialized() +void ParameterizedTestAbstract::updateIteration() { ParameterizedManager::RegisterThen then = ParameterizedManager::getInstance().registerParameter(this); if (then == ParameterizedManager::FIRST) @@ -53,6 +45,11 @@ bool ParameterizedTestAbstract::hasMoreParameters(int advance) const void ParameterizedTestAbstract::onNewIteration(bool first) { + if (!first && !hasMoreParameters(1)) + { + first = true; + } + if (first) { if (parametersCount() == 0) @@ -63,7 +60,7 @@ void ParameterizedTestAbstract::onNewIteration(bool first) } else { - _iteration = (hasMoreParameters(1)) ? _iteration + 1 : 0; + _iteration++; } peekCurrentParameter(_iteration); diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h index 057e147..cde5287 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/ParameterizedTest.h @@ -6,6 +6,7 @@ #include "Test.h" #include "TestList.h" +#include "ParameterizedManager.h" namespace UnitTest { @@ -20,10 +21,9 @@ namespace UnitTest size_t getIteration(); protected: + void updateIteration(); virtual void peekCurrentParameter(size_t iteration) = 0; virtual size_t parametersCount() const = 0; - void ensureInitialized(); - Test* const getLastTest() const; private: bool hasMoreParameters(int advance = 0) const; @@ -63,7 +63,7 @@ namespace UnitTest { if (_listener != nullptr) { - _listener->onNextIteration(getLastTest(), _parameters[iteration], iteration); + _listener->onNextIteration(ParameterizedManager::getInstance().getCurrentTest(), _parameters[iteration], iteration); } } From 124d448420d6baf9e616acb17bf8128106568ac2 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 8 Jun 2016 10:03:47 +0200 Subject: [PATCH 060/131] revert revert (finally it is useful) --- UnitTest++/ExecuteTest.h | 10 +++++++--- UnitTest++/Test.cpp | 2 +- UnitTest++/TestMacros.h | 2 +- 3 files changed, 9 insertions(+), 5 deletions(-) diff --git a/UnitTest++/ExecuteTest.h b/UnitTest++/ExecuteTest.h index d0e17ba..4491d2e 100644 --- a/UnitTest++/ExecuteTest.h +++ b/UnitTest++/ExecuteTest.h @@ -21,13 +21,16 @@ namespace UnitTest { + //TODO remove template and parameter "templateIsTest", replace with an interface template< typename T > - void ExecuteTest(T& testObject, TestDetails const& details, bool isMockTest) + void ExecuteTest(T& testObject, TestDetails const& details, bool isMockTest, bool templateIsTest) { if (isMockTest == false) CurrentTest::Details() = &details; - ParameterizedManager::getInstance().beginExecute(&details); + if (templateIsTest) + ParameterizedManager::getInstance().beginExecute(&details); + #ifdef UNITTEST_NO_EXCEPTIONS if (UNITTEST_SET_ASSERT_JUMP_TARGET() == 0) { @@ -56,7 +59,8 @@ namespace UnitTest { #ifdef UNITTEST_NO_EXCEPTIONS } #endif - ParameterizedManager::getInstance().endExecute(&details); + if (templateIsTest) + ParameterizedManager::getInstance().endExecute(&details); } } diff --git a/UnitTest++/Test.cpp b/UnitTest++/Test.cpp index 2258899..889960e 100644 --- a/UnitTest++/Test.cpp +++ b/UnitTest++/Test.cpp @@ -28,7 +28,7 @@ namespace UnitTest { void Test::Run() { - ExecuteTest(*this, m_details, m_isMockTest); + ExecuteTest(*this, m_details, m_isMockTest, true); } void Test::RunImpl() const diff --git a/UnitTest++/TestMacros.h b/UnitTest++/TestMacros.h index 738c56b..6bc925f 100644 --- a/UnitTest++/TestMacros.h +++ b/UnitTest++/TestMacros.h @@ -83,7 +83,7 @@ ({ \ Fixture ## Name ## Helper fixtureHelper(m_details); \ ctorOk = true; \ - UnitTest::ExecuteTest(fixtureHelper, m_details, false); \ + UnitTest::ExecuteTest(fixtureHelper, m_details, false, false); \ }) \ UT_CATCH (UnitTest::AssertException, e, \ { \ From 69d2a14343d55b31d7548f0407516e76f0597078 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 8 Jun 2016 10:19:42 +0200 Subject: [PATCH 061/131] created clean method --- UnitTest++/ParameterizedManager.cpp | 9 +++++++-- UnitTest++/ParameterizedManager.h | 1 + 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index aa8688a..5758332 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -47,6 +47,12 @@ Test* const ParameterizedManager::getCurrentTest() const } +bool ParameterizedManager::isCurrentTest(TestDetails const * const details) const +{ + return (_currentTest != nullptr && &_currentTest->m_test->m_details == details); +} + + void ParameterizedManager::beginExecute(TestDetails const * const details) { if (_currentTest != nullptr) @@ -61,8 +67,7 @@ void ParameterizedManager::beginExecute(TestDetails const * const details) void ParameterizedManager::endExecute(TestDetails const * const details) { - // Protection against nested tests - if (_currentTest == nullptr || &_currentTest->m_test->m_details != details) + if (!isCurrentTest(details)) { return; } diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index ff9ad57..01b4f2d 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -23,6 +23,7 @@ namespace UnitTest static ParameterizedManager & getInstance(); Test* const getCurrentTest() const; + bool isCurrentTest(TestDetails const * const details) const; void beginExecute(TestDetails const * const details); void endExecute(TestDetails const * const details); RegisterThen registerParameter(ParameterizedTestAbstract* const parameterized); From 733b73dc87259803f98ccae7b8612e4f841ad4d6 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 8 Jun 2016 11:25:13 +0200 Subject: [PATCH 062/131] parameterized tests have names --- UnitTest++/ParameterizedMacros.h | 2 +- UnitTest++/ParameterizedTest.cpp | 5 +++-- UnitTest++/ParameterizedTest.h | 9 ++++++--- 3 files changed, 10 insertions(+), 6 deletions(-) diff --git a/UnitTest++/ParameterizedMacros.h b/UnitTest++/ParameterizedMacros.h index a32bc6d..7fda47c 100644 --- a/UnitTest++/ParameterizedMacros.h +++ b/UnitTest++/ParameterizedMacros.h @@ -15,7 +15,7 @@ ## SetUpBody \ } static parameterizedCreator ## IterationName ## Instance; \ \ - static UnitTest::ParameterizedTest<## Type> ## IterationName(parameterizedCreator ## IterationName ## Instance.parameters); + static UnitTest::ParameterizedTest<## Type> ## IterationName(parameterizedCreator ## IterationName ## Instance.parameters, #IterationName); #endif \ No newline at end of file diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index 77aa2bd..813afdc 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -5,8 +5,9 @@ using namespace std; using namespace UnitTest; -ParameterizedTestAbstract::ParameterizedTestAbstract() - : _iteration(0) +ParameterizedTestAbstract::ParameterizedTestAbstract(const string & name) + : _name(name), + _iteration(0) { } diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h index cde5287..5da5b58 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/ParameterizedTest.h @@ -16,9 +16,10 @@ namespace UnitTest { friend class ParameterizedManager; public: - ParameterizedTestAbstract(); + ParameterizedTestAbstract(const string & name); virtual ~ParameterizedTestAbstract(); size_t getIteration(); + const string & getName() const { return _name; } protected: void updateIteration(); @@ -29,6 +30,7 @@ namespace UnitTest bool hasMoreParameters(int advance = 0) const; void onNewIteration(bool first); + string _name; size_t _iteration; }; @@ -42,8 +44,9 @@ namespace UnitTest virtual void onNextIteration(Test* const test, T_Parameter current, size_t iteration) = 0; }; - ParameterizedTest(vector parameters, IParameterizedTestListener* const listener = nullptr) - : _parameters(parameters), + ParameterizedTest(vector parameters, const string & name = "", IParameterizedTestListener* const listener = nullptr) + : ParameterizedTestAbstract(name), + _parameters(parameters), _listener(listener) { } From 226b31fb3efec24516ae63a09aea27a51b61a302 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 8 Jun 2016 11:26:30 +0200 Subject: [PATCH 063/131] dump names with indexes ability --- UnitTest++/ParameterizedManager.cpp | 20 ++++++++++++++++++++ UnitTest++/ParameterizedManager.h | 1 + UnitTest++/ParameterizedTest.cpp | 9 +++++++++ UnitTest++/ParameterizedTest.h | 1 + 4 files changed, 31 insertions(+) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 5758332..5471d5e 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -107,3 +107,23 @@ ParameterizedManager::RegisterThen ParameterizedManager::registerParameter(Param } return RegisterThen::IDLE; } + + +const vector & ParameterizedManager::getStack(TestDetails const * const details) +{ + static vector emptyStored; + + if (!isCurrentTest(details)) + { + return emptyStored; + } + + return _stack; + /* + for (size_t i = 0; i < _stack.size(); i++) + { + outDump += _stack[i]->getNameCurrent(); + } + return true; + */ +} diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index 01b4f2d..583a79b 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -27,6 +27,7 @@ namespace UnitTest void beginExecute(TestDetails const * const details); void endExecute(TestDetails const * const details); RegisterThen registerParameter(ParameterizedTestAbstract* const parameterized); + const vector & getStack(TestDetails const * const details); private: ParameterizedManager(); diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index 813afdc..a7a5a05 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -1,5 +1,6 @@ #include "ParameterizedTest.h" +#include using namespace std; using namespace UnitTest; @@ -24,6 +25,14 @@ size_t ParameterizedTestAbstract::getIteration() } +string ParameterizedTestAbstract::getNameCurrent() const +{ + stringstream output; + output << (_name.empty() ? "unknown" : _name) << "[" << _iteration << "]"; + return output.str(); +} + + void ParameterizedTestAbstract::updateIteration() { ParameterizedManager::RegisterThen then = ParameterizedManager::getInstance().registerParameter(this); diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h index 5da5b58..1b43a45 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/ParameterizedTest.h @@ -20,6 +20,7 @@ namespace UnitTest virtual ~ParameterizedTestAbstract(); size_t getIteration(); const string & getName() const { return _name; } + string getNameCurrent() const; protected: void updateIteration(); From ac3718d123a48c3215a7f7848e05a81e841fa87d Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 8 Jun 2016 11:27:46 +0200 Subject: [PATCH 064/131] dump is added in reporter --- UnitTest++/TestResults.cpp | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/UnitTest++/TestResults.cpp b/UnitTest++/TestResults.cpp index e40ea70..6882162 100644 --- a/UnitTest++/TestResults.cpp +++ b/UnitTest++/TestResults.cpp @@ -2,6 +2,9 @@ #include "TestReporter.h" #include "TestDetails.h" +#include "MemoryOutStream.h" +#include "ParameterizedTest.h" +#include "ParameterizedManager.h" namespace UnitTest { @@ -31,7 +34,21 @@ namespace UnitTest { } if (m_testReporter) - m_testReporter->ReportFailure(test, failure); + { + MemoryOutStream stream; + stream << failure; + string parameterizedDump; + vector parameterizeds = ParameterizedManager::getInstance().getStack(&test); + if (!parameterizeds.empty()) + { + stream << endl << "With parameterized indexes:" << endl; + for (size_t i = 0; i < parameterizeds.size(); i++) + { + stream << " - " << parameterizeds[i]->getNameCurrent() << endl; + } + } + m_testReporter->ReportFailure(test, stream.GetText()); + } } void TestResults::OnTestFinish(TestDetails const& test, float secondsElapsed) From b5932594b55bb1a49ccd1a828360deea52450105 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 8 Jun 2016 11:37:54 +0200 Subject: [PATCH 065/131] removed zombie code --- UnitTest++/ParameterizedManager.cpp | 7 ------- 1 file changed, 7 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 5471d5e..e237511 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -119,11 +119,4 @@ const vector & ParameterizedManager::getStack(TestDe } return _stack; - /* - for (size_t i = 0; i < _stack.size(); i++) - { - outDump += _stack[i]->getNameCurrent(); - } - return true; - */ } From 5a4c648136396b39d51090f229d956a14ad0b5ef Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 8 Jun 2016 14:20:00 +0200 Subject: [PATCH 066/131] cleaned dependencies --- UnitTest++/ParameterizedManager.cpp | 1 - UnitTest++/ParameterizedManager.h | 2 +- UnitTest++/ParameterizedTest.cpp | 3 ++- UnitTest++/ParameterizedTest.h | 9 ++++----- UnitTest++/TestResults.cpp | 1 - 5 files changed, 7 insertions(+), 9 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index e237511..0e47a6d 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -1,7 +1,6 @@ #include "ParameterizedManager.h" #include "Test.h" -#include "ParameterizedTest.h" using namespace std; using namespace UnitTest; diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index 583a79b..93ae2b7 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -5,11 +5,11 @@ #include #include "TestDetails.h" #include "TestList.h" +#include "ParameterizedTest.h" namespace UnitTest { using namespace std; - class ParameterizedTestAbstract; class ParameterizedManager { diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index a7a5a05..dee7b4c 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -1,6 +1,7 @@ #include "ParameterizedTest.h" #include +#include "ParameterizedManager.h" using namespace std; using namespace UnitTest; @@ -73,5 +74,5 @@ void ParameterizedTestAbstract::onNewIteration(bool first) _iteration++; } - peekCurrentParameter(_iteration); + peekCurrentParameter(& ParameterizedManager::getInstance().getCurrentTest()->m_details, _iteration); } diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h index 1b43a45..971b710 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/ParameterizedTest.h @@ -6,7 +6,6 @@ #include "Test.h" #include "TestList.h" -#include "ParameterizedManager.h" namespace UnitTest { @@ -24,7 +23,7 @@ namespace UnitTest protected: void updateIteration(); - virtual void peekCurrentParameter(size_t iteration) = 0; + virtual void peekCurrentParameter(TestDetails const * const details, size_t iteration) = 0; virtual size_t parametersCount() const = 0; private: @@ -42,7 +41,7 @@ namespace UnitTest public: struct IParameterizedTestListener { - virtual void onNextIteration(Test* const test, T_Parameter current, size_t iteration) = 0; + virtual void onNextIteration(TestDetails const * const details, T_Parameter current, size_t iteration) = 0; }; ParameterizedTest(vector parameters, const string & name = "", IParameterizedTestListener* const listener = nullptr) @@ -63,11 +62,11 @@ namespace UnitTest } protected: - virtual void peekCurrentParameter(size_t iteration) override + virtual void peekCurrentParameter(TestDetails const * const details, size_t iteration) override { if (_listener != nullptr) { - _listener->onNextIteration(ParameterizedManager::getInstance().getCurrentTest(), _parameters[iteration], iteration); + _listener->onNextIteration(details, _parameters[iteration], iteration); } } diff --git a/UnitTest++/TestResults.cpp b/UnitTest++/TestResults.cpp index 6882162..1c696dd 100644 --- a/UnitTest++/TestResults.cpp +++ b/UnitTest++/TestResults.cpp @@ -3,7 +3,6 @@ #include "TestDetails.h" #include "MemoryOutStream.h" -#include "ParameterizedTest.h" #include "ParameterizedManager.h" namespace UnitTest { From c096b4471c41b27e44342a212b3528a369bf242b Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 8 Jun 2016 16:38:02 +0200 Subject: [PATCH 067/131] added "use several" test, bug found --- tests/TestParameterizedTest.cpp | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index 0943b0b..2770e65 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -129,6 +129,20 @@ SUITE(ParameterizedTestSimple) ////////// + string useSeveralTimes; + TEST(UseSeveralTimes_DoesNotIncrement) + { + useSeveralTimes += oneTwo(); + useSeveralTimes += oneTwo(); + } + + TEST(UseSeveralTimes_DoesNotIncrement_Verify) + { + CHECK_EQUAL("1122", useSeveralTimes); + } + + ////////// + struct Fixture {}; string withFixture; From dd2d98f32dd59917ba393883b7d57e4c2a26b863 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 8 Jun 2016 16:38:13 +0200 Subject: [PATCH 068/131] fixed bug --- UnitTest++/ParameterizedManager.cpp | 18 +++++++++++++----- UnitTest++/ParameterizedManager.h | 1 + 2 files changed, 14 insertions(+), 5 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 0e47a6d..64fe6e6 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -8,7 +8,8 @@ using namespace UnitTest; ParameterizedManager::ParameterizedManager() : _currentTest(nullptr), - _nextTestBackup(nullptr) + _nextTestBackup(nullptr), + _iterationDone(false) { } @@ -61,6 +62,7 @@ void ParameterizedManager::beginExecute(TestDetails const * const details) _currentTest = retrieveTest(details); _nextTestBackup = _currentTest->m_next; _currentTest->m_next = _currentTest; // Loop itself + _iterationDone = false; } @@ -90,20 +92,26 @@ void ParameterizedManager::endExecute(TestDetails const * const details) _currentTest = nullptr; _nextTestBackup = nullptr; } + _iterationDone = false; } ParameterizedManager::RegisterThen ParameterizedManager::registerParameter(ParameterizedTestAbstract* const parameterized) { - if (!_stack.empty() && _stack.back() == parameterized) - { - return RegisterThen::ITERATE; - } if (find(_stack.begin(), _stack.end(), parameterized) == _stack.end()) { + _iterationDone = true; _stack.push_back(parameterized); return RegisterThen::FIRST; } + if (!_iterationDone) + { + if (!_stack.empty() && _stack.back() == parameterized) + { + _iterationDone = true; + return RegisterThen::ITERATE; + } + } return RegisterThen::IDLE; } diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index 93ae2b7..fffc7e6 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -37,6 +37,7 @@ namespace UnitTest TestListNode* _currentTest; TestListNode* _nextTestBackup; vector _stack; + volatile bool _iterationDone; }; } From 1a2908119b55b95e6ea3171aa51991236335f609 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Thu, 9 Jun 2016 11:18:44 +0200 Subject: [PATCH 069/131] ability to reuse a parameterized test (and "redeclaration error" protection) --- UnitTest++/ParameterizedMacros.h | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/UnitTest++/ParameterizedMacros.h b/UnitTest++/ParameterizedMacros.h index 7fda47c..e2d15b9 100644 --- a/UnitTest++/ParameterizedMacros.h +++ b/UnitTest++/ParameterizedMacros.h @@ -3,6 +3,12 @@ #include "ParameterizedTest.h" +// For a local usage, use SET_SUITE_PARAMETERS directly in your "myTestSuite.cpp". +// If you want to reuse a parameterized from an other *.cpp file, use IMPORT_SUITE_PARAMETERS in the new file. +// If you want to generalize a parameterized (example: "myParameterizedGlobals.h"), use SET_SUITE_PARAMETERS in the *.cpp and IMPORT_SUITE_PARAMETERS in the *.h +// +// Warning: please do not use SET_SUITE_PARAMETERS in a *.h file, you might have unexpected duplicate instances ! + #define SET_SUITE_PARAMETERS(Type, IterationName, SetUpBody) \ class ParameterizedCreator ## IterationName\ @@ -13,9 +19,13 @@ private: \ void create() \ ## SetUpBody \ - } static parameterizedCreator ## IterationName ## Instance; \ + } parameterizedCreator ## IterationName ## Instance; \ \ - static UnitTest::ParameterizedTest<## Type> ## IterationName(parameterizedCreator ## IterationName ## Instance.parameters, #IterationName); + UnitTest::ParameterizedTest<## Type> ## IterationName(parameterizedCreator ## IterationName ## Instance.parameters, #IterationName); + + +#define IMPORT_SUITE_PARAMETERS(Type, IterationName) \ + extern UnitTest::ParameterizedTest<## Type> ## IterationName; #endif \ No newline at end of file From 5bd95da3bf49d619f2a4de9dfbfde7f724f64f5f Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Thu, 9 Jun 2016 12:02:52 +0200 Subject: [PATCH 070/131] more easy, 1 single macro --- UnitTest++/ParameterizedMacros.h | 28 +++++++++++----------------- 1 file changed, 11 insertions(+), 17 deletions(-) diff --git a/UnitTest++/ParameterizedMacros.h b/UnitTest++/ParameterizedMacros.h index e2d15b9..d9d2d09 100644 --- a/UnitTest++/ParameterizedMacros.h +++ b/UnitTest++/ParameterizedMacros.h @@ -3,29 +3,23 @@ #include "ParameterizedTest.h" -// For a local usage, use SET_SUITE_PARAMETERS directly in your "myTestSuite.cpp". -// If you want to reuse a parameterized from an other *.cpp file, use IMPORT_SUITE_PARAMETERS in the new file. -// If you want to generalize a parameterized (example: "myParameterizedGlobals.h"), use SET_SUITE_PARAMETERS in the *.cpp and IMPORT_SUITE_PARAMETERS in the *.h -// -// Warning: please do not use SET_SUITE_PARAMETERS in a *.h file, you might have unexpected duplicate instances ! - #define SET_SUITE_PARAMETERS(Type, IterationName, SetUpBody) \ - class ParameterizedCreator ## IterationName\ + class ParameterizedCreator ## IterationName \ { \ public: \ - ParameterizedCreator ## IterationName() { create(); } \ - vector<## Type> parameters; \ + ParameterizedCreator ## IterationName() : globalInstance(getGlobalInstance()) {} \ + UnitTest::ParameterizedTest<## Type> & globalInstance; \ private: \ - void create() \ - ## SetUpBody \ - } parameterizedCreator ## IterationName ## Instance; \ + static UnitTest::ParameterizedTest<## Type> & getGlobalInstance() \ + { \ + static UnitTest::ParameterizedTest<## Type> instance(create(), #IterationName); \ + return instance; \ + } \ + static vector<## Type> create() { vector<## Type> parameters; SetUpBody return parameters; } \ + } static parameterizedCreator ## IterationName ## Instance; \ \ - UnitTest::ParameterizedTest<## Type> ## IterationName(parameterizedCreator ## IterationName ## Instance.parameters, #IterationName); - - -#define IMPORT_SUITE_PARAMETERS(Type, IterationName) \ - extern UnitTest::ParameterizedTest<## Type> ## IterationName; + static UnitTest::ParameterizedTest<## Type> & ## IterationName(parameterizedCreator ## IterationName ## Instance.globalInstance) #endif \ No newline at end of file From b10381334f5dc3d3a42c821a97f22906efebacc6 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Thu, 9 Jun 2016 13:00:06 +0200 Subject: [PATCH 071/131] parameters order change --- UnitTest++/ParameterizedMacros.h | 2 +- UnitTest++/ParameterizedTest.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/UnitTest++/ParameterizedMacros.h b/UnitTest++/ParameterizedMacros.h index d9d2d09..5fd8c2d 100644 --- a/UnitTest++/ParameterizedMacros.h +++ b/UnitTest++/ParameterizedMacros.h @@ -13,7 +13,7 @@ private: \ static UnitTest::ParameterizedTest<## Type> & getGlobalInstance() \ { \ - static UnitTest::ParameterizedTest<## Type> instance(create(), #IterationName); \ + static UnitTest::ParameterizedTest<## Type> instance(#IterationName, create()); \ return instance; \ } \ static vector<## Type> create() { vector<## Type> parameters; SetUpBody return parameters; } \ diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h index 971b710..ccb5ac8 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/ParameterizedTest.h @@ -44,7 +44,7 @@ namespace UnitTest virtual void onNextIteration(TestDetails const * const details, T_Parameter current, size_t iteration) = 0; }; - ParameterizedTest(vector parameters, const string & name = "", IParameterizedTestListener* const listener = nullptr) + ParameterizedTest(const string & name, vector parameters, IParameterizedTestListener* const listener = nullptr) : ParameterizedTestAbstract(name), _parameters(parameters), _listener(listener) From 977172e4dda45d425f762b2a1a61aba240e918e1 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Thu, 9 Jun 2016 13:03:25 +0200 Subject: [PATCH 072/131] fixed test --- tests/TestParameterizedTest.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index 2770e65..559a997 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -29,7 +29,7 @@ SUITE(ParameterizedTestSimple) TEST(SimpleVoyelConcat_Verify) { - CHECK_EQUAL(parameterizedCreatorvowelInstance.parameters.size(), simpleVowelsHitCount); + CHECK_EQUAL(6, simpleVowelsHitCount); CHECK_EQUAL("AEIOUY", simpleVowels); } From 8859f8ec4ec85c30367c1a394565a3245b2844e3 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 15 Jun 2016 10:52:52 +0200 Subject: [PATCH 073/131] created test FailedMessage_ContainsIndexes --- tests/TestParameterizedTest.cpp | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index 559a997..0a4ef69 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -2,6 +2,8 @@ #include #include "UnitTest++/ParameterizedTest.h" +#include "ScopedCurrentTest.h" +#include "RecordingReporter.h" using namespace std; using namespace UnitTest; @@ -155,4 +157,35 @@ SUITE(ParameterizedTestSimple) { CHECK_EQUAL("12", withFixture); } + + ////////// + + TEST(FailedMessage_ContainsIndexes) + { + class FailingParameterizedTest : public Test + { + public: + FailingParameterizedTest() : Test("FailingParameterizedTest") {} + virtual void RunImpl() const + { + parameterizedSingle(); + REQUIRE CHECK(false); + } + }; + + RecordingReporter reporter; + TestResults results(&reporter); + { + ScopedCurrentTest scopedResults(results); + FailingParameterizedTest().Run(); + } + + MemoryOutStream expectedFailMessage; + expectedFailMessage + << "false" << endl + << "With parameterized indexes:" << endl + << " - " << parameterizedSingle.getName() << "[0]"; + + CHECK_EQUAL(expectedFailMessage.str(), string(reporter.lastFailedMessage)); + } } From 724c803bd514c873ccf8eb41ce260c8066f82a90 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 15 Jun 2016 11:23:14 +0200 Subject: [PATCH 074/131] fixed error message memory --- UnitTest++/ParameterizedManager.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 64fe6e6..1c14eea 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -37,7 +37,9 @@ TestListNode* const ParameterizedManager::retrieveTest(TestDetails const * const } } - throw runtime_error(string("Impossible to retrieve test ") + details->testName); + string errorMessage = "Impossible to retrieve test "; + errorMessage += details->testName; + throw runtime_error(errorMessage); } From ec13c8d14029961c90fee4a8e3f9a08107b465f2 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 15 Jun 2016 11:36:27 +0200 Subject: [PATCH 075/131] method for check if it is twice the same test from TestDetails --- UnitTest++/TestDetails.cpp | 25 +++++++++++++++++++++++++ UnitTest++/TestDetails.h | 2 ++ 2 files changed, 27 insertions(+) diff --git a/UnitTest++/TestDetails.cpp b/UnitTest++/TestDetails.cpp index deb6639..61c6a65 100644 --- a/UnitTest++/TestDetails.cpp +++ b/UnitTest++/TestDetails.cpp @@ -1,4 +1,5 @@ #include "TestDetails.h" +#include 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 index cf6f1d3..1dac653 100644 --- 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&); From c0fad1bbf992295ea3e8e067d1c2972f864a2c2c Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 15 Jun 2016 11:45:39 +0200 Subject: [PATCH 076/131] added tests --- tests/TestTestDetails.cpp | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 tests/TestTestDetails.cpp diff --git a/tests/TestTestDetails.cpp b/tests/TestTestDetails.cpp new file mode 100644 index 0000000..4a3c8c4 --- /dev/null +++ b/tests/TestTestDetails.cpp @@ -0,0 +1,35 @@ +#include "UnitTest++/UnitTestPP.h" +#include "UnitTest++/TestDetails.h" + +using namespace UnitTest; + +namespace { + + TEST(SameTest_SameValues_AreEqual) + { + TestDetails details1("test1", "suite1", "file1", 1234); + TestDetails details2("test1", "suite1", "file1", 1234); + CHECK(details1.sameTest(details2)); + } + + TEST(SameTest_DifferentValues_AreNotEqual) + { + TestDetails details1("test1", "suite1", "file1", 1234); + TestDetails details2("test2", "suite2", "file2", 4321); + CHECK(!details1.sameTest(details2)); + } + + TEST(SameTest_LineNumber_AreIgnored) + { + TestDetails details1("test1", "suite1", "file1", 1234); + TestDetails details2("test1", "suite1", "file1", 0); + CHECK(details1.sameTest(details2)); + } + + TEST(SameTest_CopyConstructor_AreEqual) + { + TestDetails details1("test1", "suite1", "file1", 1234); + TestDetails details2(details1, 4321); + CHECK(details1.sameTest(details2)); + } +} From c365265a52dd3c55c109ef6e912ef62e3860a039 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 15 Jun 2016 11:46:16 +0200 Subject: [PATCH 077/131] use TestDetails::sameTest in parameterized --- UnitTest++/ParameterizedManager.cpp | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 1c14eea..9d412c2 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -31,6 +31,7 @@ TestListNode* const ParameterizedManager::retrieveTest(TestDetails const * const //TODO This workaround is a bit too complicated, why not simply add pointer to current test in class CurrentTest ? for (TestListNode* iNode = Test::GetTestList().GetHead(); iNode != nullptr; iNode = iNode->m_next) { + // Note: do not use TestDetails::sameTest here for optimisation reason if (&iNode->m_test->m_details == details) { return iNode; @@ -51,7 +52,12 @@ Test* const ParameterizedManager::getCurrentTest() const bool ParameterizedManager::isCurrentTest(TestDetails const * const details) const { - return (_currentTest != nullptr && &_currentTest->m_test->m_details == details); + if (_currentTest == nullptr) + { + return false; + } + + return _currentTest->m_test->m_details.sameTest(*details); } From 17f55d9db17fd4199a24cf5b8c02b2885c5ef9fc Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 15 Jun 2016 12:04:43 +0200 Subject: [PATCH 078/131] fixed test FailedMessage_ContainsIndexes --- tests/TestParameterizedTest.cpp | 25 ++++++++++++++++++++----- 1 file changed, 20 insertions(+), 5 deletions(-) diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index 0a4ef69..4793257 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -160,12 +160,24 @@ SUITE(ParameterizedTestSimple) ////////// + string makeMessageReadable(string message) + { + string::size_type pos = 0; + while ((pos = message.find_first_of("\r\n", pos)) != string::npos) + { + message.erase(pos, 1); + } + message = "<" + message + ">"; + return message; + } + TEST(FailedMessage_ContainsIndexes) { class FailingParameterizedTest : public Test { public: - FailingParameterizedTest() : Test("FailingParameterizedTest") {} + FailingParameterizedTest() + : Test(CurrentTest::Details()->testName, CurrentTest::Details()->suiteName, CurrentTest::Details()->filename) {} virtual void RunImpl() const { parameterizedSingle(); @@ -180,12 +192,15 @@ SUITE(ParameterizedTestSimple) FailingParameterizedTest().Run(); } - MemoryOutStream expectedFailMessage; + // Improve error reading: remove line breaks and add <> + string str = makeMessageReadable(reporter.lastFailedMessage); + + ostringstream expectedFailMessage; expectedFailMessage - << "false" << endl + << "false" << endl // this is because of the failing test << "With parameterized indexes:" << endl - << " - " << parameterizedSingle.getName() << "[0]"; + << " - " << parameterizedSingle.getName() << "[0]" << endl; - CHECK_EQUAL(expectedFailMessage.str(), string(reporter.lastFailedMessage)); + CHECK_EQUAL(makeMessageReadable(expectedFailMessage.str()), str); } } From fd9e19e88292e0e176460021b7bbefa56cd3c5a2 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 15 Jun 2016 12:14:02 +0200 Subject: [PATCH 079/131] changed sentence --- UnitTest++/TestResults.cpp | 2 +- tests/TestParameterizedTest.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/UnitTest++/TestResults.cpp b/UnitTest++/TestResults.cpp index 1c696dd..7522d32 100644 --- a/UnitTest++/TestResults.cpp +++ b/UnitTest++/TestResults.cpp @@ -40,7 +40,7 @@ namespace UnitTest { vector parameterizeds = ParameterizedManager::getInstance().getStack(&test); if (!parameterizeds.empty()) { - stream << endl << "With parameterized indexes:" << endl; + stream << endl << "With parameters:" << endl; for (size_t i = 0; i < parameterizeds.size(); i++) { stream << " - " << parameterizeds[i]->getNameCurrent() << endl; diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index 4793257..acda488 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -198,7 +198,7 @@ SUITE(ParameterizedTestSimple) ostringstream expectedFailMessage; expectedFailMessage << "false" << endl // this is because of the failing test - << "With parameterized indexes:" << endl + << "With parameters:" << endl << " - " << parameterizedSingle.getName() << "[0]" << endl; CHECK_EQUAL(makeMessageReadable(expectedFailMessage.str()), str); From 269cc159bb731bbd1714b53d5bdc10ea8231dbd8 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 17 Jun 2016 16:29:33 +0200 Subject: [PATCH 080/131] parameters listed on a single line --- UnitTest++/TestResults.cpp | 8 ++++++-- tests/TestParameterizedTest.cpp | 27 ++++++++------------------- 2 files changed, 14 insertions(+), 21 deletions(-) diff --git a/UnitTest++/TestResults.cpp b/UnitTest++/TestResults.cpp index 7522d32..00a9aee 100644 --- a/UnitTest++/TestResults.cpp +++ b/UnitTest++/TestResults.cpp @@ -40,10 +40,14 @@ namespace UnitTest { vector parameterizeds = ParameterizedManager::getInstance().getStack(&test); if (!parameterizeds.empty()) { - stream << endl << "With parameters:" << endl; + stream << " Parameters: "; for (size_t i = 0; i < parameterizeds.size(); i++) { - stream << " - " << parameterizeds[i]->getNameCurrent() << endl; + if (i != 0) + { + stream << ", "; + } + stream << parameterizeds[i]->getNameCurrent(); } } m_testReporter->ReportFailure(test, stream.GetText()); diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index acda488..f5673b7 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -160,16 +160,9 @@ SUITE(ParameterizedTestSimple) ////////// - string makeMessageReadable(string message) - { - string::size_type pos = 0; - while ((pos = message.find_first_of("\r\n", pos)) != string::npos) - { - message.erase(pos, 1); - } - message = "<" + message + ">"; - return message; - } + SET_SUITE_PARAMETERS(int, parameterizedSingleBis, { + parameters.push_back(3); + }); TEST(FailedMessage_ContainsIndexes) { @@ -181,6 +174,7 @@ SUITE(ParameterizedTestSimple) virtual void RunImpl() const { parameterizedSingle(); + parameterizedSingleBis(); REQUIRE CHECK(false); } }; @@ -192,15 +186,10 @@ SUITE(ParameterizedTestSimple) FailingParameterizedTest().Run(); } - // Improve error reading: remove line breaks and add <> - string str = makeMessageReadable(reporter.lastFailedMessage); - - ostringstream expectedFailMessage; - expectedFailMessage - << "false" << endl // this is because of the failing test - << "With parameters:" << endl - << " - " << parameterizedSingle.getName() << "[0]" << endl; + string expectedFailMessage = "false Parameters: " + + parameterizedSingle.getName() + "[0], " + + parameterizedSingleBis.getName() + "[0]"; - CHECK_EQUAL(makeMessageReadable(expectedFailMessage.str()), str); + CHECK_EQUAL(expectedFailMessage, string(reporter.lastFailedMessage)); } } From 7c89e14aecdafd2e194ec9f0248a69582903f24c Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Mon, 20 Jun 2016 10:00:45 +0200 Subject: [PATCH 081/131] loop only if there is a parameter --- UnitTest++/ParameterizedManager.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 9d412c2..c3fe27e 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -69,7 +69,6 @@ void ParameterizedManager::beginExecute(TestDetails const * const details) } _currentTest = retrieveTest(details); _nextTestBackup = _currentTest->m_next; - _currentTest->m_next = _currentTest; // Loop itself _iterationDone = false; } @@ -109,6 +108,7 @@ ParameterizedManager::RegisterThen ParameterizedManager::registerParameter(Param if (find(_stack.begin(), _stack.end(), parameterized) == _stack.end()) { _iterationDone = true; + _currentTest->m_next = _currentTest; // Loop itself _stack.push_back(parameterized); return RegisterThen::FIRST; } From 8b1cb0b1d01c23d1e5665df7a154f1c2fb26b11b Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Mon, 20 Jun 2016 10:14:55 +0200 Subject: [PATCH 082/131] cleaning --- UnitTest++/ParameterizedManager.cpp | 14 +++++++++----- UnitTest++/ParameterizedManager.h | 2 +- 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index c3fe27e..c565afd 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -46,7 +46,12 @@ TestListNode* const ParameterizedManager::retrieveTest(TestDetails const * const Test* const ParameterizedManager::getCurrentTest() const { - return (_currentTest != nullptr) ? _currentTest->m_test : nullptr; + if (_currentTest == nullptr) + { + return nullptr; + } + + return _currentTest->m_test; } @@ -99,6 +104,7 @@ void ParameterizedManager::endExecute(TestDetails const * const details) _currentTest = nullptr; _nextTestBackup = nullptr; } + _iterationDone = false; } @@ -124,14 +130,12 @@ ParameterizedManager::RegisterThen ParameterizedManager::registerParameter(Param } -const vector & ParameterizedManager::getStack(TestDetails const * const details) +const vector & ParameterizedManager::getStack(TestDetails const * const details) const { - static vector emptyStored; - if (!isCurrentTest(details)) { + static vector emptyStored; return emptyStored; } - return _stack; } diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index fffc7e6..e96988d 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -27,7 +27,7 @@ namespace UnitTest void beginExecute(TestDetails const * const details); void endExecute(TestDetails const * const details); RegisterThen registerParameter(ParameterizedTestAbstract* const parameterized); - const vector & getStack(TestDetails const * const details); + const vector & getStack(TestDetails const * const details) const; private: ParameterizedManager(); From 4373207200c53e911a730cd35be2c616596bb5b7 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Mon, 20 Jun 2016 10:46:00 +0200 Subject: [PATCH 083/131] moved iteration FIRST/IDLE/ITERATE handling in manager --- UnitTest++/ParameterizedManager.cpp | 18 ++++++++++++++++++ UnitTest++/ParameterizedManager.h | 17 +++++++++-------- UnitTest++/ParameterizedTest.cpp | 10 +--------- 3 files changed, 28 insertions(+), 17 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index c565afd..0d296fc 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -109,6 +109,24 @@ void ParameterizedManager::endExecute(TestDetails const * const details) } +void ParameterizedManager::updateParameter(ParameterizedTestAbstract* const parameterized) +{ + RegisterThen then = registerParameter(parameterized); + if (then == ParameterizedManager::IDLE) + { + return; + } + if (then == ParameterizedManager::FIRST) + { + parameterized->onNewIteration(true); + } + else if (then == ParameterizedManager::ITERATE) + { + parameterized->onNewIteration(false); + } +} + + ParameterizedManager::RegisterThen ParameterizedManager::registerParameter(ParameterizedTestAbstract* const parameterized) { if (find(_stack.begin(), _stack.end(), parameterized) == _stack.end()) diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index e96988d..4b3d5c6 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -14,25 +14,26 @@ namespace UnitTest class ParameterizedManager { public: - enum RegisterThen - { - FIRST, - ITERATE, - IDLE - }; - static ParameterizedManager & getInstance(); Test* const getCurrentTest() const; bool isCurrentTest(TestDetails const * const details) const; void beginExecute(TestDetails const * const details); void endExecute(TestDetails const * const details); - RegisterThen registerParameter(ParameterizedTestAbstract* const parameterized); + void updateParameter(ParameterizedTestAbstract* const parameterized); const vector & getStack(TestDetails const * const details) const; private: + enum RegisterThen //TODO Can remove this ? + { + FIRST, + ITERATE, + IDLE + }; + ParameterizedManager(); virtual ~ParameterizedManager(); TestListNode* const retrieveTest(TestDetails const * const details); + RegisterThen registerParameter(ParameterizedTestAbstract* const parameterized); TestListNode* _currentTest; TestListNode* _nextTestBackup; diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index dee7b4c..8e2819f 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -36,15 +36,7 @@ string ParameterizedTestAbstract::getNameCurrent() const void ParameterizedTestAbstract::updateIteration() { - ParameterizedManager::RegisterThen then = ParameterizedManager::getInstance().registerParameter(this); - if (then == ParameterizedManager::FIRST) - { - onNewIteration(true); - } - else if (then == ParameterizedManager::ITERATE) - { - onNewIteration(false); - } + ParameterizedManager::getInstance().updateParameter(this); } From d14a47d470421b2e4268c6c49f53ac2f9b1ad9a9 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Mon, 20 Jun 2016 11:57:23 +0200 Subject: [PATCH 084/131] created excludeIndex functionality --- UnitTest++/ParameterizedManager.cpp | 43 ++++++++++++++++++++-- UnitTest++/ParameterizedManager.h | 5 ++- UnitTest++/ParameterizedTest.cpp | 7 ++++ UnitTest++/ParameterizedTest.h | 7 ++++ tests/TestParameterizedTest.cpp | 56 +++++++++++++++++++++++++++++ 5 files changed, 114 insertions(+), 4 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 0d296fc..8731887 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -74,6 +74,7 @@ void ParameterizedManager::beginExecute(TestDetails const * const details) } _currentTest = retrieveTest(details); _nextTestBackup = _currentTest->m_next; + _excludedIndexes.clear(); _iterationDone = false; } @@ -111,11 +112,24 @@ void ParameterizedManager::endExecute(TestDetails const * const details) void ParameterizedManager::updateParameter(ParameterizedTestAbstract* const parameterized) { - RegisterThen then = registerParameter(parameterized); - if (then == ParameterizedManager::IDLE) + const vector & excludedIndexes = _excludedIndexes[parameterized]; + bool repeat = true; + while (repeat) { - return; + iterate(parameterized); + + repeat = (find(excludedIndexes.begin(), excludedIndexes.end(), parameterized->_iteration) != excludedIndexes.end()); + if (repeat) + { + _iterationDone = false; + } } +} + + +void ParameterizedManager::iterate(ParameterizedTestAbstract* const parameterized) +{ + RegisterThen then = registerParameter(parameterized); if (then == ParameterizedManager::FIRST) { parameterized->onNewIteration(true); @@ -148,6 +162,29 @@ ParameterizedManager::RegisterThen ParameterizedManager::registerParameter(Param } +void ParameterizedManager::excludeIndex(ParameterizedTestAbstract* const parameterized, size_t index) +{ + vector & excludedIndexes = _excludedIndexes[parameterized]; + + if (index >= parameterized->parametersCount()) + { + throw out_of_range("excluded index is out of range"); + } + + if (find(excludedIndexes.begin(), excludedIndexes.end(), index) != excludedIndexes.end()) + { + return; // already inserted + } + + if (excludedIndexes.size() + 1 == parameterized->parametersCount()) + { + throw runtime_error("all parameters have been excluded, can not proceed"); + } + + excludedIndexes.push_back(index); +} + + const vector & ParameterizedManager::getStack(TestDetails const * const details) const { if (!isCurrentTest(details)) diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index 4b3d5c6..32fcb2a 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -2,7 +2,7 @@ #define UNITTEST_PARAMETERIZEDMANAGER_H #include -#include +#include #include "TestDetails.h" #include "TestList.h" #include "ParameterizedTest.h" @@ -20,6 +20,7 @@ namespace UnitTest void beginExecute(TestDetails const * const details); void endExecute(TestDetails const * const details); void updateParameter(ParameterizedTestAbstract* const parameterized); + void excludeIndex(ParameterizedTestAbstract* const parameterized, size_t index); const vector & getStack(TestDetails const * const details) const; private: @@ -33,11 +34,13 @@ namespace UnitTest ParameterizedManager(); virtual ~ParameterizedManager(); TestListNode* const retrieveTest(TestDetails const * const details); + void iterate(ParameterizedTestAbstract* const parameterized); RegisterThen registerParameter(ParameterizedTestAbstract* const parameterized); TestListNode* _currentTest; TestListNode* _nextTestBackup; vector _stack; + unordered_map> _excludedIndexes; volatile bool _iterationDone; }; } diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index 8e2819f..4bd9117 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -68,3 +68,10 @@ void ParameterizedTestAbstract::onNewIteration(bool first) peekCurrentParameter(& ParameterizedManager::getInstance().getCurrentTest()->m_details, _iteration); } + + +ParameterizedTestAbstract & ParameterizedTestAbstract::excludeIndex(size_t index) +{ + ParameterizedManager::getInstance().excludeIndex(this, index); + return *this; +} diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h index ccb5ac8..4e4aca8 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/ParameterizedTest.h @@ -20,6 +20,7 @@ namespace UnitTest size_t getIteration(); const string & getName() const { return _name; } string getNameCurrent() const; + ParameterizedTestAbstract & excludeIndex(size_t index); protected: void updateIteration(); @@ -61,6 +62,12 @@ namespace UnitTest return _parameters; } + ParameterizedTest & excludeIndex(size_t index) + { + ParameterizedTestAbstract::excludeIndex(index); + return *this; + } + protected: virtual void peekCurrentParameter(TestDetails const * const details, size_t iteration) override { diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index f5673b7..6fdf4dd 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -192,4 +192,60 @@ SUITE(ParameterizedTestSimple) CHECK_EQUAL(expectedFailMessage, string(reporter.lastFailedMessage)); } + + ////////// + + TEST(ExcludeIndex_OutOfRange_ThrowsException) + { + size_t out = vowel.parameters().size(); + CHECK_THROW(vowel.excludeIndex(out), out_of_range); + } + + TEST(ExcludeIndex_ExcludeAll_ThrowsException) + { + size_t last = vowel.parameters().size()-1; + for (size_t i = 0; i < last; i++) + { + vowel.excludeIndex(i); + } + + CHECK_THROW(vowel.excludeIndex(last), runtime_error); + } + + ////////// + + string excludeSomeVowels; + TEST(ExcludeIndex_ExcludeSome) + { + vowel + .excludeIndex(1) // "E" + .excludeIndex(4); // "U" + + excludeSomeVowels += vowel(); + } + + TEST(ExcludeIndex_ExcludeSome_Verify) + { + CHECK_EQUAL("AIOY", excludeSomeVowels); + } + + ////////// + + string excludeWithNested; + TEST(ExcludeIndex_ExcludeWithNested) + { + vowel + .excludeIndex(0) // "A" + .excludeIndex(2) // "I" + .excludeIndex(3) // "O" + .excludeIndex(4); // "U" + + excludeWithNested += vowel(); + excludeWithNested += oneTwo(); + } + + TEST(ExcludeIndex_ExcludeWithNested_Verify) + { + CHECK_EQUAL("E1E2Y1Y2", excludeWithNested); + } } From 24bf5919006ff5ad64f3a5ca6b024453b8efd492 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Mon, 20 Jun 2016 12:17:44 +0200 Subject: [PATCH 085/131] forbid exclude while iterating --- UnitTest++/ParameterizedManager.cpp | 5 +++++ tests/TestParameterizedTest.cpp | 11 ++++++++++- 2 files changed, 15 insertions(+), 1 deletion(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 8731887..4687a89 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -164,6 +164,11 @@ ParameterizedManager::RegisterThen ParameterizedManager::registerParameter(Param void ParameterizedManager::excludeIndex(ParameterizedTestAbstract* const parameterized, size_t index) { + if (_iterationDone) + { + throw runtime_error("can not exclude indexes after iteration began"); + } + vector & excludedIndexes = _excludedIndexes[parameterized]; if (index >= parameterized->parametersCount()) diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index 6fdf4dd..4ff083c 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -203,7 +203,7 @@ SUITE(ParameterizedTestSimple) TEST(ExcludeIndex_ExcludeAll_ThrowsException) { - size_t last = vowel.parameters().size()-1; + size_t last = vowel.parameters().size() - 1; for (size_t i = 0; i < last; i++) { vowel.excludeIndex(i); @@ -248,4 +248,13 @@ SUITE(ParameterizedTestSimple) { CHECK_EQUAL("E1E2Y1Y2", excludeWithNested); } + + ////////// + + TEST(ExcludeIndex_ExcludeAfterIterationBegan_ThrowsException) + { + vowel.excludeIndex(0); + vowel(); + CHECK_THROW(vowel.excludeIndex(1), runtime_error); + } } From 423c03b570092d60b7abba7f59e66b5088510d4a Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Mon, 20 Jun 2016 12:21:30 +0200 Subject: [PATCH 086/131] rename functionality to "ignoreIndex" --- UnitTest++/ParameterizedManager.cpp | 22 ++++++------- UnitTest++/ParameterizedManager.h | 4 +-- UnitTest++/ParameterizedTest.cpp | 4 +-- UnitTest++/ParameterizedTest.h | 6 ++-- tests/TestParameterizedTest.cpp | 50 ++++++++++++++--------------- 5 files changed, 43 insertions(+), 43 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 4687a89..04a3cdd 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -74,7 +74,7 @@ void ParameterizedManager::beginExecute(TestDetails const * const details) } _currentTest = retrieveTest(details); _nextTestBackup = _currentTest->m_next; - _excludedIndexes.clear(); + _ignoredIndexes.clear(); _iterationDone = false; } @@ -112,13 +112,13 @@ void ParameterizedManager::endExecute(TestDetails const * const details) void ParameterizedManager::updateParameter(ParameterizedTestAbstract* const parameterized) { - const vector & excludedIndexes = _excludedIndexes[parameterized]; + const vector & ignoredIndexes = _ignoredIndexes[parameterized]; bool repeat = true; while (repeat) { iterate(parameterized); - repeat = (find(excludedIndexes.begin(), excludedIndexes.end(), parameterized->_iteration) != excludedIndexes.end()); + repeat = (find(ignoredIndexes.begin(), ignoredIndexes.end(), parameterized->_iteration) != ignoredIndexes.end()); if (repeat) { _iterationDone = false; @@ -162,31 +162,31 @@ ParameterizedManager::RegisterThen ParameterizedManager::registerParameter(Param } -void ParameterizedManager::excludeIndex(ParameterizedTestAbstract* const parameterized, size_t index) +void ParameterizedManager::ignoreIndex(ParameterizedTestAbstract* const parameterized, size_t index) { if (_iterationDone) { - throw runtime_error("can not exclude indexes after iteration began"); + throw runtime_error("can not ignore indexes after iteration began"); } - vector & excludedIndexes = _excludedIndexes[parameterized]; + vector & ignoredIndexes = _ignoredIndexes[parameterized]; if (index >= parameterized->parametersCount()) { - throw out_of_range("excluded index is out of range"); + throw out_of_range("ignore index is out of range"); } - if (find(excludedIndexes.begin(), excludedIndexes.end(), index) != excludedIndexes.end()) + if (find(ignoredIndexes.begin(), ignoredIndexes.end(), index) != ignoredIndexes.end()) { return; // already inserted } - if (excludedIndexes.size() + 1 == parameterized->parametersCount()) + if (ignoredIndexes.size() + 1 == parameterized->parametersCount()) { - throw runtime_error("all parameters have been excluded, can not proceed"); + throw runtime_error("all parameters have been ignored, can not proceed"); } - excludedIndexes.push_back(index); + ignoredIndexes.push_back(index); } diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index 32fcb2a..f2bc798 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -20,7 +20,7 @@ namespace UnitTest void beginExecute(TestDetails const * const details); void endExecute(TestDetails const * const details); void updateParameter(ParameterizedTestAbstract* const parameterized); - void excludeIndex(ParameterizedTestAbstract* const parameterized, size_t index); + void ignoreIndex(ParameterizedTestAbstract* const parameterized, size_t index); const vector & getStack(TestDetails const * const details) const; private: @@ -40,7 +40,7 @@ namespace UnitTest TestListNode* _currentTest; TestListNode* _nextTestBackup; vector _stack; - unordered_map> _excludedIndexes; + unordered_map> _ignoredIndexes; volatile bool _iterationDone; }; } diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index 4bd9117..9507ee2 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -70,8 +70,8 @@ void ParameterizedTestAbstract::onNewIteration(bool first) } -ParameterizedTestAbstract & ParameterizedTestAbstract::excludeIndex(size_t index) +ParameterizedTestAbstract & ParameterizedTestAbstract::ignoreIndex(size_t index) { - ParameterizedManager::getInstance().excludeIndex(this, index); + ParameterizedManager::getInstance().ignoreIndex(this, index); return *this; } diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h index 4e4aca8..ea867d0 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/ParameterizedTest.h @@ -20,7 +20,7 @@ namespace UnitTest size_t getIteration(); const string & getName() const { return _name; } string getNameCurrent() const; - ParameterizedTestAbstract & excludeIndex(size_t index); + ParameterizedTestAbstract & ignoreIndex(size_t index); protected: void updateIteration(); @@ -62,9 +62,9 @@ namespace UnitTest return _parameters; } - ParameterizedTest & excludeIndex(size_t index) + ParameterizedTest & ignoreIndex(size_t index) { - ParameterizedTestAbstract::excludeIndex(index); + ParameterizedTestAbstract::ignoreIndex(index); return *this; } diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index 4ff083c..5530509 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -195,66 +195,66 @@ SUITE(ParameterizedTestSimple) ////////// - TEST(ExcludeIndex_OutOfRange_ThrowsException) + TEST(IgnoreIndex_OutOfRange_ThrowsException) { size_t out = vowel.parameters().size(); - CHECK_THROW(vowel.excludeIndex(out), out_of_range); + CHECK_THROW(vowel.ignoreIndex(out), out_of_range); } - TEST(ExcludeIndex_ExcludeAll_ThrowsException) + TEST(IgnoreIndex_IgnoreAll_ThrowsException) { size_t last = vowel.parameters().size() - 1; for (size_t i = 0; i < last; i++) { - vowel.excludeIndex(i); + vowel.ignoreIndex(i); } - CHECK_THROW(vowel.excludeIndex(last), runtime_error); + CHECK_THROW(vowel.ignoreIndex(last), runtime_error); } ////////// - string excludeSomeVowels; - TEST(ExcludeIndex_ExcludeSome) + string ignoreSomeVowels; + TEST(IgnoreIndex_IgnoreSome) { vowel - .excludeIndex(1) // "E" - .excludeIndex(4); // "U" + .ignoreIndex(1) // "E" + .ignoreIndex(4); // "U" - excludeSomeVowels += vowel(); + ignoreSomeVowels += vowel(); } - TEST(ExcludeIndex_ExcludeSome_Verify) + TEST(IgnoreIndex_IgnoreSome_Verify) { - CHECK_EQUAL("AIOY", excludeSomeVowels); + CHECK_EQUAL("AIOY", ignoreSomeVowels); } ////////// - string excludeWithNested; - TEST(ExcludeIndex_ExcludeWithNested) + string ignoreWithNested; + TEST(IgnoreIndex_IgnoreWithNested) { vowel - .excludeIndex(0) // "A" - .excludeIndex(2) // "I" - .excludeIndex(3) // "O" - .excludeIndex(4); // "U" + .ignoreIndex(0) // "A" + .ignoreIndex(2) // "I" + .ignoreIndex(3) // "O" + .ignoreIndex(4); // "U" - excludeWithNested += vowel(); - excludeWithNested += oneTwo(); + ignoreWithNested += vowel(); + ignoreWithNested += oneTwo(); } - TEST(ExcludeIndex_ExcludeWithNested_Verify) + TEST(IgnoreIndex_IgnoreWithNested_Verify) { - CHECK_EQUAL("E1E2Y1Y2", excludeWithNested); + CHECK_EQUAL("E1E2Y1Y2", ignoreWithNested); } ////////// - TEST(ExcludeIndex_ExcludeAfterIterationBegan_ThrowsException) + TEST(IgnoreIndex_IgnoreAfterIterationBegan_ThrowsException) { - vowel.excludeIndex(0); + vowel.ignoreIndex(0); vowel(); - CHECK_THROW(vowel.excludeIndex(1), runtime_error); + CHECK_THROW(vowel.ignoreIndex(1), runtime_error); } } From 58d402affda3dc6d04a5118cb53c3494b1dd1e19 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Mon, 20 Jun 2016 14:04:32 +0200 Subject: [PATCH 087/131] ignore by value --- UnitTest++/ParameterizedTest.h | 10 ++++++++++ tests/TestParameterizedTest.cpp | 17 +++++++++++++++++ 2 files changed, 27 insertions(+) diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h index ea867d0..ec6b95e 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/ParameterizedTest.h @@ -68,6 +68,16 @@ namespace UnitTest return *this; } + ParameterizedTest & ignore(T_Parameter p) + { + vector::iterator it = find(_parameters.begin(), _parameters.end(), p); + if (it == _parameters.end()) + { + return *this; + } + return ignoreIndex(it - _parameters.begin()); + } + protected: virtual void peekCurrentParameter(TestDetails const * const details, size_t iteration) override { diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index 5530509..ef0e570 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -257,4 +257,21 @@ SUITE(ParameterizedTestSimple) vowel(); CHECK_THROW(vowel.ignoreIndex(1), runtime_error); } + + ////////// + + string ignoreSomeVowelsByValue; + TEST(Ignore_IgnoreSome) + { + vowel + .ignore("E") + .ignore("U"); + + ignoreSomeVowelsByValue += vowel(); + } + + TEST(Ignore_IgnoreSome_Verify) + { + CHECK_EQUAL("AIOY", ignoreSomeVowelsByValue); + } } From 119c7e23a950cec2787d84f64f53d7d300ad7180 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Mon, 20 Jun 2016 16:18:46 +0200 Subject: [PATCH 088/131] simplification --- UnitTest++/ParameterizedManager.cpp | 23 ++++++++++------------- UnitTest++/ParameterizedManager.h | 9 +-------- 2 files changed, 11 insertions(+), 21 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 04a3cdd..fa0fd83 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -28,10 +28,9 @@ ParameterizedManager & ParameterizedManager::getInstance() TestListNode* const ParameterizedManager::retrieveTest(TestDetails const * const details) { - //TODO This workaround is a bit too complicated, why not simply add pointer to current test in class CurrentTest ? for (TestListNode* iNode = Test::GetTestList().GetHead(); iNode != nullptr; iNode = iNode->m_next) { - // Note: do not use TestDetails::sameTest here for optimisation reason + // Warning: do not use TestDetails::sameTest here for optimisation reason if (&iNode->m_test->m_details == details) { return iNode; @@ -129,36 +128,34 @@ void ParameterizedManager::updateParameter(ParameterizedTestAbstract* const para void ParameterizedManager::iterate(ParameterizedTestAbstract* const parameterized) { - RegisterThen then = registerParameter(parameterized); - if (then == ParameterizedManager::FIRST) + bool firstIteration = false; + if (registerParameter(parameterized, firstIteration)) { - parameterized->onNewIteration(true); - } - else if (then == ParameterizedManager::ITERATE) - { - parameterized->onNewIteration(false); + parameterized->onNewIteration(firstIteration); } } -ParameterizedManager::RegisterThen ParameterizedManager::registerParameter(ParameterizedTestAbstract* const parameterized) +bool ParameterizedManager::registerParameter(ParameterizedTestAbstract* const parameterized, bool & outFirstIteration) { if (find(_stack.begin(), _stack.end(), parameterized) == _stack.end()) { _iterationDone = true; _currentTest->m_next = _currentTest; // Loop itself _stack.push_back(parameterized); - return RegisterThen::FIRST; + outFirstIteration = true; + return true; } if (!_iterationDone) { if (!_stack.empty() && _stack.back() == parameterized) { _iterationDone = true; - return RegisterThen::ITERATE; + outFirstIteration = false; + return true; } } - return RegisterThen::IDLE; + return false; } diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index f2bc798..6f19516 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -24,18 +24,11 @@ namespace UnitTest const vector & getStack(TestDetails const * const details) const; private: - enum RegisterThen //TODO Can remove this ? - { - FIRST, - ITERATE, - IDLE - }; - ParameterizedManager(); virtual ~ParameterizedManager(); TestListNode* const retrieveTest(TestDetails const * const details); void iterate(ParameterizedTestAbstract* const parameterized); - RegisterThen registerParameter(ParameterizedTestAbstract* const parameterized); + bool registerParameter(ParameterizedTestAbstract* const parameterized, bool & outFirst); TestListNode* _currentTest; TestListNode* _nextTestBackup; From e583e3df175f6a85b4ea87a89498782c1dcf91e3 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Mon, 20 Jun 2016 16:40:23 +0200 Subject: [PATCH 089/131] clean ignored indexes only at end of iteration cycle --- UnitTest++/ParameterizedManager.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index fa0fd83..fd00447 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -73,7 +73,6 @@ void ParameterizedManager::beginExecute(TestDetails const * const details) } _currentTest = retrieveTest(details); _nextTestBackup = _currentTest->m_next; - _ignoredIndexes.clear(); _iterationDone = false; } @@ -103,6 +102,7 @@ void ParameterizedManager::endExecute(TestDetails const * const details) _currentTest->m_next = _nextTestBackup; _currentTest = nullptr; _nextTestBackup = nullptr; + _ignoredIndexes.clear(); } _iterationDone = false; From 7df39dd501721c112ce9123f18014e6e70abb9cc Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Mon, 20 Jun 2016 17:09:31 +0200 Subject: [PATCH 090/131] global ignore + tests --- UnitTest++/ParameterizedManager.cpp | 44 ++++++++++++++++++++++++++--- UnitTest++/ParameterizedManager.h | 9 ++++-- tests/TestParameterizedTest.cpp | 34 ++++++++++++++++++++++ 3 files changed, 81 insertions(+), 6 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index fd00447..d763bb9 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -9,7 +9,8 @@ using namespace UnitTest; ParameterizedManager::ParameterizedManager() : _currentTest(nullptr), _nextTestBackup(nullptr), - _iterationDone(false) + _iterationDone(false), + _executing(false) { } @@ -69,11 +70,16 @@ void ParameterizedManager::beginExecute(TestDetails const * const details) { if (_currentTest != nullptr) { + if (isCurrentTest(details)) + { + _executing = true; + } return; } _currentTest = retrieveTest(details); _nextTestBackup = _currentTest->m_next; _iterationDone = false; + _executing = true; } @@ -106,6 +112,29 @@ void ParameterizedManager::endExecute(TestDetails const * const details) } _iterationDone = false; + _executing = false; +} + + +void ParameterizedManager::dumpGlobalIgnoredIndexes(ParameterizedTestAbstract* const parameterized) +{ + ParameterizedIndexes::iterator it = _ignoredIndexesGlobal.find(parameterized); + if (it == _ignoredIndexesGlobal.end()) + { + return; + } + + vector & ignoredIndexesLocal = _ignoredIndexes[parameterized]; + + const vector & ignoredIndexesGlobal = it->second; + for (size_t i = 0; i < ignoredIndexesGlobal.size(); i++) + { + size_t iIndex = ignoredIndexesGlobal[i]; + if (find(ignoredIndexesLocal.begin(), ignoredIndexesLocal.end(), iIndex) == ignoredIndexesLocal.end()) + { + ignoredIndexesLocal.push_back(iIndex); + } + } } @@ -131,6 +160,10 @@ void ParameterizedManager::iterate(ParameterizedTestAbstract* const parameterize bool firstIteration = false; if (registerParameter(parameterized, firstIteration)) { + if (firstIteration) + { + dumpGlobalIgnoredIndexes(parameterized); + } parameterized->onNewIteration(firstIteration); } } @@ -159,14 +192,16 @@ bool ParameterizedManager::registerParameter(ParameterizedTestAbstract* const pa } -void ParameterizedManager::ignoreIndex(ParameterizedTestAbstract* const parameterized, size_t index) +ParameterizedManager & ParameterizedManager::ignoreIndex(ParameterizedTestAbstract* const parameterized, size_t index) { if (_iterationDone) { throw runtime_error("can not ignore indexes after iteration began"); } - vector & ignoredIndexes = _ignoredIndexes[parameterized]; + vector & ignoredIndexes = (_executing) + ? _ignoredIndexes[parameterized] + : _ignoredIndexesGlobal[parameterized]; if (index >= parameterized->parametersCount()) { @@ -175,7 +210,7 @@ void ParameterizedManager::ignoreIndex(ParameterizedTestAbstract* const paramete if (find(ignoredIndexes.begin(), ignoredIndexes.end(), index) != ignoredIndexes.end()) { - return; // already inserted + return *this; // already inserted } if (ignoredIndexes.size() + 1 == parameterized->parametersCount()) @@ -184,6 +219,7 @@ void ParameterizedManager::ignoreIndex(ParameterizedTestAbstract* const paramete } ignoredIndexes.push_back(index); + return *this; } diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index 6f19516..152281c 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -20,21 +20,26 @@ namespace UnitTest void beginExecute(TestDetails const * const details); void endExecute(TestDetails const * const details); void updateParameter(ParameterizedTestAbstract* const parameterized); - void ignoreIndex(ParameterizedTestAbstract* const parameterized, size_t index); + ParameterizedManager & ignoreIndex(ParameterizedTestAbstract* const parameterized, size_t index); const vector & getStack(TestDetails const * const details) const; private: + typedef unordered_map> ParameterizedIndexes; + ParameterizedManager(); virtual ~ParameterizedManager(); TestListNode* const retrieveTest(TestDetails const * const details); + void dumpGlobalIgnoredIndexes(ParameterizedTestAbstract* const parameterized); void iterate(ParameterizedTestAbstract* const parameterized); bool registerParameter(ParameterizedTestAbstract* const parameterized, bool & outFirst); TestListNode* _currentTest; TestListNode* _nextTestBackup; vector _stack; - unordered_map> _ignoredIndexes; + ParameterizedIndexes _ignoredIndexes; + ParameterizedIndexes _ignoredIndexesGlobal; volatile bool _iterationDone; + volatile bool _executing; }; } diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index ef0e570..f57d62a 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -2,6 +2,7 @@ #include #include "UnitTest++/ParameterizedTest.h" +#include "UnitTest++/ParameterizedManager.h" #include "ScopedCurrentTest.h" #include "RecordingReporter.h" @@ -274,4 +275,37 @@ SUITE(ParameterizedTestSimple) { CHECK_EQUAL("AIOY", ignoreSomeVowelsByValue); } + + ////////// + + SET_SUITE_PARAMETERS(string, pzVowelPartial, { + parameters = vowel.parameters(); + }); + + struct Initializer + { + Initializer() + { + ParameterizedManager::getInstance() + .ignoreIndex(&pzVowelPartial, 1) // "E" + .ignoreIndex(&pzVowelPartial, 4); // "U" + } + } initializerInstance; + + string globalIgnoreSomeVowels; + + // Note: the test is executed twice (A/B) + TEST(GlobalIgnore_IgnoreSome_A) + { + globalIgnoreSomeVowels += pzVowelPartial(); + } + TEST(GlobalIgnore_IgnoreSome_B) + { + globalIgnoreSomeVowels += pzVowelPartial(); + } + + TEST(GlobalIgnore_IgnoreSome_Verify) + { + CHECK_EQUAL("AIOYAIOY", globalIgnoreSomeVowels); + } } From bc5161f7dc3351aaf91bb3403701c463c3291724 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Mon, 20 Jun 2016 18:12:40 +0200 Subject: [PATCH 091/131] simplification: use struct instead of parralel maps --- UnitTest++/ParameterizedManager.cpp | 74 +++++++++++++++++++---------- UnitTest++/ParameterizedManager.h | 15 ++++-- 2 files changed, 60 insertions(+), 29 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index d763bb9..0b90d0b 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -108,7 +108,7 @@ void ParameterizedManager::endExecute(TestDetails const * const details) _currentTest->m_next = _nextTestBackup; _currentTest = nullptr; _nextTestBackup = nullptr; - _ignoredIndexes.clear(); + clearNonGlobalIgnoredIndexes(); } _iterationDone = false; @@ -116,23 +116,31 @@ void ParameterizedManager::endExecute(TestDetails const * const details) } -void ParameterizedManager::dumpGlobalIgnoredIndexes(ParameterizedTestAbstract* const parameterized) +void ParameterizedManager::clearNonGlobalIgnoredIndexes() { - ParameterizedIndexes::iterator it = _ignoredIndexesGlobal.find(parameterized); - if (it == _ignoredIndexesGlobal.end()) + for (IgnoredIndexesMap::iterator it1 = _ignoredIndexes.begin(); it1 != _ignoredIndexes.end();) { - return; - } + vector & ignoredIndexes = it1->second; - vector & ignoredIndexesLocal = _ignoredIndexes[parameterized]; + for (vector::iterator it2 = ignoredIndexes.begin(); it2 != ignoredIndexes.end();) + { + if (!it2->global) + { + it2 = ignoredIndexes.erase(it2); + } + else + { + it2++; + } + } - const vector & ignoredIndexesGlobal = it->second; - for (size_t i = 0; i < ignoredIndexesGlobal.size(); i++) - { - size_t iIndex = ignoredIndexesGlobal[i]; - if (find(ignoredIndexesLocal.begin(), ignoredIndexesLocal.end(), iIndex) == ignoredIndexesLocal.end()) + if (ignoredIndexes.empty()) { - ignoredIndexesLocal.push_back(iIndex); + _ignoredIndexes.erase(it1++); // Note: map erase is a bit special + } + else + { + it1++; } } } @@ -140,13 +148,14 @@ void ParameterizedManager::dumpGlobalIgnoredIndexes(ParameterizedTestAbstract* c void ParameterizedManager::updateParameter(ParameterizedTestAbstract* const parameterized) { - const vector & ignoredIndexes = _ignoredIndexes[parameterized]; + vector & ignoredIndexes = _ignoredIndexes[parameterized]; bool repeat = true; while (repeat) { iterate(parameterized); - repeat = (find(ignoredIndexes.begin(), ignoredIndexes.end(), parameterized->_iteration) != ignoredIndexes.end()); + vector::iterator ignoredIt = findIgnored(ignoredIndexes, parameterized->_iteration); + repeat = (ignoredIt != ignoredIndexes.end()); if (repeat) { _iterationDone = false; @@ -160,10 +169,6 @@ void ParameterizedManager::iterate(ParameterizedTestAbstract* const parameterize bool firstIteration = false; if (registerParameter(parameterized, firstIteration)) { - if (firstIteration) - { - dumpGlobalIgnoredIndexes(parameterized); - } parameterized->onNewIteration(firstIteration); } } @@ -192,6 +197,19 @@ bool ParameterizedManager::registerParameter(ParameterizedTestAbstract* const pa } +vector::iterator ParameterizedManager::findIgnored(vector & ignoredIndexes, size_t index) +{ + for (vector::iterator it = ignoredIndexes.begin(); it != ignoredIndexes.end(); it++) + { + if (index == it->index) + { + return it; + } + } + return ignoredIndexes.end(); +} + + ParameterizedManager & ParameterizedManager::ignoreIndex(ParameterizedTestAbstract* const parameterized, size_t index) { if (_iterationDone) @@ -199,18 +217,23 @@ ParameterizedManager & ParameterizedManager::ignoreIndex(ParameterizedTestAbstra throw runtime_error("can not ignore indexes after iteration began"); } - vector & ignoredIndexes = (_executing) - ? _ignoredIndexes[parameterized] - : _ignoredIndexesGlobal[parameterized]; + bool global = !_executing; + vector & ignoredIndexes = _ignoredIndexes[parameterized]; if (index >= parameterized->parametersCount()) { throw out_of_range("ignore index is out of range"); } - if (find(ignoredIndexes.begin(), ignoredIndexes.end(), index) != ignoredIndexes.end()) + vector::iterator ignoredIt = findIgnored(ignoredIndexes, index); + if (ignoredIt != ignoredIndexes.end()) { - return *this; // already inserted + // Upgrade to global if required + if (!ignoredIt->global && global) + { + ignoredIt->global = global; + } + return *this; } if (ignoredIndexes.size() + 1 == parameterized->parametersCount()) @@ -218,7 +241,8 @@ ParameterizedManager & ParameterizedManager::ignoreIndex(ParameterizedTestAbstra throw runtime_error("all parameters have been ignored, can not proceed"); } - ignoredIndexes.push_back(index); + ignoredIndexes.push_back(IgnoredIndex(index, global)); + return *this; } diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index 152281c..094648c 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -24,20 +24,27 @@ namespace UnitTest const vector & getStack(TestDetails const * const details) const; private: - typedef unordered_map> ParameterizedIndexes; + struct IgnoredIndex + { + IgnoredIndex(size_t index, bool global) : index(index), global(global) {} + size_t index; + bool global; + }; + + typedef unordered_map> IgnoredIndexesMap; ParameterizedManager(); virtual ~ParameterizedManager(); TestListNode* const retrieveTest(TestDetails const * const details); - void dumpGlobalIgnoredIndexes(ParameterizedTestAbstract* const parameterized); void iterate(ParameterizedTestAbstract* const parameterized); bool registerParameter(ParameterizedTestAbstract* const parameterized, bool & outFirst); + vector::iterator findIgnored(vector & ignoredIndexes, size_t index); + void clearNonGlobalIgnoredIndexes(); TestListNode* _currentTest; TestListNode* _nextTestBackup; vector _stack; - ParameterizedIndexes _ignoredIndexes; - ParameterizedIndexes _ignoredIndexesGlobal; + IgnoredIndexesMap _ignoredIndexes; volatile bool _iterationDone; volatile bool _executing; }; From 9c13b30072f83980304ac0f79a19fb9bf9464c2c Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 1 Jul 2016 14:48:46 +0200 Subject: [PATCH 092/131] added test IgnoreIndex_IgnoreLast which revealed a bug --- tests/TestParameterizedTest.cpp | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index f57d62a..fb252a7 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -215,6 +215,27 @@ SUITE(ParameterizedTestSimple) ////////// + size_t ignoreIndexLast_count = 0; + string ignoreIndexLast; + TEST(IgnoreIndex_IgnoreLast) + { + size_t lastIndex = oneTwo.parameters().size() - 1; + oneTwo.ignoreIndex(lastIndex); + + ignoreIndexLast += oneTwo(); + + // WARNING: this is not the test itself, it is only for reveal a "dead loop" + REQUIRE CHECK(ignoreIndexLast_count < lastIndex); + ignoreIndexLast_count++; + } + + TEST(IgnoreIndex_IgnoreLast_Verify) + { + CHECK_EQUAL("1", ignoreIndexLast); + } + + ////////// + string ignoreSomeVowels; TEST(IgnoreIndex_IgnoreSome) { From fdbc313b8e01d2d562453e176f9b804d3317055a Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 1 Jul 2016 15:12:01 +0200 Subject: [PATCH 093/131] fixed ignore bug --- UnitTest++/ParameterizedManager.cpp | 31 ++++++++++++++++++++++++++++- UnitTest++/ParameterizedManager.h | 1 + 2 files changed, 31 insertions(+), 1 deletion(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 0b90d0b..5c5a1d1 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -66,6 +66,35 @@ bool ParameterizedManager::isCurrentTest(TestDetails const * const details) cons } +bool ParameterizedManager::hasMoreIterations(ParameterizedTestAbstract* const parameterized) +{ + if (!parameterized->hasMoreParameters(1)) + { + return false; + } + + vector & ignoredIndexes = _ignoredIndexes[parameterized]; + if (!ignoredIndexes.empty()) + { + bool allRemainingsAreIgnored = true; + for (size_t iIndex = parameterized->_iteration + 1; iIndex < parameterized->parametersCount(); iIndex++) + { + if (findIgnored(ignoredIndexes, iIndex) == ignoredIndexes.end()) + { + allRemainingsAreIgnored = false; + break; + } + } + if (allRemainingsAreIgnored) + { + return false; + } + } + + return true; +} + + void ParameterizedManager::beginExecute(TestDetails const * const details) { if (_currentTest != nullptr) @@ -93,7 +122,7 @@ void ParameterizedManager::endExecute(TestDetails const * const details) while (!_stack.empty()) { ParameterizedTestAbstract* iParameterized = _stack.back(); - if (iParameterized->hasMoreParameters(1)) + if (hasMoreIterations(iParameterized)) { break; } diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index 094648c..f264474 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -38,6 +38,7 @@ namespace UnitTest TestListNode* const retrieveTest(TestDetails const * const details); void iterate(ParameterizedTestAbstract* const parameterized); bool registerParameter(ParameterizedTestAbstract* const parameterized, bool & outFirst); + bool hasMoreIterations(ParameterizedTestAbstract* const parameterized); vector::iterator findIgnored(vector & ignoredIndexes, size_t index); void clearNonGlobalIgnoredIndexes(); From a82ebbd8f29c22b61f1902c12f3f66d25bad49fa Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 1 Jul 2016 15:29:24 +0200 Subject: [PATCH 094/131] removed now useless code --- UnitTest++/ParameterizedTest.cpp | 5 ----- 1 file changed, 5 deletions(-) diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index 9507ee2..a544fcd 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -48,11 +48,6 @@ bool ParameterizedTestAbstract::hasMoreParameters(int advance) const void ParameterizedTestAbstract::onNewIteration(bool first) { - if (!first && !hasMoreParameters(1)) - { - first = true; - } - if (first) { if (parametersCount() == 0) From a5d13e3aa89f34a6dbb93e2cb2816b20a93e2496 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 1 Jul 2016 16:50:45 +0200 Subject: [PATCH 095/131] renamed "iteration" -> "index" --- UnitTest++/ParameterizedMacros.h | 12 ++++++------ UnitTest++/ParameterizedManager.cpp | 21 +++++++++++---------- UnitTest++/ParameterizedManager.h | 4 ++-- UnitTest++/ParameterizedTest.cpp | 22 +++++++++++----------- UnitTest++/ParameterizedTest.h | 18 +++++++++--------- 5 files changed, 39 insertions(+), 38 deletions(-) diff --git a/UnitTest++/ParameterizedMacros.h b/UnitTest++/ParameterizedMacros.h index 5fd8c2d..0adc2ba 100644 --- a/UnitTest++/ParameterizedMacros.h +++ b/UnitTest++/ParameterizedMacros.h @@ -4,22 +4,22 @@ #include "ParameterizedTest.h" -#define SET_SUITE_PARAMETERS(Type, IterationName, SetUpBody) \ - class ParameterizedCreator ## IterationName \ +#define SET_SUITE_PARAMETERS(Type, Name, SetUpBody) \ + class ParameterizedCreator ## Name \ { \ public: \ - ParameterizedCreator ## IterationName() : globalInstance(getGlobalInstance()) {} \ + ParameterizedCreator ## Name() : globalInstance(getGlobalInstance()) {} \ UnitTest::ParameterizedTest<## Type> & globalInstance; \ private: \ static UnitTest::ParameterizedTest<## Type> & getGlobalInstance() \ { \ - static UnitTest::ParameterizedTest<## Type> instance(#IterationName, create()); \ + static UnitTest::ParameterizedTest<## Type> instance(#Name, create()); \ return instance; \ } \ static vector<## Type> create() { vector<## Type> parameters; SetUpBody return parameters; } \ - } static parameterizedCreator ## IterationName ## Instance; \ + } static parameterizedCreator ## Name ## Instance; \ \ - static UnitTest::ParameterizedTest<## Type> & ## IterationName(parameterizedCreator ## IterationName ## Instance.globalInstance) + static UnitTest::ParameterizedTest<## Type> & ## Name(parameterizedCreator ## Name ## Instance.globalInstance) #endif \ No newline at end of file diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 5c5a1d1..fc05c46 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -66,7 +66,7 @@ bool ParameterizedManager::isCurrentTest(TestDetails const * const details) cons } -bool ParameterizedManager::hasMoreIterations(ParameterizedTestAbstract* const parameterized) +bool ParameterizedManager::hasMoreIndexes(ParameterizedTestAbstract* const parameterized) { if (!parameterized->hasMoreParameters(1)) { @@ -77,7 +77,7 @@ bool ParameterizedManager::hasMoreIterations(ParameterizedTestAbstract* const pa if (!ignoredIndexes.empty()) { bool allRemainingsAreIgnored = true; - for (size_t iIndex = parameterized->_iteration + 1; iIndex < parameterized->parametersCount(); iIndex++) + for (size_t iIndex = parameterized->_index + 1; iIndex < parameterized->parametersCount(); iIndex++) { if (findIgnored(ignoredIndexes, iIndex) == ignoredIndexes.end()) { @@ -122,7 +122,7 @@ void ParameterizedManager::endExecute(TestDetails const * const details) while (!_stack.empty()) { ParameterizedTestAbstract* iParameterized = _stack.back(); - if (hasMoreIterations(iParameterized)) + if (hasMoreIndexes(iParameterized)) { break; } @@ -183,7 +183,7 @@ void ParameterizedManager::updateParameter(ParameterizedTestAbstract* const para { iterate(parameterized); - vector::iterator ignoredIt = findIgnored(ignoredIndexes, parameterized->_iteration); + vector::iterator ignoredIt = findIgnored(ignoredIndexes, parameterized->_index); repeat = (ignoredIt != ignoredIndexes.end()); if (repeat) { @@ -195,22 +195,22 @@ void ParameterizedManager::updateParameter(ParameterizedTestAbstract* const para void ParameterizedManager::iterate(ParameterizedTestAbstract* const parameterized) { - bool firstIteration = false; - if (registerParameter(parameterized, firstIteration)) + bool firstIndex = false; + if (registerParameter(parameterized, firstIndex)) { - parameterized->onNewIteration(firstIteration); + parameterized->nextIndex(firstIndex); } } -bool ParameterizedManager::registerParameter(ParameterizedTestAbstract* const parameterized, bool & outFirstIteration) +bool ParameterizedManager::registerParameter(ParameterizedTestAbstract* const parameterized, bool & outFirstIndex) { if (find(_stack.begin(), _stack.end(), parameterized) == _stack.end()) { _iterationDone = true; _currentTest->m_next = _currentTest; // Loop itself _stack.push_back(parameterized); - outFirstIteration = true; + outFirstIndex = true; return true; } if (!_iterationDone) @@ -218,10 +218,11 @@ bool ParameterizedManager::registerParameter(ParameterizedTestAbstract* const pa if (!_stack.empty() && _stack.back() == parameterized) { _iterationDone = true; - outFirstIteration = false; + outFirstIndex = false; return true; } } + outFirstIndex = false; return false; } diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index f264474..8557426 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -37,8 +37,8 @@ namespace UnitTest virtual ~ParameterizedManager(); TestListNode* const retrieveTest(TestDetails const * const details); void iterate(ParameterizedTestAbstract* const parameterized); - bool registerParameter(ParameterizedTestAbstract* const parameterized, bool & outFirst); - bool hasMoreIterations(ParameterizedTestAbstract* const parameterized); + bool registerParameter(ParameterizedTestAbstract* const parameterized, bool & outFirstIndex); + bool hasMoreIndexes(ParameterizedTestAbstract* const parameterized); vector::iterator findIgnored(vector & ignoredIndexes, size_t index); void clearNonGlobalIgnoredIndexes(); diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/ParameterizedTest.cpp index a544fcd..3a26d5e 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/ParameterizedTest.cpp @@ -9,7 +9,7 @@ using namespace UnitTest; ParameterizedTestAbstract::ParameterizedTestAbstract(const string & name) : _name(name), - _iteration(0) + _index(0) { } @@ -19,22 +19,22 @@ ParameterizedTestAbstract::~ParameterizedTestAbstract() } -size_t ParameterizedTestAbstract::getIteration() +size_t ParameterizedTestAbstract::getCurrentIndex() { - updateIteration(); - return _iteration; + updateCurrentIndex(); + return _index; } string ParameterizedTestAbstract::getNameCurrent() const { stringstream output; - output << (_name.empty() ? "unknown" : _name) << "[" << _iteration << "]"; + output << (_name.empty() ? "unknown" : _name) << "[" << _index << "]"; return output.str(); } -void ParameterizedTestAbstract::updateIteration() +void ParameterizedTestAbstract::updateCurrentIndex() { ParameterizedManager::getInstance().updateParameter(this); } @@ -42,11 +42,11 @@ void ParameterizedTestAbstract::updateIteration() bool ParameterizedTestAbstract::hasMoreParameters(int advance) const { - return (_iteration + advance < (int)parametersCount()); + return (_index + advance < (int)parametersCount()); } -void ParameterizedTestAbstract::onNewIteration(bool first) +void ParameterizedTestAbstract::nextIndex(bool first) { if (first) { @@ -54,14 +54,14 @@ void ParameterizedTestAbstract::onNewIteration(bool first) { throw runtime_error("No values for parameterized test"); } - _iteration = 0; + _index = 0; } else { - _iteration++; + _index++; } - peekCurrentParameter(& ParameterizedManager::getInstance().getCurrentTest()->m_details, _iteration); + peekCurrentParameter(&ParameterizedManager::getInstance().getCurrentTest()->m_details, _index); } diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h index ec6b95e..5755215 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/ParameterizedTest.h @@ -17,22 +17,22 @@ namespace UnitTest public: ParameterizedTestAbstract(const string & name); virtual ~ParameterizedTestAbstract(); - size_t getIteration(); + size_t getCurrentIndex(); const string & getName() const { return _name; } string getNameCurrent() const; ParameterizedTestAbstract & ignoreIndex(size_t index); protected: - void updateIteration(); - virtual void peekCurrentParameter(TestDetails const * const details, size_t iteration) = 0; + void updateCurrentIndex(); + virtual void peekCurrentParameter(TestDetails const * const details, size_t index) = 0; virtual size_t parametersCount() const = 0; private: bool hasMoreParameters(int advance = 0) const; - void onNewIteration(bool first); + void nextIndex(bool first); string _name; - size_t _iteration; + size_t _index; }; @@ -42,7 +42,7 @@ namespace UnitTest public: struct IParameterizedTestListener { - virtual void onNextIteration(TestDetails const * const details, T_Parameter current, size_t iteration) = 0; + virtual void onNext(TestDetails const * const details, T_Parameter current, size_t index) = 0; }; ParameterizedTest(const string & name, vector parameters, IParameterizedTestListener* const listener = nullptr) @@ -54,7 +54,7 @@ namespace UnitTest T_Parameter operator()() { - return _parameters[getIteration()]; + return _parameters[getCurrentIndex()]; } const vector & parameters() const @@ -79,11 +79,11 @@ namespace UnitTest } protected: - virtual void peekCurrentParameter(TestDetails const * const details, size_t iteration) override + virtual void peekCurrentParameter(TestDetails const * const details, size_t index) override { if (_listener != nullptr) { - _listener->onNextIteration(details, _parameters[iteration], iteration); + _listener->onNext(details, _parameters[index], index); } } From 1ccb2136d3ab331845bdbfe4f0267f49ad49e00d Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 1 Jul 2016 16:54:19 +0200 Subject: [PATCH 096/131] cleaned macro --- UnitTest++/ParameterizedMacros.h | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/UnitTest++/ParameterizedMacros.h b/UnitTest++/ParameterizedMacros.h index 0adc2ba..9043c90 100644 --- a/UnitTest++/ParameterizedMacros.h +++ b/UnitTest++/ParameterizedMacros.h @@ -5,21 +5,21 @@ #define SET_SUITE_PARAMETERS(Type, Name, SetUpBody) \ - class ParameterizedCreator ## Name \ + class ParameterizedCreator##Name \ { \ public: \ - ParameterizedCreator ## Name() : globalInstance(getGlobalInstance()) {} \ - UnitTest::ParameterizedTest<## Type> & globalInstance; \ + ParameterizedCreator##Name() : globalInstance(getGlobalInstance()) {} \ + UnitTest::ParameterizedTest & globalInstance; \ private: \ - static UnitTest::ParameterizedTest<## Type> & getGlobalInstance() \ + static UnitTest::ParameterizedTest & getGlobalInstance() \ { \ - static UnitTest::ParameterizedTest<## Type> instance(#Name, create()); \ + static UnitTest::ParameterizedTest instance(#Name, create()); \ return instance; \ } \ - static vector<## Type> create() { vector<## Type> parameters; SetUpBody return parameters; } \ - } static parameterizedCreator ## Name ## Instance; \ + static vector create() { vector parameters; SetUpBody return parameters; } \ + } static parameterizedCreator##Name##Instance; \ \ - static UnitTest::ParameterizedTest<## Type> & ## Name(parameterizedCreator ## Name ## Instance.globalInstance) + static UnitTest::ParameterizedTest & Name(parameterizedCreator##Name##Instance.globalInstance) #endif \ No newline at end of file From e33f47e50add6efbb1bd1ac5007c1e6ad0ba5993 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sat, 2 Jul 2016 13:30:35 +0200 Subject: [PATCH 097/131] added missing include --- UnitTest++/ParameterizedTest.h | 1 + 1 file changed, 1 insertion(+) diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/ParameterizedTest.h index 5755215..1d2652d 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/ParameterizedTest.h @@ -3,6 +3,7 @@ #include #include +#include #include "Test.h" #include "TestList.h" From 36dac7146d555fa381810a944c6c711acf653ba9 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sat, 2 Jul 2016 13:41:46 +0200 Subject: [PATCH 098/131] removed useless var --- UnitTest++/TestResults.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/UnitTest++/TestResults.cpp b/UnitTest++/TestResults.cpp index 00a9aee..8c2c6e9 100644 --- a/UnitTest++/TestResults.cpp +++ b/UnitTest++/TestResults.cpp @@ -36,7 +36,6 @@ namespace UnitTest { { MemoryOutStream stream; stream << failure; - string parameterizedDump; vector parameterizeds = ParameterizedManager::getInstance().getStack(&test); if (!parameterizeds.empty()) { From 7c5415c76ae0172101cebb1974d4732cb33dd75d Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sat, 2 Jul 2016 13:45:13 +0200 Subject: [PATCH 099/131] renamed class "ParameterizedTest" -> "TestParameter" --- UnitTest++/ParameterizedMacros.h | 10 +++---- UnitTest++/ParameterizedManager.cpp | 16 +++++------ UnitTest++/ParameterizedManager.h | 18 ++++++------ ...arameterizedTest.cpp => TestParameter.cpp} | 18 ++++++------ .../{ParameterizedTest.h => TestParameter.h} | 28 +++++++++---------- UnitTest++/TestResults.cpp | 8 +++--- tests/TestParameterizedTest.cpp | 4 +-- 7 files changed, 51 insertions(+), 51 deletions(-) rename UnitTest++/{ParameterizedTest.cpp => TestParameter.cpp} (59%) rename UnitTest++/{ParameterizedTest.h => TestParameter.h} (68%) diff --git a/UnitTest++/ParameterizedMacros.h b/UnitTest++/ParameterizedMacros.h index 9043c90..b1effcd 100644 --- a/UnitTest++/ParameterizedMacros.h +++ b/UnitTest++/ParameterizedMacros.h @@ -1,7 +1,7 @@ #ifndef UNITTEST_PARAMETERIZEDMACROS_H #define UNITTEST_PARAMETERIZEDMACROS_H -#include "ParameterizedTest.h" +#include "TestParameter.h" #define SET_SUITE_PARAMETERS(Type, Name, SetUpBody) \ @@ -9,17 +9,17 @@ { \ public: \ ParameterizedCreator##Name() : globalInstance(getGlobalInstance()) {} \ - UnitTest::ParameterizedTest & globalInstance; \ + UnitTest::TestParameter & globalInstance; \ private: \ - static UnitTest::ParameterizedTest & getGlobalInstance() \ + static UnitTest::TestParameter & getGlobalInstance() \ { \ - static UnitTest::ParameterizedTest instance(#Name, create()); \ + static UnitTest::TestParameter instance(#Name, create()); \ return instance; \ } \ static vector create() { vector parameters; SetUpBody return parameters; } \ } static parameterizedCreator##Name##Instance; \ \ - static UnitTest::ParameterizedTest & Name(parameterizedCreator##Name##Instance.globalInstance) + static UnitTest::TestParameter & Name(parameterizedCreator##Name##Instance.globalInstance) #endif \ No newline at end of file diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index fc05c46..48d1281 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -66,7 +66,7 @@ bool ParameterizedManager::isCurrentTest(TestDetails const * const details) cons } -bool ParameterizedManager::hasMoreIndexes(ParameterizedTestAbstract* const parameterized) +bool ParameterizedManager::hasMoreIndexes(TestParameterAbstract* const parameterized) { if (!parameterized->hasMoreParameters(1)) { @@ -121,7 +121,7 @@ void ParameterizedManager::endExecute(TestDetails const * const details) while (!_stack.empty()) { - ParameterizedTestAbstract* iParameterized = _stack.back(); + TestParameterAbstract* iParameterized = _stack.back(); if (hasMoreIndexes(iParameterized)) { break; @@ -175,7 +175,7 @@ void ParameterizedManager::clearNonGlobalIgnoredIndexes() } -void ParameterizedManager::updateParameter(ParameterizedTestAbstract* const parameterized) +void ParameterizedManager::updateParameter(TestParameterAbstract* const parameterized) { vector & ignoredIndexes = _ignoredIndexes[parameterized]; bool repeat = true; @@ -193,7 +193,7 @@ void ParameterizedManager::updateParameter(ParameterizedTestAbstract* const para } -void ParameterizedManager::iterate(ParameterizedTestAbstract* const parameterized) +void ParameterizedManager::iterate(TestParameterAbstract* const parameterized) { bool firstIndex = false; if (registerParameter(parameterized, firstIndex)) @@ -203,7 +203,7 @@ void ParameterizedManager::iterate(ParameterizedTestAbstract* const parameterize } -bool ParameterizedManager::registerParameter(ParameterizedTestAbstract* const parameterized, bool & outFirstIndex) +bool ParameterizedManager::registerParameter(TestParameterAbstract* const parameterized, bool & outFirstIndex) { if (find(_stack.begin(), _stack.end(), parameterized) == _stack.end()) { @@ -240,7 +240,7 @@ vector::iterator ParameterizedManager::findI } -ParameterizedManager & ParameterizedManager::ignoreIndex(ParameterizedTestAbstract* const parameterized, size_t index) +ParameterizedManager & ParameterizedManager::ignoreIndex(TestParameterAbstract* const parameterized, size_t index) { if (_iterationDone) { @@ -277,11 +277,11 @@ ParameterizedManager & ParameterizedManager::ignoreIndex(ParameterizedTestAbstra } -const vector & ParameterizedManager::getStack(TestDetails const * const details) const +const vector & ParameterizedManager::getStack(TestDetails const * const details) const { if (!isCurrentTest(details)) { - static vector emptyStored; + static vector emptyStored; return emptyStored; } return _stack; diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index 8557426..5183269 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -5,7 +5,7 @@ #include #include "TestDetails.h" #include "TestList.h" -#include "ParameterizedTest.h" +#include "TestParameter.h" namespace UnitTest { @@ -19,9 +19,9 @@ namespace UnitTest bool isCurrentTest(TestDetails const * const details) const; void beginExecute(TestDetails const * const details); void endExecute(TestDetails const * const details); - void updateParameter(ParameterizedTestAbstract* const parameterized); - ParameterizedManager & ignoreIndex(ParameterizedTestAbstract* const parameterized, size_t index); - const vector & getStack(TestDetails const * const details) const; + void updateParameter(TestParameterAbstract* const parameterized); + ParameterizedManager & ignoreIndex(TestParameterAbstract* const parameterized, size_t index); + const vector & getStack(TestDetails const * const details) const; private: struct IgnoredIndex @@ -31,20 +31,20 @@ namespace UnitTest bool global; }; - typedef unordered_map> IgnoredIndexesMap; + typedef unordered_map> IgnoredIndexesMap; ParameterizedManager(); virtual ~ParameterizedManager(); TestListNode* const retrieveTest(TestDetails const * const details); - void iterate(ParameterizedTestAbstract* const parameterized); - bool registerParameter(ParameterizedTestAbstract* const parameterized, bool & outFirstIndex); - bool hasMoreIndexes(ParameterizedTestAbstract* const parameterized); + void iterate(TestParameterAbstract* const parameterized); + bool registerParameter(TestParameterAbstract* const parameterized, bool & outFirstIndex); + bool hasMoreIndexes(TestParameterAbstract* const parameterized); vector::iterator findIgnored(vector & ignoredIndexes, size_t index); void clearNonGlobalIgnoredIndexes(); TestListNode* _currentTest; TestListNode* _nextTestBackup; - vector _stack; + vector _stack; IgnoredIndexesMap _ignoredIndexes; volatile bool _iterationDone; volatile bool _executing; diff --git a/UnitTest++/ParameterizedTest.cpp b/UnitTest++/TestParameter.cpp similarity index 59% rename from UnitTest++/ParameterizedTest.cpp rename to UnitTest++/TestParameter.cpp index 3a26d5e..2f3eb65 100644 --- a/UnitTest++/ParameterizedTest.cpp +++ b/UnitTest++/TestParameter.cpp @@ -1,4 +1,4 @@ -#include "ParameterizedTest.h" +#include "TestParameter.h" #include #include "ParameterizedManager.h" @@ -7,26 +7,26 @@ using namespace std; using namespace UnitTest; -ParameterizedTestAbstract::ParameterizedTestAbstract(const string & name) +TestParameterAbstract::TestParameterAbstract(const string & name) : _name(name), _index(0) { } -ParameterizedTestAbstract::~ParameterizedTestAbstract() +TestParameterAbstract::~TestParameterAbstract() { } -size_t ParameterizedTestAbstract::getCurrentIndex() +size_t TestParameterAbstract::getCurrentIndex() { updateCurrentIndex(); return _index; } -string ParameterizedTestAbstract::getNameCurrent() const +string TestParameterAbstract::getNameCurrent() const { stringstream output; output << (_name.empty() ? "unknown" : _name) << "[" << _index << "]"; @@ -34,19 +34,19 @@ string ParameterizedTestAbstract::getNameCurrent() const } -void ParameterizedTestAbstract::updateCurrentIndex() +void TestParameterAbstract::updateCurrentIndex() { ParameterizedManager::getInstance().updateParameter(this); } -bool ParameterizedTestAbstract::hasMoreParameters(int advance) const +bool TestParameterAbstract::hasMoreParameters(int advance) const { return (_index + advance < (int)parametersCount()); } -void ParameterizedTestAbstract::nextIndex(bool first) +void TestParameterAbstract::nextIndex(bool first) { if (first) { @@ -65,7 +65,7 @@ void ParameterizedTestAbstract::nextIndex(bool first) } -ParameterizedTestAbstract & ParameterizedTestAbstract::ignoreIndex(size_t index) +TestParameterAbstract & TestParameterAbstract::ignoreIndex(size_t index) { ParameterizedManager::getInstance().ignoreIndex(this, index); return *this; diff --git a/UnitTest++/ParameterizedTest.h b/UnitTest++/TestParameter.h similarity index 68% rename from UnitTest++/ParameterizedTest.h rename to UnitTest++/TestParameter.h index 1d2652d..960cb2b 100644 --- a/UnitTest++/ParameterizedTest.h +++ b/UnitTest++/TestParameter.h @@ -1,5 +1,5 @@ -#ifndef UNITTEST_PARAMETERIZEDTEST_H -#define UNITTEST_PARAMETERIZEDTEST_H +#ifndef UNITTEST_TESTPARAMETER_H +#define UNITTEST_TESTPARAMETER_H #include #include @@ -12,16 +12,16 @@ namespace UnitTest { using namespace std; - class ParameterizedTestAbstract + class TestParameterAbstract { friend class ParameterizedManager; public: - ParameterizedTestAbstract(const string & name); - virtual ~ParameterizedTestAbstract(); + TestParameterAbstract(const string & name); + virtual ~TestParameterAbstract(); size_t getCurrentIndex(); const string & getName() const { return _name; } string getNameCurrent() const; - ParameterizedTestAbstract & ignoreIndex(size_t index); + TestParameterAbstract & ignoreIndex(size_t index); protected: void updateCurrentIndex(); @@ -38,16 +38,16 @@ namespace UnitTest template - class ParameterizedTest : public ParameterizedTestAbstract + class TestParameter : public TestParameterAbstract { public: - struct IParameterizedTestListener + struct IParameterListener { virtual void onNext(TestDetails const * const details, T_Parameter current, size_t index) = 0; }; - ParameterizedTest(const string & name, vector parameters, IParameterizedTestListener* const listener = nullptr) - : ParameterizedTestAbstract(name), + TestParameter(const string & name, vector parameters, IParameterListener* const listener = nullptr) + : TestParameterAbstract(name), _parameters(parameters), _listener(listener) { @@ -63,13 +63,13 @@ namespace UnitTest return _parameters; } - ParameterizedTest & ignoreIndex(size_t index) + TestParameter & ignoreIndex(size_t index) { - ParameterizedTestAbstract::ignoreIndex(index); + TestParameterAbstract::ignoreIndex(index); return *this; } - ParameterizedTest & ignore(T_Parameter p) + TestParameter & ignore(T_Parameter p) { vector::iterator it = find(_parameters.begin(), _parameters.end(), p); if (it == _parameters.end()) @@ -95,7 +95,7 @@ namespace UnitTest private: vector _parameters; - IParameterizedTestListener* const _listener; + IParameterListener* const _listener; }; } diff --git a/UnitTest++/TestResults.cpp b/UnitTest++/TestResults.cpp index 8c2c6e9..e52f4fe 100644 --- a/UnitTest++/TestResults.cpp +++ b/UnitTest++/TestResults.cpp @@ -36,17 +36,17 @@ namespace UnitTest { { MemoryOutStream stream; stream << failure; - vector parameterizeds = ParameterizedManager::getInstance().getStack(&test); - if (!parameterizeds.empty()) + vector parameters = ParameterizedManager::getInstance().getStack(&test); + if (!parameters.empty()) { stream << " Parameters: "; - for (size_t i = 0; i < parameterizeds.size(); i++) + for (size_t i = 0; i < parameters.size(); i++) { if (i != 0) { stream << ", "; } - stream << parameterizeds[i]->getNameCurrent(); + stream << parameters[i]->getNameCurrent(); } } m_testReporter->ReportFailure(test, stream.GetText()); diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index fb252a7..f5dd3c5 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -1,7 +1,7 @@ #include "UnitTest++/UnitTest++.h" #include -#include "UnitTest++/ParameterizedTest.h" +#include "UnitTest++/TestParameter.h" #include "UnitTest++/ParameterizedManager.h" #include "ScopedCurrentTest.h" #include "RecordingReporter.h" @@ -10,7 +10,7 @@ using namespace std; using namespace UnitTest; -SUITE(ParameterizedTestSimple) +SUITE(ParameterizedTest) { string simpleVowels; int simpleVowelsHitCount = 0; From 058812bf2e7ec399eba047a363668e6d9d53e6bd Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sat, 2 Jul 2016 13:48:19 +0200 Subject: [PATCH 100/131] use parameter naming convention "pz*" --- tests/TestParameterizedTest.cpp | 78 ++++++++++++++++----------------- 1 file changed, 39 insertions(+), 39 deletions(-) diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index f5dd3c5..6f07e52 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -15,7 +15,7 @@ SUITE(ParameterizedTest) string simpleVowels; int simpleVowelsHitCount = 0; - SET_SUITE_PARAMETERS(string, vowel, { + SET_SUITE_PARAMETERS(string, pzVowel, { parameters.push_back("A"); parameters.push_back("E"); parameters.push_back("I"); @@ -24,13 +24,13 @@ SUITE(ParameterizedTest) parameters.push_back("Y"); }); - TEST(SimpleVoyelConcat) + TEST(SimpleVowelConcat) { - simpleVowels += vowel(); + simpleVowels += pzVowel(); simpleVowelsHitCount++; } - TEST(SimpleVoyelConcat_Verify) + TEST(SimpleVowelConcat_Verify) { CHECK_EQUAL(6, simpleVowelsHitCount); CHECK_EQUAL("AEIOUY", simpleVowels); @@ -50,7 +50,7 @@ SUITE(ParameterizedTest) bool enteredEmpty = false; int hitCountEmpty = 0; - SET_SUITE_PARAMETERS(int, parameterizedEmpty, { + SET_SUITE_PARAMETERS(int, pzEmpty, { }); TEST(WhenNoParameters_throwsException) @@ -58,7 +58,7 @@ SUITE(ParameterizedTest) enteredEmpty = true; try { - parameterizedEmpty(); + pzEmpty(); } catch (runtime_error e) // Expected case { @@ -81,13 +81,13 @@ SUITE(ParameterizedTest) int hitCountSingle = 0; static int singleValueSuiteSum = 0; - SET_SUITE_PARAMETERS(int, parameterizedSingle, { + SET_SUITE_PARAMETERS(int, pzSingle, { parameters.push_back(2); }); TEST(WhenSingleValue_singleExecution) { - singleValueSuiteSum += parameterizedSingle(); + singleValueSuiteSum += pzSingle(); CHECK_EQUAL(2, singleValueSuiteSum); hitCountSingle++; } @@ -103,7 +103,7 @@ SUITE(ParameterizedTest) string voyelReuse; TEST(ReusePreviousParameterized) { - voyelReuse += vowel() + "-"; // Add a separator for + voyelReuse += pzVowel() + "-"; // Add a separator for } TEST(ReusePreviousParameterized_Verify) @@ -113,7 +113,7 @@ SUITE(ParameterizedTest) ////////// - SET_SUITE_PARAMETERS(string, oneTwo, { + SET_SUITE_PARAMETERS(string, pzOneTwo, { parameters.push_back("1"); parameters.push_back("2"); }); @@ -121,8 +121,8 @@ SUITE(ParameterizedTest) string nestedParameters; TEST(NestedParameters) { - nestedParameters += vowel(); - nestedParameters += oneTwo(); + nestedParameters += pzVowel(); + nestedParameters += pzOneTwo(); } TEST(NestedParameters_Verify) @@ -135,8 +135,8 @@ SUITE(ParameterizedTest) string useSeveralTimes; TEST(UseSeveralTimes_DoesNotIncrement) { - useSeveralTimes += oneTwo(); - useSeveralTimes += oneTwo(); + useSeveralTimes += pzOneTwo(); + useSeveralTimes += pzOneTwo(); } TEST(UseSeveralTimes_DoesNotIncrement_Verify) @@ -151,7 +151,7 @@ SUITE(ParameterizedTest) string withFixture; TEST_FIXTURE(Fixture, WorksWithFixture) { - withFixture += oneTwo(); + withFixture += pzOneTwo(); } TEST(WorksWithFixture_Verify) @@ -161,7 +161,7 @@ SUITE(ParameterizedTest) ////////// - SET_SUITE_PARAMETERS(int, parameterizedSingleBis, { + SET_SUITE_PARAMETERS(int, pzSingleBis, { parameters.push_back(3); }); @@ -174,8 +174,8 @@ SUITE(ParameterizedTest) : Test(CurrentTest::Details()->testName, CurrentTest::Details()->suiteName, CurrentTest::Details()->filename) {} virtual void RunImpl() const { - parameterizedSingle(); - parameterizedSingleBis(); + pzSingle(); + pzSingleBis(); REQUIRE CHECK(false); } }; @@ -188,8 +188,8 @@ SUITE(ParameterizedTest) } string expectedFailMessage = "false Parameters: " - + parameterizedSingle.getName() + "[0], " - + parameterizedSingleBis.getName() + "[0]"; + + pzSingle.getName() + "[0], " + + pzSingleBis.getName() + "[0]"; CHECK_EQUAL(expectedFailMessage, string(reporter.lastFailedMessage)); } @@ -198,19 +198,19 @@ SUITE(ParameterizedTest) TEST(IgnoreIndex_OutOfRange_ThrowsException) { - size_t out = vowel.parameters().size(); - CHECK_THROW(vowel.ignoreIndex(out), out_of_range); + size_t out = pzVowel.parameters().size(); + CHECK_THROW(pzVowel.ignoreIndex(out), out_of_range); } TEST(IgnoreIndex_IgnoreAll_ThrowsException) { - size_t last = vowel.parameters().size() - 1; + size_t last = pzVowel.parameters().size() - 1; for (size_t i = 0; i < last; i++) { - vowel.ignoreIndex(i); + pzVowel.ignoreIndex(i); } - CHECK_THROW(vowel.ignoreIndex(last), runtime_error); + CHECK_THROW(pzVowel.ignoreIndex(last), runtime_error); } ////////// @@ -219,10 +219,10 @@ SUITE(ParameterizedTest) string ignoreIndexLast; TEST(IgnoreIndex_IgnoreLast) { - size_t lastIndex = oneTwo.parameters().size() - 1; - oneTwo.ignoreIndex(lastIndex); + size_t lastIndex = pzOneTwo.parameters().size() - 1; + pzOneTwo.ignoreIndex(lastIndex); - ignoreIndexLast += oneTwo(); + ignoreIndexLast += pzOneTwo(); // WARNING: this is not the test itself, it is only for reveal a "dead loop" REQUIRE CHECK(ignoreIndexLast_count < lastIndex); @@ -239,11 +239,11 @@ SUITE(ParameterizedTest) string ignoreSomeVowels; TEST(IgnoreIndex_IgnoreSome) { - vowel + pzVowel .ignoreIndex(1) // "E" .ignoreIndex(4); // "U" - ignoreSomeVowels += vowel(); + ignoreSomeVowels += pzVowel(); } TEST(IgnoreIndex_IgnoreSome_Verify) @@ -256,14 +256,14 @@ SUITE(ParameterizedTest) string ignoreWithNested; TEST(IgnoreIndex_IgnoreWithNested) { - vowel + pzVowel .ignoreIndex(0) // "A" .ignoreIndex(2) // "I" .ignoreIndex(3) // "O" .ignoreIndex(4); // "U" - ignoreWithNested += vowel(); - ignoreWithNested += oneTwo(); + ignoreWithNested += pzVowel(); + ignoreWithNested += pzOneTwo(); } TEST(IgnoreIndex_IgnoreWithNested_Verify) @@ -275,9 +275,9 @@ SUITE(ParameterizedTest) TEST(IgnoreIndex_IgnoreAfterIterationBegan_ThrowsException) { - vowel.ignoreIndex(0); - vowel(); - CHECK_THROW(vowel.ignoreIndex(1), runtime_error); + pzVowel.ignoreIndex(0); + pzVowel(); + CHECK_THROW(pzVowel.ignoreIndex(1), runtime_error); } ////////// @@ -285,11 +285,11 @@ SUITE(ParameterizedTest) string ignoreSomeVowelsByValue; TEST(Ignore_IgnoreSome) { - vowel + pzVowel .ignore("E") .ignore("U"); - ignoreSomeVowelsByValue += vowel(); + ignoreSomeVowelsByValue += pzVowel(); } TEST(Ignore_IgnoreSome_Verify) @@ -300,7 +300,7 @@ SUITE(ParameterizedTest) ////////// SET_SUITE_PARAMETERS(string, pzVowelPartial, { - parameters = vowel.parameters(); + parameters = pzVowel.parameters(); }); struct Initializer From 28576acc601cfc981b3c181e59743e9a8a515099 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Sat, 2 Jul 2016 14:02:38 +0200 Subject: [PATCH 101/131] SET_SUITE_PARAMETERS -> SET_SUITE_PARAMETER --- UnitTest++/ParameterizedMacros.h | 2 +- tests/TestParameterizedTest.cpp | 12 ++++++------ 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/UnitTest++/ParameterizedMacros.h b/UnitTest++/ParameterizedMacros.h index b1effcd..0764f5c 100644 --- a/UnitTest++/ParameterizedMacros.h +++ b/UnitTest++/ParameterizedMacros.h @@ -4,7 +4,7 @@ #include "TestParameter.h" -#define SET_SUITE_PARAMETERS(Type, Name, SetUpBody) \ +#define SET_SUITE_PARAMETER(Type, Name, SetUpBody) \ class ParameterizedCreator##Name \ { \ public: \ diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index 6f07e52..2c1ab42 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -15,7 +15,7 @@ SUITE(ParameterizedTest) string simpleVowels; int simpleVowelsHitCount = 0; - SET_SUITE_PARAMETERS(string, pzVowel, { + SET_SUITE_PARAMETER(string, pzVowel, { parameters.push_back("A"); parameters.push_back("E"); parameters.push_back("I"); @@ -50,7 +50,7 @@ SUITE(ParameterizedTest) bool enteredEmpty = false; int hitCountEmpty = 0; - SET_SUITE_PARAMETERS(int, pzEmpty, { + SET_SUITE_PARAMETER(int, pzEmpty, { }); TEST(WhenNoParameters_throwsException) @@ -81,7 +81,7 @@ SUITE(ParameterizedTest) int hitCountSingle = 0; static int singleValueSuiteSum = 0; - SET_SUITE_PARAMETERS(int, pzSingle, { + SET_SUITE_PARAMETER(int, pzSingle, { parameters.push_back(2); }); @@ -113,7 +113,7 @@ SUITE(ParameterizedTest) ////////// - SET_SUITE_PARAMETERS(string, pzOneTwo, { + SET_SUITE_PARAMETER(string, pzOneTwo, { parameters.push_back("1"); parameters.push_back("2"); }); @@ -161,7 +161,7 @@ SUITE(ParameterizedTest) ////////// - SET_SUITE_PARAMETERS(int, pzSingleBis, { + SET_SUITE_PARAMETER(int, pzSingleBis, { parameters.push_back(3); }); @@ -299,7 +299,7 @@ SUITE(ParameterizedTest) ////////// - SET_SUITE_PARAMETERS(string, pzVowelPartial, { + SET_SUITE_PARAMETER(string, pzVowelPartial, { parameters = pzVowel.parameters(); }); From c340b400634f069cf62727142e3fbd37687962c8 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Mon, 4 Jul 2016 10:34:25 +0200 Subject: [PATCH 102/131] SET_SUITE_PARAMETER -> SET_TEST_PARAMETER --- UnitTest++/ParameterizedMacros.h | 2 +- tests/TestParameterizedTest.cpp | 12 ++++++------ 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/UnitTest++/ParameterizedMacros.h b/UnitTest++/ParameterizedMacros.h index 0764f5c..c9f20b7 100644 --- a/UnitTest++/ParameterizedMacros.h +++ b/UnitTest++/ParameterizedMacros.h @@ -4,7 +4,7 @@ #include "TestParameter.h" -#define SET_SUITE_PARAMETER(Type, Name, SetUpBody) \ +#define SET_TEST_PARAMETER(Type, Name, SetUpBody) \ class ParameterizedCreator##Name \ { \ public: \ diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index 2c1ab42..17afb3c 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -15,7 +15,7 @@ SUITE(ParameterizedTest) string simpleVowels; int simpleVowelsHitCount = 0; - SET_SUITE_PARAMETER(string, pzVowel, { + SET_TEST_PARAMETER(string, pzVowel, { parameters.push_back("A"); parameters.push_back("E"); parameters.push_back("I"); @@ -50,7 +50,7 @@ SUITE(ParameterizedTest) bool enteredEmpty = false; int hitCountEmpty = 0; - SET_SUITE_PARAMETER(int, pzEmpty, { + SET_TEST_PARAMETER(int, pzEmpty, { }); TEST(WhenNoParameters_throwsException) @@ -81,7 +81,7 @@ SUITE(ParameterizedTest) int hitCountSingle = 0; static int singleValueSuiteSum = 0; - SET_SUITE_PARAMETER(int, pzSingle, { + SET_TEST_PARAMETER(int, pzSingle, { parameters.push_back(2); }); @@ -113,7 +113,7 @@ SUITE(ParameterizedTest) ////////// - SET_SUITE_PARAMETER(string, pzOneTwo, { + SET_TEST_PARAMETER(string, pzOneTwo, { parameters.push_back("1"); parameters.push_back("2"); }); @@ -161,7 +161,7 @@ SUITE(ParameterizedTest) ////////// - SET_SUITE_PARAMETER(int, pzSingleBis, { + SET_TEST_PARAMETER(int, pzSingleBis, { parameters.push_back(3); }); @@ -299,7 +299,7 @@ SUITE(ParameterizedTest) ////////// - SET_SUITE_PARAMETER(string, pzVowelPartial, { + SET_TEST_PARAMETER(string, pzVowelPartial, { parameters = pzVowel.parameters(); }); From a15549da7ccec9b0098be26a03b5c2171a9e0475 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Mon, 4 Jul 2016 10:40:10 +0200 Subject: [PATCH 103/131] parameters -> values --- UnitTest++/ParameterizedMacros.h | 2 +- UnitTest++/TestParameter.cpp | 2 +- UnitTest++/TestParameter.h | 36 ++++++++++++++++---------------- tests/TestParameterizedTest.cpp | 31 +++++++++++++-------------- 4 files changed, 35 insertions(+), 36 deletions(-) diff --git a/UnitTest++/ParameterizedMacros.h b/UnitTest++/ParameterizedMacros.h index c9f20b7..26b5f46 100644 --- a/UnitTest++/ParameterizedMacros.h +++ b/UnitTest++/ParameterizedMacros.h @@ -16,7 +16,7 @@ static UnitTest::TestParameter instance(#Name, create()); \ return instance; \ } \ - static vector create() { vector parameters; SetUpBody return parameters; } \ + static vector create() { vector values; SetUpBody return values; } \ } static parameterizedCreator##Name##Instance; \ \ static UnitTest::TestParameter & Name(parameterizedCreator##Name##Instance.globalInstance) diff --git a/UnitTest++/TestParameter.cpp b/UnitTest++/TestParameter.cpp index 2f3eb65..fb43d54 100644 --- a/UnitTest++/TestParameter.cpp +++ b/UnitTest++/TestParameter.cpp @@ -61,7 +61,7 @@ void TestParameterAbstract::nextIndex(bool first) _index++; } - peekCurrentParameter(&ParameterizedManager::getInstance().getCurrentTest()->m_details, _index); + peekCurrent(&ParameterizedManager::getInstance().getCurrentTest()->m_details, _index); } diff --git a/UnitTest++/TestParameter.h b/UnitTest++/TestParameter.h index 960cb2b..65b4105 100644 --- a/UnitTest++/TestParameter.h +++ b/UnitTest++/TestParameter.h @@ -25,7 +25,7 @@ namespace UnitTest protected: void updateCurrentIndex(); - virtual void peekCurrentParameter(TestDetails const * const details, size_t index) = 0; + virtual void peekCurrent(TestDetails const * const details, size_t index) = 0; virtual size_t parametersCount() const = 0; private: @@ -37,64 +37,64 @@ namespace UnitTest }; - template + template class TestParameter : public TestParameterAbstract { public: struct IParameterListener { - virtual void onNext(TestDetails const * const details, T_Parameter current, size_t index) = 0; + virtual void onNext(TestDetails const * const details, T currentValue, size_t currentIndex) = 0; }; - TestParameter(const string & name, vector parameters, IParameterListener* const listener = nullptr) + TestParameter(const string & name, vector values, IParameterListener* const listener = nullptr) : TestParameterAbstract(name), - _parameters(parameters), + _values(values), _listener(listener) { } - T_Parameter operator()() + T operator()() { - return _parameters[getCurrentIndex()]; + return _values[getCurrentIndex()]; } - const vector & parameters() const + const vector & values() const { - return _parameters; + return _values; } - TestParameter & ignoreIndex(size_t index) + TestParameter & ignoreIndex(size_t index) { TestParameterAbstract::ignoreIndex(index); return *this; } - TestParameter & ignore(T_Parameter p) + TestParameter & ignore(T p) { - vector::iterator it = find(_parameters.begin(), _parameters.end(), p); - if (it == _parameters.end()) + vector::iterator it = find(_values.begin(), _values.end(), p); + if (it == _values.end()) { return *this; } - return ignoreIndex(it - _parameters.begin()); + return ignoreIndex(it - _values.begin()); } protected: - virtual void peekCurrentParameter(TestDetails const * const details, size_t index) override + virtual void peekCurrent(TestDetails const * const details, size_t index) override { if (_listener != nullptr) { - _listener->onNext(details, _parameters[index], index); + _listener->onNext(details, _values[index], index); } } virtual size_t parametersCount() const override { - return _parameters.size(); + return _values.size(); } private: - vector _parameters; + vector _values; IParameterListener* const _listener; }; } diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index 17afb3c..6996072 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -16,12 +16,12 @@ SUITE(ParameterizedTest) int simpleVowelsHitCount = 0; SET_TEST_PARAMETER(string, pzVowel, { - parameters.push_back("A"); - parameters.push_back("E"); - parameters.push_back("I"); - parameters.push_back("O"); - parameters.push_back("U"); - parameters.push_back("Y"); + values.push_back("A"); + values.push_back("E"); + values.push_back("I"); + values.push_back("O"); + values.push_back("U"); + values.push_back("Y"); }); TEST(SimpleVowelConcat) @@ -50,8 +50,7 @@ SUITE(ParameterizedTest) bool enteredEmpty = false; int hitCountEmpty = 0; - SET_TEST_PARAMETER(int, pzEmpty, { - }); + SET_TEST_PARAMETER(int, pzEmpty, {}); TEST(WhenNoParameters_throwsException) { @@ -82,7 +81,7 @@ SUITE(ParameterizedTest) static int singleValueSuiteSum = 0; SET_TEST_PARAMETER(int, pzSingle, { - parameters.push_back(2); + values.push_back(2); }); TEST(WhenSingleValue_singleExecution) @@ -114,8 +113,8 @@ SUITE(ParameterizedTest) ////////// SET_TEST_PARAMETER(string, pzOneTwo, { - parameters.push_back("1"); - parameters.push_back("2"); + values.push_back("1"); + values.push_back("2"); }); string nestedParameters; @@ -162,7 +161,7 @@ SUITE(ParameterizedTest) ////////// SET_TEST_PARAMETER(int, pzSingleBis, { - parameters.push_back(3); + values.push_back(3); }); TEST(FailedMessage_ContainsIndexes) @@ -198,13 +197,13 @@ SUITE(ParameterizedTest) TEST(IgnoreIndex_OutOfRange_ThrowsException) { - size_t out = pzVowel.parameters().size(); + size_t out = pzVowel.values().size(); CHECK_THROW(pzVowel.ignoreIndex(out), out_of_range); } TEST(IgnoreIndex_IgnoreAll_ThrowsException) { - size_t last = pzVowel.parameters().size() - 1; + size_t last = pzVowel.values().size() - 1; for (size_t i = 0; i < last; i++) { pzVowel.ignoreIndex(i); @@ -219,7 +218,7 @@ SUITE(ParameterizedTest) string ignoreIndexLast; TEST(IgnoreIndex_IgnoreLast) { - size_t lastIndex = pzOneTwo.parameters().size() - 1; + size_t lastIndex = pzOneTwo.values().size() - 1; pzOneTwo.ignoreIndex(lastIndex); ignoreIndexLast += pzOneTwo(); @@ -300,7 +299,7 @@ SUITE(ParameterizedTest) ////////// SET_TEST_PARAMETER(string, pzVowelPartial, { - parameters = pzVowel.parameters(); + values = pzVowel.values(); }); struct Initializer From aca5bc0e827f280c2e72ee71693c88222c2d6a7f Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 8 Jul 2016 13:02:09 +0200 Subject: [PATCH 104/131] test LoopIsNotDetectableInTestList --- tests/TestParameterizedTest.cpp | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index 6996072..e3a30eb 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -328,4 +328,16 @@ SUITE(ParameterizedTest) { CHECK_EQUAL("AIOYAIOY", globalIgnoreSomeVowels); } + + ////////// + + TEST(LoopIsNotDetectableInTestList) + { + pzOneTwo(); // Important for perform looping + + for (TestListNode* iNode = Test::GetTestList().GetHead(); iNode != nullptr; iNode = iNode->m_next) + { + REQUIRE CHECK(iNode != iNode->m_next); + } + } } From 256ac0b58ad25788a0efa6ae840235bc9db583fe Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 8 Jul 2016 13:14:23 +0200 Subject: [PATCH 105/131] LoopIsNotDetectableInTestList_Verify --- tests/TestParameterizedTest.cpp | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index e3a30eb..9105e73 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -331,6 +331,7 @@ SUITE(ParameterizedTest) ////////// + vector currentTestsNodes; TEST(LoopIsNotDetectableInTestList) { pzOneTwo(); // Important for perform looping @@ -338,6 +339,23 @@ SUITE(ParameterizedTest) for (TestListNode* iNode = Test::GetTestList().GetHead(); iNode != nullptr; iNode = iNode->m_next) { REQUIRE CHECK(iNode != iNode->m_next); + + if (pzOneTwo.getCurrentIndex() == 0) + { + currentTestsNodes.push_back(iNode); + } + } + } + + TEST(LoopIsNotDetectableInTestList_Verify) + { + vector expectedNodes; + for (TestListNode* iNode = Test::GetTestList().GetHead(); iNode != nullptr; iNode = iNode->m_next) + { + expectedNodes.push_back(iNode); } + + REQUIRE CHECK_EQUAL(expectedNodes.size(), currentTestsNodes.size()); + CHECK_ARRAY_EQUAL(expectedNodes, currentTestsNodes, expectedNodes.size()); } } From 4b43692212b3be0b518a48d4ab712f70c96e0097 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 8 Jul 2016 13:16:34 +0200 Subject: [PATCH 106/131] loop only during phasis end->begin (for stay undetectable) --- UnitTest++/ParameterizedManager.cpp | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 48d1281..4d42ccb 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -101,6 +101,7 @@ void ParameterizedManager::beginExecute(TestDetails const * const details) { if (isCurrentTest(details)) { + _currentTest->m_next = _nextTestBackup; _executing = true; } return; @@ -134,11 +135,14 @@ void ParameterizedManager::endExecute(TestDetails const * const details) if (_stack.empty()) { - _currentTest->m_next = _nextTestBackup; _currentTest = nullptr; _nextTestBackup = nullptr; clearNonGlobalIgnoredIndexes(); } + else + { + _currentTest->m_next = _currentTest; // Loop itself + } _iterationDone = false; _executing = false; @@ -208,7 +212,6 @@ bool ParameterizedManager::registerParameter(TestParameterAbstract* const parame if (find(_stack.begin(), _stack.end(), parameterized) == _stack.end()) { _iterationDone = true; - _currentTest->m_next = _currentTest; // Loop itself _stack.push_back(parameterized); outFirstIndex = true; return true; From 8fca8ed30170a84194a08fd110b3f8738b049935 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 8 Jul 2016 13:19:15 +0200 Subject: [PATCH 107/131] minor test enforcement --- tests/TestParameterizedTest.cpp | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index 9105e73..08b277f 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -339,20 +339,20 @@ SUITE(ParameterizedTest) for (TestListNode* iNode = Test::GetTestList().GetHead(); iNode != nullptr; iNode = iNode->m_next) { REQUIRE CHECK(iNode != iNode->m_next); - - if (pzOneTwo.getCurrentIndex() == 0) - { - currentTestsNodes.push_back(iNode); - } + currentTestsNodes.push_back(iNode); } } TEST(LoopIsNotDetectableInTestList_Verify) { vector expectedNodes; - for (TestListNode* iNode = Test::GetTestList().GetHead(); iNode != nullptr; iNode = iNode->m_next) + + for (size_t i = 0; i < pzOneTwo.values().size(); i++) // tested vector contains repeated values because it is filled by parameterized test { - expectedNodes.push_back(iNode); + for (TestListNode* iNode = Test::GetTestList().GetHead(); iNode != nullptr; iNode = iNode->m_next) + { + expectedNodes.push_back(iNode); + } } REQUIRE CHECK_EQUAL(expectedNodes.size(), currentTestsNodes.size()); From cb32b4fa0807f10918a2e9aa08d39e239a309ff2 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 8 Jul 2016 13:19:35 +0200 Subject: [PATCH 108/131] getCurrentTest returns node instead of test --- UnitTest++/ParameterizedManager.cpp | 11 ----------- UnitTest++/ParameterizedManager.h | 2 +- UnitTest++/TestParameter.cpp | 2 +- 3 files changed, 2 insertions(+), 13 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 4d42ccb..ca92661 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -44,17 +44,6 @@ TestListNode* const ParameterizedManager::retrieveTest(TestDetails const * const } -Test* const ParameterizedManager::getCurrentTest() const -{ - if (_currentTest == nullptr) - { - return nullptr; - } - - return _currentTest->m_test; -} - - bool ParameterizedManager::isCurrentTest(TestDetails const * const details) const { if (_currentTest == nullptr) diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index 5183269..ab70e2d 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -15,7 +15,7 @@ namespace UnitTest { public: static ParameterizedManager & getInstance(); - Test* const getCurrentTest() const; + TestListNode* const getCurrentTest() const { return _currentTest; } bool isCurrentTest(TestDetails const * const details) const; void beginExecute(TestDetails const * const details); void endExecute(TestDetails const * const details); diff --git a/UnitTest++/TestParameter.cpp b/UnitTest++/TestParameter.cpp index fb43d54..6564ce1 100644 --- a/UnitTest++/TestParameter.cpp +++ b/UnitTest++/TestParameter.cpp @@ -61,7 +61,7 @@ void TestParameterAbstract::nextIndex(bool first) _index++; } - peekCurrent(&ParameterizedManager::getInstance().getCurrentTest()->m_details, _index); + peekCurrent(&ParameterizedManager::getInstance().getCurrentTest()->m_test->m_details, _index); } From 4a51b5d49944727116487de00168d07b804fee6c Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 8 Jul 2016 13:21:45 +0200 Subject: [PATCH 109/131] tests rename --- tests/TestParameterizedTest.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index 08b277f..243a52e 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -332,7 +332,7 @@ SUITE(ParameterizedTest) ////////// vector currentTestsNodes; - TEST(LoopIsNotDetectableInTestList) + TEST(NoDeadLoopInTestList) { pzOneTwo(); // Important for perform looping @@ -343,7 +343,7 @@ SUITE(ParameterizedTest) } } - TEST(LoopIsNotDetectableInTestList_Verify) + TEST(NoDeadLoopInTestList_Verify) { vector expectedNodes; From 328f64ba851928e11ea915feee8921377e87a567 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 12 Jul 2016 13:23:54 +0200 Subject: [PATCH 110/131] rename "parameters" to "values" --- UnitTest++/ParameterizedManager.cpp | 8 ++++---- UnitTest++/TestParameter.cpp | 6 +++--- UnitTest++/TestParameter.h | 6 +++--- 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index ca92661..954f852 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -57,7 +57,7 @@ bool ParameterizedManager::isCurrentTest(TestDetails const * const details) cons bool ParameterizedManager::hasMoreIndexes(TestParameterAbstract* const parameterized) { - if (!parameterized->hasMoreParameters(1)) + if (!parameterized->hasMoreValues(1)) { return false; } @@ -66,7 +66,7 @@ bool ParameterizedManager::hasMoreIndexes(TestParameterAbstract* const parameter if (!ignoredIndexes.empty()) { bool allRemainingsAreIgnored = true; - for (size_t iIndex = parameterized->_index + 1; iIndex < parameterized->parametersCount(); iIndex++) + for (size_t iIndex = parameterized->_index + 1; iIndex < parameterized->valuesCount(); iIndex++) { if (findIgnored(ignoredIndexes, iIndex) == ignoredIndexes.end()) { @@ -242,7 +242,7 @@ ParameterizedManager & ParameterizedManager::ignoreIndex(TestParameterAbstract* bool global = !_executing; vector & ignoredIndexes = _ignoredIndexes[parameterized]; - if (index >= parameterized->parametersCount()) + if (index >= parameterized->valuesCount()) { throw out_of_range("ignore index is out of range"); } @@ -258,7 +258,7 @@ ParameterizedManager & ParameterizedManager::ignoreIndex(TestParameterAbstract* return *this; } - if (ignoredIndexes.size() + 1 == parameterized->parametersCount()) + if (ignoredIndexes.size() + 1 == parameterized->valuesCount()) { throw runtime_error("all parameters have been ignored, can not proceed"); } diff --git a/UnitTest++/TestParameter.cpp b/UnitTest++/TestParameter.cpp index 6564ce1..f6b4440 100644 --- a/UnitTest++/TestParameter.cpp +++ b/UnitTest++/TestParameter.cpp @@ -40,9 +40,9 @@ void TestParameterAbstract::updateCurrentIndex() } -bool TestParameterAbstract::hasMoreParameters(int advance) const +bool TestParameterAbstract::hasMoreValues(int advance) const { - return (_index + advance < (int)parametersCount()); + return (_index + advance < (int)valuesCount()); } @@ -50,7 +50,7 @@ void TestParameterAbstract::nextIndex(bool first) { if (first) { - if (parametersCount() == 0) + if (valuesCount() == 0) { throw runtime_error("No values for parameterized test"); } diff --git a/UnitTest++/TestParameter.h b/UnitTest++/TestParameter.h index 65b4105..cd63d75 100644 --- a/UnitTest++/TestParameter.h +++ b/UnitTest++/TestParameter.h @@ -26,10 +26,10 @@ namespace UnitTest protected: void updateCurrentIndex(); virtual void peekCurrent(TestDetails const * const details, size_t index) = 0; - virtual size_t parametersCount() const = 0; + virtual size_t valuesCount() const = 0; private: - bool hasMoreParameters(int advance = 0) const; + bool hasMoreValues(int advance = 0) const; void nextIndex(bool first); string _name; @@ -88,7 +88,7 @@ namespace UnitTest } } - virtual size_t parametersCount() const override + virtual size_t valuesCount() const override { return _values.size(); } From 90c678ee0718f5551079170a33d2af17a0ae2508 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 12 Jul 2016 13:27:33 +0200 Subject: [PATCH 111/131] minor chage: const ref --- UnitTest++/TestResults.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/UnitTest++/TestResults.cpp b/UnitTest++/TestResults.cpp index e52f4fe..818900f 100644 --- a/UnitTest++/TestResults.cpp +++ b/UnitTest++/TestResults.cpp @@ -36,7 +36,7 @@ namespace UnitTest { { MemoryOutStream stream; stream << failure; - vector parameters = ParameterizedManager::getInstance().getStack(&test); + const vector & parameters = ParameterizedManager::getInstance().getStack(&test); if (!parameters.empty()) { stream << " Parameters: "; From 7ed07322e6b2213d98947ab1960e2890b72cefe3 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 12 Jul 2016 13:40:49 +0200 Subject: [PATCH 112/131] do not throw exception if index out of range --- UnitTest++/ParameterizedManager.cpp | 2 +- tests/TestParameterizedTest.cpp | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 954f852..f90af7d 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -244,7 +244,7 @@ ParameterizedManager & ParameterizedManager::ignoreIndex(TestParameterAbstract* if (index >= parameterized->valuesCount()) { - throw out_of_range("ignore index is out of range"); + return *this; } vector::iterator ignoredIt = findIgnored(ignoredIndexes, index); diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index 243a52e..fe3eafd 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -195,10 +195,10 @@ SUITE(ParameterizedTest) ////////// - TEST(IgnoreIndex_OutOfRange_ThrowsException) + TEST(IgnoreIndex_OutOfRange_DoesNotThrowException) { size_t out = pzVowel.values().size(); - CHECK_THROW(pzVowel.ignoreIndex(out), out_of_range); + pzVowel.ignoreIndex(out); } TEST(IgnoreIndex_IgnoreAll_ThrowsException) From f7b47b6b1c8e350691545e76e2030bab89b2415a Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 12 Jul 2016 13:43:55 +0200 Subject: [PATCH 113/131] minor simplifications --- UnitTest++/ParameterizedManager.cpp | 19 +++++++++---------- UnitTest++/TestParameter.h | 3 ++- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index f90af7d..e7a567e 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -201,8 +201,8 @@ bool ParameterizedManager::registerParameter(TestParameterAbstract* const parame if (find(_stack.begin(), _stack.end(), parameterized) == _stack.end()) { _iterationDone = true; - _stack.push_back(parameterized); outFirstIndex = true; + _stack.push_back(parameterized); return true; } if (!_iterationDone) @@ -251,20 +251,19 @@ ParameterizedManager & ParameterizedManager::ignoreIndex(TestParameterAbstract* if (ignoredIt != ignoredIndexes.end()) { // Upgrade to global if required - if (!ignoredIt->global && global) + if (global && !ignoredIt->global) { - ignoredIt->global = global; + ignoredIt->global = true; } - return *this; } - - if (ignoredIndexes.size() + 1 == parameterized->valuesCount()) + else { - throw runtime_error("all parameters have been ignored, can not proceed"); + if (ignoredIndexes.size() + 1 == parameterized->valuesCount()) + { + throw runtime_error("all parameters have been ignored, can not proceed"); + } + ignoredIndexes.push_back(IgnoredIndex(index, global)); } - - ignoredIndexes.push_back(IgnoredIndex(index, global)); - return *this; } diff --git a/UnitTest++/TestParameter.h b/UnitTest++/TestParameter.h index cd63d75..9009434 100644 --- a/UnitTest++/TestParameter.h +++ b/UnitTest++/TestParameter.h @@ -55,7 +55,8 @@ namespace UnitTest T operator()() { - return _values[getCurrentIndex()]; + size_t index = getCurrentIndex(); + return _values[index]; } const vector & values() const From b697f9cc10a5b92fb263ce7a3e7f0f5818714d59 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Tue, 12 Jul 2016 14:31:15 +0200 Subject: [PATCH 114/131] macro SET_TEST_PARAMETER_LISTENER(Type, Name, ListenerPtr, SetUpBody) --- UnitTest++/ParameterizedMacros.h | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/UnitTest++/ParameterizedMacros.h b/UnitTest++/ParameterizedMacros.h index 26b5f46..06f2fa1 100644 --- a/UnitTest++/ParameterizedMacros.h +++ b/UnitTest++/ParameterizedMacros.h @@ -4,7 +4,7 @@ #include "TestParameter.h" -#define SET_TEST_PARAMETER(Type, Name, SetUpBody) \ +#define SET_TEST_PARAMETER_LISTENER(Type, Name, ListenerPtr, SetUpBody) \ class ParameterizedCreator##Name \ { \ public: \ @@ -13,7 +13,7 @@ private: \ static UnitTest::TestParameter & getGlobalInstance() \ { \ - static UnitTest::TestParameter instance(#Name, create()); \ + static UnitTest::TestParameter instance(#Name, create(), ListenerPtr); \ return instance; \ } \ static vector create() { vector values; SetUpBody return values; } \ @@ -22,4 +22,8 @@ static UnitTest::TestParameter & Name(parameterizedCreator##Name##Instance.globalInstance) +#define SET_TEST_PARAMETER(Type, Name, SetUpBody) \ + SET_TEST_PARAMETER_LISTENER(Type, Name, nullptr, SetUpBody) + + #endif \ No newline at end of file From ebe11e54c814d942d5093267defbbb3189bc1b8f Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Fri, 22 Jul 2016 11:19:49 +0200 Subject: [PATCH 115/131] method for check if a parameter is ignored --- UnitTest++/ParameterizedManager.cpp | 8 ++++++++ UnitTest++/ParameterizedManager.h | 1 + UnitTest++/TestParameter.cpp | 6 ++++++ UnitTest++/TestParameter.h | 11 +++++++++++ tests/TestParameterizedTest.cpp | 15 +++++++++++++++ 5 files changed, 41 insertions(+) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index e7a567e..becf55c 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -268,6 +268,14 @@ ParameterizedManager & ParameterizedManager::ignoreIndex(TestParameterAbstract* } +bool ParameterizedManager::isIndexIgnored(TestParameterAbstract* const parameterized, size_t index) +{ + vector & ignoredIndexes = _ignoredIndexes[parameterized]; + vector::iterator ignoredIt = findIgnored(ignoredIndexes, index); + return (ignoredIt != ignoredIndexes.end()); +} + + const vector & ParameterizedManager::getStack(TestDetails const * const details) const { if (!isCurrentTest(details)) diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index ab70e2d..d0cead8 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -21,6 +21,7 @@ namespace UnitTest void endExecute(TestDetails const * const details); void updateParameter(TestParameterAbstract* const parameterized); ParameterizedManager & ignoreIndex(TestParameterAbstract* const parameterized, size_t index); + bool isIndexIgnored(TestParameterAbstract* const parameterized, size_t index); const vector & getStack(TestDetails const * const details) const; private: diff --git a/UnitTest++/TestParameter.cpp b/UnitTest++/TestParameter.cpp index f6b4440..a0603b7 100644 --- a/UnitTest++/TestParameter.cpp +++ b/UnitTest++/TestParameter.cpp @@ -70,3 +70,9 @@ TestParameterAbstract & TestParameterAbstract::ignoreIndex(size_t index) ParameterizedManager::getInstance().ignoreIndex(this, index); return *this; } + + +bool TestParameterAbstract::isIndexIgnored(size_t index) +{ + return ParameterizedManager::getInstance().isIndexIgnored(this, index); +} diff --git a/UnitTest++/TestParameter.h b/UnitTest++/TestParameter.h index 9009434..a85d184 100644 --- a/UnitTest++/TestParameter.h +++ b/UnitTest++/TestParameter.h @@ -22,6 +22,7 @@ namespace UnitTest const string & getName() const { return _name; } string getNameCurrent() const; TestParameterAbstract & ignoreIndex(size_t index); + bool isIndexIgnored(size_t index); protected: void updateCurrentIndex(); @@ -80,6 +81,16 @@ namespace UnitTest return ignoreIndex(it - _values.begin()); } + bool isIgnored(T p) + { + vector::iterator it = find(_values.begin(), _values.end(), p); + if (it == _values.end()) + { + return true; + } + return isIndexIgnored(it - _values.begin()); + } + protected: virtual void peekCurrent(TestDetails const * const details, size_t index) override { diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index fe3eafd..ce37147 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -331,6 +331,21 @@ SUITE(ParameterizedTest) ////////// + TEST(Ignore_Getter) + { + pzVowel.ignore("E"); + CHECK(pzVowel.isIgnored("E")); + CHECK(!pzVowel.isIgnored("Y")); + } + + TEST(IgnoreGlobal_Getter) + { + CHECK(pzVowelPartial.isIgnored("E")); + CHECK(!pzVowelPartial.isIgnored("Y")); + } + + ////////// + vector currentTestsNodes; TEST(NoDeadLoopInTestList) { From 87146c137578c53ad7b55ca13c9d62cbba4015ca Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Thu, 28 Jul 2016 11:19:37 +0200 Subject: [PATCH 116/131] method rename --- UnitTest++/ParameterizedManager.cpp | 4 ++-- UnitTest++/ParameterizedManager.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index becf55c..5e65b83 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -189,14 +189,14 @@ void ParameterizedManager::updateParameter(TestParameterAbstract* const paramete void ParameterizedManager::iterate(TestParameterAbstract* const parameterized) { bool firstIndex = false; - if (registerParameter(parameterized, firstIndex)) + if (stackParameter(parameterized, firstIndex)) { parameterized->nextIndex(firstIndex); } } -bool ParameterizedManager::registerParameter(TestParameterAbstract* const parameterized, bool & outFirstIndex) +bool ParameterizedManager::stackParameter(TestParameterAbstract* const parameterized, bool & outFirstIndex) { if (find(_stack.begin(), _stack.end(), parameterized) == _stack.end()) { diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index d0cead8..f58af92 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -38,7 +38,7 @@ namespace UnitTest virtual ~ParameterizedManager(); TestListNode* const retrieveTest(TestDetails const * const details); void iterate(TestParameterAbstract* const parameterized); - bool registerParameter(TestParameterAbstract* const parameterized, bool & outFirstIndex); + bool stackParameter(TestParameterAbstract* const parameterized, bool & outFirstIndex); bool hasMoreIndexes(TestParameterAbstract* const parameterized); vector::iterator findIgnored(vector & ignoredIndexes, size_t index); void clearNonGlobalIgnoredIndexes(); From 4543b15231e9db1eb88740c09bcdb588c9809e68 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Thu, 28 Jul 2016 12:07:02 +0200 Subject: [PATCH 117/131] added possibility to set auto or force local/global ignore --- UnitTest++/ParameterizedManager.cpp | 16 ++++++++++++++-- UnitTest++/ParameterizedManager.h | 3 ++- UnitTest++/TestParameter.cpp | 4 ++-- UnitTest++/TestParameter.h | 9 ++++++++- 4 files changed, 26 insertions(+), 6 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 5e65b83..d410744 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -232,14 +232,26 @@ vector::iterator ParameterizedManager::findI } -ParameterizedManager & ParameterizedManager::ignoreIndex(TestParameterAbstract* const parameterized, size_t index) +bool ParameterizedManager::isGlobal(IgnoreScope scope) +{ + switch (scope) + { + case AUTO: return !_executing; + case LOCAL: return false; + case GLOBAL:return true; + } + throw runtime_error("Invalid enum value for ignore scope"); +} + + +ParameterizedManager & ParameterizedManager::ignoreIndex(TestParameterAbstract* const parameterized, size_t index, IgnoreScope scope) { if (_iterationDone) { throw runtime_error("can not ignore indexes after iteration began"); } - bool global = !_executing; + bool global = isGlobal(scope); vector & ignoredIndexes = _ignoredIndexes[parameterized]; if (index >= parameterized->valuesCount()) diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index f58af92..8f4e26c 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -20,7 +20,7 @@ namespace UnitTest void beginExecute(TestDetails const * const details); void endExecute(TestDetails const * const details); void updateParameter(TestParameterAbstract* const parameterized); - ParameterizedManager & ignoreIndex(TestParameterAbstract* const parameterized, size_t index); + ParameterizedManager & ignoreIndex(TestParameterAbstract* const parameterized, size_t index, IgnoreScope scope = AUTO); bool isIndexIgnored(TestParameterAbstract* const parameterized, size_t index); const vector & getStack(TestDetails const * const details) const; @@ -40,6 +40,7 @@ namespace UnitTest void iterate(TestParameterAbstract* const parameterized); bool stackParameter(TestParameterAbstract* const parameterized, bool & outFirstIndex); bool hasMoreIndexes(TestParameterAbstract* const parameterized); + bool isGlobal(IgnoreScope scope); vector::iterator findIgnored(vector & ignoredIndexes, size_t index); void clearNonGlobalIgnoredIndexes(); diff --git a/UnitTest++/TestParameter.cpp b/UnitTest++/TestParameter.cpp index a0603b7..6de4578 100644 --- a/UnitTest++/TestParameter.cpp +++ b/UnitTest++/TestParameter.cpp @@ -65,9 +65,9 @@ void TestParameterAbstract::nextIndex(bool first) } -TestParameterAbstract & TestParameterAbstract::ignoreIndex(size_t index) +TestParameterAbstract & TestParameterAbstract::ignoreIndex(size_t index, IgnoreScope scope) { - ParameterizedManager::getInstance().ignoreIndex(this, index); + ParameterizedManager::getInstance().ignoreIndex(this, index, scope); return *this; } diff --git a/UnitTest++/TestParameter.h b/UnitTest++/TestParameter.h index a85d184..83eb297 100644 --- a/UnitTest++/TestParameter.h +++ b/UnitTest++/TestParameter.h @@ -12,6 +12,13 @@ namespace UnitTest { using namespace std; + enum IgnoreScope + { + AUTO, + LOCAL, + GLOBAL + }; + class TestParameterAbstract { friend class ParameterizedManager; @@ -21,7 +28,7 @@ namespace UnitTest size_t getCurrentIndex(); const string & getName() const { return _name; } string getNameCurrent() const; - TestParameterAbstract & ignoreIndex(size_t index); + TestParameterAbstract & ignoreIndex(size_t index, IgnoreScope scope = AUTO); bool isIndexIgnored(size_t index); protected: From 672b17bddd99c25b92a121e4272b10239c999da8 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Thu, 28 Jul 2016 12:26:28 +0200 Subject: [PATCH 118/131] added feature ignore index by parameter name --- UnitTest++/ParameterizedManager.cpp | 34 +++++++++++++++++++++++++++++ UnitTest++/ParameterizedManager.h | 6 ++++- 2 files changed, 39 insertions(+), 1 deletion(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index d410744..1f79a61 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -170,6 +170,7 @@ void ParameterizedManager::clearNonGlobalIgnoredIndexes() void ParameterizedManager::updateParameter(TestParameterAbstract* const parameterized) { + importIgnoredParameter(parameterized); vector & ignoredIndexes = _ignoredIndexes[parameterized]; bool repeat = true; while (repeat) @@ -232,6 +233,24 @@ vector::iterator ParameterizedManager::findI } +void ParameterizedManager::importIgnoredParameter(TestParameterAbstract* const parameterized) +{ + IgnoredIndexesByNameMap::iterator it = _pendingIgnoredIndexes.find(parameterized->getName()); + if (it == _pendingIgnoredIndexes.end()) + { + return; + } + + vector & pendingIgnoredIndexes = it->second; + while (!pendingIgnoredIndexes.empty()) + { + const IgnoredIndex & iIgnored = pendingIgnoredIndexes.back(); + ignoreIndex(parameterized, iIgnored.index, iIgnored.global ? GLOBAL : LOCAL); + pendingIgnoredIndexes.pop_back(); + } +} + + bool ParameterizedManager::isGlobal(IgnoreScope scope) { switch (scope) @@ -280,6 +299,21 @@ ParameterizedManager & ParameterizedManager::ignoreIndex(TestParameterAbstract* } +ParameterizedManager & ParameterizedManager::ignoreIndex(const string & parameterName, size_t index, IgnoreScope scope) +{ + if (parameterName.empty()) + { + throw invalid_argument("Empty parameter name given in ignore index"); + } + + // Note: do not care about duplicates indexes for now + bool global = isGlobal(scope); + _pendingIgnoredIndexes[parameterName].push_back(IgnoredIndex(index, global)); + + return *this; +} + + bool ParameterizedManager::isIndexIgnored(TestParameterAbstract* const parameterized, size_t index) { vector & ignoredIndexes = _ignoredIndexes[parameterized]; diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index 8f4e26c..770f28b 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -21,6 +21,7 @@ namespace UnitTest void endExecute(TestDetails const * const details); void updateParameter(TestParameterAbstract* const parameterized); ParameterizedManager & ignoreIndex(TestParameterAbstract* const parameterized, size_t index, IgnoreScope scope = AUTO); + ParameterizedManager & ignoreIndex(const string & parameterName, size_t index, IgnoreScope scope = AUTO); bool isIndexIgnored(TestParameterAbstract* const parameterized, size_t index); const vector & getStack(TestDetails const * const details) const; @@ -31,8 +32,9 @@ namespace UnitTest size_t index; bool global; }; - + typedef unordered_map> IgnoredIndexesMap; + typedef unordered_map> IgnoredIndexesByNameMap; ParameterizedManager(); virtual ~ParameterizedManager(); @@ -42,12 +44,14 @@ namespace UnitTest bool hasMoreIndexes(TestParameterAbstract* const parameterized); bool isGlobal(IgnoreScope scope); vector::iterator findIgnored(vector & ignoredIndexes, size_t index); + void importIgnoredParameter(TestParameterAbstract* const parameterized); void clearNonGlobalIgnoredIndexes(); TestListNode* _currentTest; TestListNode* _nextTestBackup; vector _stack; IgnoredIndexesMap _ignoredIndexes; + IgnoredIndexesByNameMap _pendingIgnoredIndexes; volatile bool _iterationDone; volatile bool _executing; }; From 0f7dd82fbb1cffb77b6ad17300274cfd7ba359b0 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Thu, 28 Jul 2016 13:05:24 +0200 Subject: [PATCH 119/131] created tests --- tests/TestParameterizedTest.cpp | 41 +++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index ce37147..eea2ac8 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -373,4 +373,45 @@ SUITE(ParameterizedTest) REQUIRE CHECK_EQUAL(expectedNodes.size(), currentTestsNodes.size()); CHECK_ARRAY_EQUAL(expectedNodes, currentTestsNodes, expectedNodes.size()); } + + ////////// + + struct Initializer4pzIgnoredByNameVowel + { + Initializer4pzIgnoredByNameVowel() + { + ParameterizedManager::getInstance() + .ignoreIndex("pzIgnoredByNameVowel", 2) // "I" + .ignoreIndex("pzIgnoredByNameVowel", 5); // "Y" + } + } initializer4pzIgnoredByNameVowelInstance; + + SET_TEST_PARAMETER(string, pzIgnoredByNameVowel, { + values = pzVowel.values(); + }); + + string ignoreSomeVowelsByName_Global; + TEST(Ignore_IgnoreByName_Global) + { + ignoreSomeVowelsByName_Global += pzIgnoredByNameVowel(); + } + + TEST(Ignore_IgnoreByName_Global_Verify) + { + CHECK_EQUAL("AEOU", ignoreSomeVowelsByName_Global); + } + + string ignoreSomeVowelsByName_Local; + TEST(Ignore_IgnoreByName_Local) + { + ParameterizedManager::getInstance() + .ignoreIndex("pzIgnoredByNameVowel", 3); // "O" + + ignoreSomeVowelsByName_Local += pzIgnoredByNameVowel(); + } + + TEST(Ignore_IgnoreByName_Local_Verify) + { + CHECK_EQUAL("AEU", ignoreSomeVowelsByName_Local); + } } From 57cc9631f3dfce3b84938709b832dfb26b6f08f1 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Thu, 28 Jul 2016 13:10:05 +0200 Subject: [PATCH 120/131] simplification: added SuitePredicate::addAll --- UnitTest++/SuitePredicate.cpp | 11 +++++++++++ UnitTest++/SuitePredicate.h | 2 ++ UnitTest++/TestRunner.cpp | 34 ++++++++++++++++++---------------- 3 files changed, 31 insertions(+), 16 deletions(-) diff --git a/UnitTest++/SuitePredicate.cpp b/UnitTest++/SuitePredicate.cpp index e2876d8..8a5748d 100644 --- a/UnitTest++/SuitePredicate.cpp +++ b/UnitTest++/SuitePredicate.cpp @@ -5,6 +5,7 @@ using namespace UnitTest; SuitePredicate::SuitePredicate() + : _all(false) { } @@ -26,8 +27,18 @@ void SuitePredicate::addTest(char const* testName) } +void SuitePredicate::addAll() +{ + _all = true; +} + + bool SuitePredicate::operator()(Test const * const test) const { + if (_all) + { + return true; + } return (mustExecuteSuite(test) || mustExecuteTest(test)); } diff --git a/UnitTest++/SuitePredicate.h b/UnitTest++/SuitePredicate.h index c9cf8c7..f9fb31c 100644 --- a/UnitTest++/SuitePredicate.h +++ b/UnitTest++/SuitePredicate.h @@ -17,6 +17,7 @@ namespace UnitTest void addSuite(char const* suiteName); void addTest(char const* testName); + void addAll(); bool operator()(Test const * const test) const; @@ -26,6 +27,7 @@ namespace UnitTest vector _suiteNames; vector _testNames; + bool _all; }; } diff --git a/UnitTest++/TestRunner.cpp b/UnitTest++/TestRunner.cpp index 1fe598e..087fd82 100644 --- a/UnitTest++/TestRunner.cpp +++ b/UnitTest++/TestRunner.cpp @@ -20,27 +20,29 @@ namespace UnitTest { int RunTestsCmd(int argc, char**argv, char const* suiteArgument) { - if (argc <= 1) - { - return UnitTest::RunAllTests(); - } - - //if first arg is "--suite", we search for suite names instead of test names - const bool suite = strcmp(suiteArgument, argv[1]) == 0; - SuitePredicate predicate; - int from = (suite) ? 2 : 1; - for (int i = from; i < argc; ++i) + if (argc > 1) { - if (suite) - { - predicate.addSuite(argv[i]); - } - else + //if first arg is "--suite", we search for suite names instead of test names + const bool suite = strcmp(suiteArgument, argv[1]) == 0; + + int from = (suite) ? 2 : 1; + for (int i = from; i < argc; ++i) { - predicate.addTest(argv[i]); + if (suite) + { + predicate.addSuite(argv[i]); + } + else + { + predicate.addTest(argv[i]); + } } } + else + { + predicate.addAll(); + } //run selected test(s) only TestReporterStdout reporter; From c077a46380097914128d2283fd7ddb69d3633a3b Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Thu, 28 Jul 2016 13:42:01 +0200 Subject: [PATCH 121/131] cleaned params argument and now mandatory param "--test" --- UnitTest++/TestRunner.cpp | 110 +++++++++++++++++++++++++++----------- UnitTest++/TestRunner.h | 2 +- 2 files changed, 81 insertions(+), 31 deletions(-) diff --git a/UnitTest++/TestRunner.cpp b/UnitTest++/TestRunner.cpp index 087fd82..f143eca 100644 --- a/UnitTest++/TestRunner.cpp +++ b/UnitTest++/TestRunner.cpp @@ -18,37 +18,87 @@ namespace UnitTest { return runner.RunTestsIf(Test::GetTestList(), NULL, True(), 0); } - int RunTestsCmd(int argc, char**argv, char const* suiteArgument) + bool findArgumentListIndex(int argc, char**argv, char const* argument, int & outFrom, int & outCount) { - SuitePredicate predicate; - if (argc > 1) - { - //if first arg is "--suite", we search for suite names instead of test names - const bool suite = strcmp(suiteArgument, argv[1]) == 0; - - int from = (suite) ? 2 : 1; - for (int i = from; i < argc; ++i) - { - if (suite) - { - predicate.addSuite(argv[i]); - } - else - { - predicate.addTest(argv[i]); - } - } - } - else - { - predicate.addAll(); - } - - //run selected test(s) only - TestReporterStdout reporter; - TestRunner runner(reporter); - - return runner.RunTestsIf(Test::GetTestList(), 0, predicate, 0); + if (argc <= 1) + { + return false; + } + + outFrom = -1; + for (int i = 1; i < argc; i++) + { + if (strcmp(argument, argv[i]) == 0) + { + outFrom = i; + break; + } + } + if (outFrom == -1) + { + return false; + } + outFrom++; + outCount = 0; + for (int i = outFrom; i < argc; i++) + { + char* value = argv[i]; + if (strlen(value) >= 2 && value[0] == '-'&& value[1] == '-') + { + break; + } + outCount++; + } + + return true; + } + + bool readSuiteArgument(SuitePredicate & predicate, int argc, char**argv, char const* argument) + { + int from, count; + if (!findArgumentListIndex(argc, argv, argument, from, count)) + { + return false; + } + for (int i = from; i < from + count; i++) + { + predicate.addSuite(argv[i]); + } + return true; + } + + bool readTestArgument(SuitePredicate & predicate, int argc, char**argv, char const* argument) + { + int from, count; + if (!findArgumentListIndex(argc, argv, argument, from, count)) + { + return false; + } + for (int i = from; i < from + count; i++) + { + predicate.addTest(argv[i]); + } + return true; + } + + int RunTestsCmd(int argc, char**argv, char const* suiteArgument, char const* testArgument) + { + SuitePredicate predicate; + + bool specific = false; + specific |= readSuiteArgument(predicate, argc, argv, suiteArgument); + specific |= readTestArgument(predicate, argc, argv, testArgument); + + if (!specific) + { + predicate.addAll(); + } + + //run selected test(s) only + TestReporterStdout reporter; + TestRunner runner(reporter); + + return runner.RunTestsIf(Test::GetTestList(), 0, predicate, 0); } TestRunner::TestRunner(TestReporter& reporter) diff --git a/UnitTest++/TestRunner.h b/UnitTest++/TestRunner.h index 08780bc..9226f2b 100644 --- a/UnitTest++/TestRunner.h +++ b/UnitTest++/TestRunner.h @@ -12,7 +12,7 @@ namespace UnitTest { class Timer; UNITTEST_LINKAGE int RunAllTests(); - UNITTEST_LINKAGE int RunTestsCmd(int argc, char**argv, char const* suiteArgument = "--suite"); + UNITTEST_LINKAGE int RunTestsCmd(int argc, char**argv, char const* suiteArgument = "--suite", char const* testArgument = "--test"); struct True { From c91ff62af2a020c654c6724dc0d90e3736e7e038 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Thu, 28 Jul 2016 14:47:00 +0200 Subject: [PATCH 122/131] analyze ignore by array name --- UnitTest++/ParameterizedManager.cpp | 30 +++++++++++++++++++++++++++++ UnitTest++/ParameterizedManager.h | 1 + 2 files changed, 31 insertions(+) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 1f79a61..117d917 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -1,6 +1,7 @@ #include "ParameterizedManager.h" #include "Test.h" +#include using namespace std; using namespace UnitTest; @@ -314,6 +315,35 @@ ParameterizedManager & ParameterizedManager::ignoreIndex(const string & paramete } +ParameterizedManager & ParameterizedManager::ignoreIndexes(const string & parametersArrayRange, IgnoreScope scope) +{ + if (parametersArrayRange.empty()) + { + throw invalid_argument("Empty parameter array range given in ignore index"); + } + + size_t openPos = parametersArrayRange.find('['); + size_t closePos = parametersArrayRange.find(']'); + if (openPos == 0 || openPos == string::npos || closePos == string::npos || closePos < openPos) + { + throw invalid_argument("Misformatted ignore index, should be pzMyParam[0,1,2]"); + } + + string parameterName = parametersArrayRange.substr(0, openPos); + string indexes = parametersArrayRange.substr(openPos + 1, closePos - openPos - 1); + + stringstream stream(indexes); + string item; + while (getline(stream, item, ',')) + { + int index = stoi(item); + ignoreIndex(parameterName, index, scope); + } + + return *this; +} + + bool ParameterizedManager::isIndexIgnored(TestParameterAbstract* const parameterized, size_t index) { vector & ignoredIndexes = _ignoredIndexes[parameterized]; diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index 770f28b..7443704 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -22,6 +22,7 @@ namespace UnitTest void updateParameter(TestParameterAbstract* const parameterized); ParameterizedManager & ignoreIndex(TestParameterAbstract* const parameterized, size_t index, IgnoreScope scope = AUTO); ParameterizedManager & ignoreIndex(const string & parameterName, size_t index, IgnoreScope scope = AUTO); + ParameterizedManager & ignoreIndexes(const string & parametersArrayRange, IgnoreScope scope = AUTO); bool isIndexIgnored(TestParameterAbstract* const parameterized, size_t index); const vector & getStack(TestDetails const * const details) const; From 923cd554fcb141e67ec5fa0d3fa6a69800bedfd2 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Thu, 28 Jul 2016 14:47:09 +0200 Subject: [PATCH 123/131] added tests --- tests/TestParameterizedTest.cpp | 45 ++++++++++++++++++++++++++++++++- 1 file changed, 44 insertions(+), 1 deletion(-) diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index eea2ac8..a9d2e96 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -373,7 +373,7 @@ SUITE(ParameterizedTest) REQUIRE CHECK_EQUAL(expectedNodes.size(), currentTestsNodes.size()); CHECK_ARRAY_EQUAL(expectedNodes, currentTestsNodes, expectedNodes.size()); } - + ////////// struct Initializer4pzIgnoredByNameVowel @@ -414,4 +414,47 @@ SUITE(ParameterizedTest) { CHECK_EQUAL("AEU", ignoreSomeVowelsByName_Local); } + + + ////////// + + SET_TEST_PARAMETER(string, pzIgnoredByNameVowelSome, { + values = pzVowel.values(); + }); + + string ignoreByNameRangeEmptyIsAllowed; + TEST(Ignore_IgnoreByNameRange_EmptyIsAllowed) + { + ParameterizedManager::getInstance().ignoreIndexes("pzIgnoredByNameVowelSome[]"); + ignoreByNameRangeEmptyIsAllowed += pzIgnoredByNameVowelSome(); + } + + TEST(Ignore_IgnoreByNameRange_EmptyIsAllowed_Verify) + { + CHECK_EQUAL("AEIOUY", ignoreByNameRangeEmptyIsAllowed); + } + + string ignoreByNameRangeSingleValue; + TEST(Ignore_IgnoreByNameRange_SingleValue) + { + ParameterizedManager::getInstance().ignoreIndexes("pzIgnoredByNameVowelSome[2]"); + ignoreByNameRangeSingleValue += pzIgnoredByNameVowelSome(); + } + + TEST(Ignore_IgnoreByNameRange_SingleValue_Verify) + { + CHECK_EQUAL("AEOUY", ignoreByNameRangeSingleValue); + } + + string ignoreByNameRangeSeveralUnorderedValues; + TEST(Ignore_IgnoreByNameRange_SeveralUnorderedValues) + { + ParameterizedManager::getInstance().ignoreIndexes("pzIgnoredByNameVowelSome[3,4,0]"); + ignoreByNameRangeSeveralUnorderedValues += pzIgnoredByNameVowelSome(); + } + + TEST(Ignore_IgnoreByNameRange_SeveralUnorderedValues_Verify) + { + CHECK_EQUAL("EIY", ignoreByNameRangeSeveralUnorderedValues); + } } From 62378a6f7eee6d75eb69c0cc1f905fa0c1fb47d5 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Thu, 28 Jul 2016 14:55:53 +0200 Subject: [PATCH 124/131] added argument "--ignoreparam" (ex: --ignoreparam pzToto[0,2,6]) --- UnitTest++/TestRunner.cpp | 19 ++++++++++++++++++- UnitTest++/TestRunner.h | 2 +- 2 files changed, 19 insertions(+), 2 deletions(-) diff --git a/UnitTest++/TestRunner.cpp b/UnitTest++/TestRunner.cpp index f143eca..6f19121 100644 --- a/UnitTest++/TestRunner.cpp +++ b/UnitTest++/TestRunner.cpp @@ -5,6 +5,7 @@ #include "TimeHelpers.h" #include "MemoryOutStream.h" #include "SuitePredicate.h" +#include "ParameterizedManager.h" #include @@ -81,7 +82,21 @@ namespace UnitTest { return true; } - int RunTestsCmd(int argc, char**argv, char const* suiteArgument, char const* testArgument) + bool readIgnoreParamArgument(int argc, char**argv, char const* argument) + { + int from, count; + if (!findArgumentListIndex(argc, argv, argument, from, count)) + { + return false; + } + for (int i = from; i < from + count; i++) + { + ParameterizedManager::getInstance().ignoreIndexes(argv[i]); + } + return true; + } + + int RunTestsCmd(int argc, char**argv, char const* suiteArgument, char const* testArgument, char const* ignoreParamArgument) { SuitePredicate predicate; @@ -89,6 +104,8 @@ namespace UnitTest { specific |= readSuiteArgument(predicate, argc, argv, suiteArgument); specific |= readTestArgument(predicate, argc, argv, testArgument); + readIgnoreParamArgument(argc, argv, ignoreParamArgument); + if (!specific) { predicate.addAll(); diff --git a/UnitTest++/TestRunner.h b/UnitTest++/TestRunner.h index 9226f2b..fbf14c0 100644 --- a/UnitTest++/TestRunner.h +++ b/UnitTest++/TestRunner.h @@ -12,7 +12,7 @@ namespace UnitTest { class Timer; UNITTEST_LINKAGE int RunAllTests(); - UNITTEST_LINKAGE int RunTestsCmd(int argc, char**argv, char const* suiteArgument = "--suite", char const* testArgument = "--test"); + UNITTEST_LINKAGE int RunTestsCmd(int argc, char**argv, char const* suiteArgument = "--suite", char const* testArgument = "--test", char const* ignoreParamArgument = "--ignoreparam"); struct True { From 924c8ed317ebb4aaa84f7ae174fc72fe51b9f3cd Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Thu, 28 Jul 2016 15:47:17 +0200 Subject: [PATCH 125/131] added comment about how to use commands --- UnitTest++/TestRunner.h | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/UnitTest++/TestRunner.h b/UnitTest++/TestRunner.h index fbf14c0..55f3856 100644 --- a/UnitTest++/TestRunner.h +++ b/UnitTest++/TestRunner.h @@ -12,6 +12,15 @@ namespace UnitTest { class Timer; UNITTEST_LINKAGE int RunAllTests(); + + /** + * Commands: + * --suite One or multiple suite names to execute, can be combined with --test + * --test One or multiple test names to execute, can be combined with --suite + * --ignoretest One or multiple test parameter name, with index(es) specified, using this syntax: pzMyParam[4,8,12,7] + * + * Usage example: myTests.exe --suite MySuite1 MyOtherSuite --test MySpecialTest MyOtherTest --ignoreparam pzMyPlatforms[0,2,3] pzMyParam[4,8] + */ UNITTEST_LINKAGE int RunTestsCmd(int argc, char**argv, char const* suiteArgument = "--suite", char const* testArgument = "--test", char const* ignoreParamArgument = "--ignoreparam"); struct True From 16e0dc2f654706a1ec620574c8563e1c2f3ed607 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Thu, 28 Jul 2016 15:50:18 +0200 Subject: [PATCH 126/131] fixed comment --- UnitTest++/TestRunner.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/UnitTest++/TestRunner.h b/UnitTest++/TestRunner.h index 55f3856..62b56e6 100644 --- a/UnitTest++/TestRunner.h +++ b/UnitTest++/TestRunner.h @@ -17,7 +17,7 @@ namespace UnitTest { * Commands: * --suite One or multiple suite names to execute, can be combined with --test * --test One or multiple test names to execute, can be combined with --suite - * --ignoretest One or multiple test parameter name, with index(es) specified, using this syntax: pzMyParam[4,8,12,7] + * --ignoreparam One or multiple test parameter name, with index(es) specified, using this syntax: pzMyParam[4,8,12,7] * * Usage example: myTests.exe --suite MySuite1 MyOtherSuite --test MySpecialTest MyOtherTest --ignoreparam pzMyPlatforms[0,2,3] pzMyParam[4,8] */ From 69ccda496844a0102e956b19c5ee4c569375bed5 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Thu, 28 Jul 2016 16:10:36 +0200 Subject: [PATCH 127/131] generalization --- UnitTest++/ParameterizedManager.cpp | 23 ++++++++++++++++++----- UnitTest++/ParameterizedManager.h | 2 ++ 2 files changed, 20 insertions(+), 5 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 117d917..38a0416 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -316,31 +316,44 @@ ParameterizedManager & ParameterizedManager::ignoreIndex(const string & paramete ParameterizedManager & ParameterizedManager::ignoreIndexes(const string & parametersArrayRange, IgnoreScope scope) +{ + string parameterName; + vector indexes = parseParameter(parametersArrayRange, parameterName); + for (size_t i = 0; i < indexes.size(); i++) + { + ignoreIndex(parameterName, indexes[i], scope); + } + return *this; +} + + +vector ParameterizedManager::parseParameter(const string & parametersArrayRange, string & outParameterName) { if (parametersArrayRange.empty()) { - throw invalid_argument("Empty parameter array range given in ignore index"); + throw invalid_argument("Empty parameter array range given"); } size_t openPos = parametersArrayRange.find('['); size_t closePos = parametersArrayRange.find(']'); if (openPos == 0 || openPos == string::npos || closePos == string::npos || closePos < openPos) { - throw invalid_argument("Misformatted ignore index, should be pzMyParam[0,1,2]"); + throw invalid_argument("Misformatted parameter array range index, should be pzMyParam[0,1,2]"); } - string parameterName = parametersArrayRange.substr(0, openPos); + outParameterName = parametersArrayRange.substr(0, openPos); string indexes = parametersArrayRange.substr(openPos + 1, closePos - openPos - 1); stringstream stream(indexes); string item; + vector indexesList; while (getline(stream, item, ',')) { int index = stoi(item); - ignoreIndex(parameterName, index, scope); + indexesList.push_back(index); } - return *this; + return indexesList; } diff --git a/UnitTest++/ParameterizedManager.h b/UnitTest++/ParameterizedManager.h index 7443704..3645265 100644 --- a/UnitTest++/ParameterizedManager.h +++ b/UnitTest++/ParameterizedManager.h @@ -48,6 +48,8 @@ namespace UnitTest void importIgnoredParameter(TestParameterAbstract* const parameterized); void clearNonGlobalIgnoredIndexes(); + static vector parseParameter(const string & parametersArrayRange, string & outParameterName); + TestListNode* _currentTest; TestListNode* _nextTestBackup; vector _stack; From 21b1a598b9014d1380b0a93a57bfcdc080c50a15 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Mon, 22 Aug 2016 14:41:26 +0200 Subject: [PATCH 128/131] specify "--test" is optional --- UnitTest++/TestRunner.cpp | 26 +++++++++++++++++--------- UnitTest++/TestRunner.h | 6 ++++-- 2 files changed, 21 insertions(+), 11 deletions(-) diff --git a/UnitTest++/TestRunner.cpp b/UnitTest++/TestRunner.cpp index 6f19121..a71de3e 100644 --- a/UnitTest++/TestRunner.cpp +++ b/UnitTest++/TestRunner.cpp @@ -26,21 +26,28 @@ namespace UnitTest { return false; } - outFrom = -1; - for (int i = 1; i < argc; i++) + outCount = 0; + if (strlen(argument) > 0) { - if (strcmp(argument, argv[i]) == 0) + outFrom = 0; + for (int i = 1; i < argc; i++) { - outFrom = i; - break; + if (strcmp(argument, argv[i]) == 0) + { + outFrom = i + 1; + break; + } + } + if (outFrom == 0) + { + return false; } } - if (outFrom == -1) + else { - return false; + outFrom = 1; } - outFrom++; - outCount = 0; + for (int i = outFrom; i < argc; i++) { char* value = argv[i]; @@ -103,6 +110,7 @@ namespace UnitTest { bool specific = false; specific |= readSuiteArgument(predicate, argc, argv, suiteArgument); specific |= readTestArgument(predicate, argc, argv, testArgument); + specific |= readTestArgument(predicate, argc, argv, ""); readIgnoreParamArgument(argc, argv, ignoreParamArgument); diff --git a/UnitTest++/TestRunner.h b/UnitTest++/TestRunner.h index 62b56e6..78b8962 100644 --- a/UnitTest++/TestRunner.h +++ b/UnitTest++/TestRunner.h @@ -15,11 +15,13 @@ namespace UnitTest { /** * Commands: + * --test One or multiple test names to execute (specify "--test" is optional if it is the first argument), can be combined with --suite * --suite One or multiple suite names to execute, can be combined with --test - * --test One or multiple test names to execute, can be combined with --suite * --ignoreparam One or multiple test parameter name, with index(es) specified, using this syntax: pzMyParam[4,8,12,7] * - * Usage example: myTests.exe --suite MySuite1 MyOtherSuite --test MySpecialTest MyOtherTest --ignoreparam pzMyPlatforms[0,2,3] pzMyParam[4,8] + * Usage examples: + * myTests.exe --suite MySuite1 MyOtherSuite --test MySpecialTest MyOtherTest --ignoreparam pzMyPlatforms[0,2,3] pzMyParam[4,8] + * myTests.exe MySpecialTest MyOtherTest --suite MySuite1 */ UNITTEST_LINKAGE int RunTestsCmd(int argc, char**argv, char const* suiteArgument = "--suite", char const* testArgument = "--test", char const* ignoreParamArgument = "--ignoreparam"); From a77b0c74fb3df8190c0bbc825d327a930db3dadd Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Wed, 24 Aug 2016 13:18:02 +0200 Subject: [PATCH 129/131] removed non pertinant and problematic condition --- UnitTest++/ParameterizedManager.cpp | 5 ----- 1 file changed, 5 deletions(-) diff --git a/UnitTest++/ParameterizedManager.cpp b/UnitTest++/ParameterizedManager.cpp index 38a0416..25de010 100644 --- a/UnitTest++/ParameterizedManager.cpp +++ b/UnitTest++/ParameterizedManager.cpp @@ -266,11 +266,6 @@ bool ParameterizedManager::isGlobal(IgnoreScope scope) ParameterizedManager & ParameterizedManager::ignoreIndex(TestParameterAbstract* const parameterized, size_t index, IgnoreScope scope) { - if (_iterationDone) - { - throw runtime_error("can not ignore indexes after iteration began"); - } - bool global = isGlobal(scope); vector & ignoredIndexes = _ignoredIndexes[parameterized]; From b48bd9852ecc3f621c619c7570b58cb205217cc1 Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Thu, 25 Aug 2016 17:44:12 +0200 Subject: [PATCH 130/131] added long/short macro --- UnitTest++/ParameterizedMacros.h | 20 +++++++++++++++++--- tests/TestLongMacros.cpp | 4 +++- 2 files changed, 20 insertions(+), 4 deletions(-) diff --git a/UnitTest++/ParameterizedMacros.h b/UnitTest++/ParameterizedMacros.h index 06f2fa1..37a71bc 100644 --- a/UnitTest++/ParameterizedMacros.h +++ b/UnitTest++/ParameterizedMacros.h @@ -4,7 +4,7 @@ #include "TestParameter.h" -#define SET_TEST_PARAMETER_LISTENER(Type, Name, ListenerPtr, SetUpBody) \ +#define UNITTEST_SET_TEST_PARAMETER_LISTENER(Type, Name, ListenerPtr, SetUpBody) \ class ParameterizedCreator##Name \ { \ public: \ @@ -22,8 +22,22 @@ static UnitTest::TestParameter & Name(parameterizedCreator##Name##Instance.globalInstance) -#define SET_TEST_PARAMETER(Type, Name, SetUpBody) \ - SET_TEST_PARAMETER_LISTENER(Type, Name, nullptr, SetUpBody) +#define UNITTEST_SET_TEST_PARAMETER(Type, Name, SetUpBody) \ + UNITTEST_SET_TEST_PARAMETER_LISTENER(Type, Name, nullptr, SetUpBody) +#ifndef UNITTEST_DISABLE_SHORT_MACROS + #ifdef SET_TEST_PARAMETER_LISTENER + #error SET_TEST_PARAMETER_LISTENER already defined, re-configure with UNITTEST_ENABLE_SHORT_MACROS set to 0 and use UNITTEST_SET_TEST_PARAMETER_LISTENER instead + #else + #define SET_TEST_PARAMETER_LISTENER UNITTEST_SET_TEST_PARAMETER_LISTENER + #endif + + #ifdef SET_TEST_PARAMETER + #error SET_TEST_PARAMETER already defined, re-configure with UNITTEST_ENABLE_SHORT_MACROS set to 0 and use UNITTEST_SET_TEST_PARAMETER instead + #else + #define SET_TEST_PARAMETER UNITTEST_SET_TEST_PARAMETER + #endif +#endif + #endif \ No newline at end of file diff --git a/tests/TestLongMacros.cpp b/tests/TestLongMacros.cpp index 6720a97..6c58830 100644 --- a/tests/TestLongMacros.cpp +++ b/tests/TestLongMacros.cpp @@ -37,7 +37,9 @@ UNITTEST_SUITE(LongMacros) defined(SUITE) || \ defined(TEST) || \ defined(TEST_FIXTURE) || \ - defined(REQUIRE) + defined(REQUIRE) || \ + defined(SET_TEST_PARAMETER_LISTENER) || \ + defined(SET_TEST_PARAMETER) UNITTEST_CHECK(false); #endif From 17d6e82ca66db64d4c93e465c7f631d6c47e27aa Mon Sep 17 00:00:00 2001 From: Gabriel Schlozer Date: Thu, 25 Aug 2016 17:48:28 +0200 Subject: [PATCH 131/131] forgot to remove this test after commit a77b0c74fb3df8190c0bbc825d327a930db3dadd --- tests/TestParameterizedTest.cpp | 9 --------- 1 file changed, 9 deletions(-) diff --git a/tests/TestParameterizedTest.cpp b/tests/TestParameterizedTest.cpp index a9d2e96..6589131 100644 --- a/tests/TestParameterizedTest.cpp +++ b/tests/TestParameterizedTest.cpp @@ -272,15 +272,6 @@ SUITE(ParameterizedTest) ////////// - TEST(IgnoreIndex_IgnoreAfterIterationBegan_ThrowsException) - { - pzVowel.ignoreIndex(0); - pzVowel(); - CHECK_THROW(pzVowel.ignoreIndex(1), runtime_error); - } - - ////////// - string ignoreSomeVowelsByValue; TEST(Ignore_IgnoreSome) {