unittest-cpp · killoctal · May 11, 2016 · May 11, 2016 · May 11, 2016 · May 11, 2016
diff --git 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 << "] ";
          }

diff --git 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"
@@ -20,12 +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;
 
+	  if (templateIsTest)
+         ParameterizedManager::getInstance().beginExecute(&details);
+
 #ifdef UNITTEST_NO_EXCEPTIONS
       if (UNITTEST_SET_ASSERT_JUMP_TARGET() == 0)
       {
@@ -54,6 +59,8 @@ namespace UnitTest {
 #ifdef UNITTEST_NO_EXCEPTIONS
    }
 #endif
+	  if (templateIsTest)
+         ParameterizedManager::getInstance().endExecute(&details);
    }
 
 }

diff --git a/UnitTest++/ParameterizedMacros.h b/UnitTest++/ParameterizedMacros.h
@@ -0,0 +1,43 @@
+#ifndef UNITTEST_PARAMETERIZEDMACROS_H
+#define UNITTEST_PARAMETERIZEDMACROS_H
+
+#include "TestParameter.h"
+
+
+#define UNITTEST_SET_TEST_PARAMETER_LISTENER(Type, Name, ListenerPtr, SetUpBody) \
+	class ParameterizedCreator##Name \
+	{ \
+	public: \
+		ParameterizedCreator##Name() : globalInstance(getGlobalInstance()) {} \
+		UnitTest::TestParameter<Type> & globalInstance; \
+	private: \
+		static UnitTest::TestParameter<Type> & getGlobalInstance() \
+		{ \
+			static UnitTest::TestParameter<Type> instance(#Name, create(), ListenerPtr); \
+			return instance; \
+		} \
+		static vector<Type> create() { vector<Type> values; SetUpBody return values; } \
+	} static parameterizedCreator##Name##Instance; \
+	\
+	static UnitTest::TestParameter<Type> & Name(parameterizedCreator##Name##Instance.globalInstance)
+
+
+#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