Fixed problems with fixtures, where the setup and tear down was not matching across .cpp unit tests for issue #21.

Author: colinrg

test/TestClass.hpp

@@ -29,7 +29,7 @@ limitations under the License.
 #include "TestStdioFileFunctor.hpp"
 #include "TestMemoryLeakCheck.hpp"
 #include "TestMemoryCounter.hpp"
-#include "TestSetupTeardownFunctor.hpp"
+#include "TestSetupTeardown.hpp"
 
 #include <cstring>
 #include <climits>
@@ -73,6 +73,8 @@ class TestClass
         , m_test_number(0)
         , m_logged(false)
     {
+        GetSharedData().SetClassName(class_name);
+
         // Ensure that the next constructor can complete
         // the snapshot memory leak checking.
         TestClass*& prev_test = GetPreviousTest();
@@ -189,58 +191,50 @@ class TestClass
         return str;
     }
 
-private:
-    // Setup and tear down functionality, called via Execute function.
-    template<bool const is_setup>
-    void SetupTeardown()
-    {
-        TestSetupTeardownFunctor*& setup_or_teardown = GetSetupOrTeardown<is_setup>();
-
-        if (setup_or_teardown != NULL)
-        {
-            setup_or_teardown->Execute();
-            setup_or_teardown = NULL;
-        }
-    }
-
-    // Setting the setup and tear down functions, which get called later.
-    // See TEST_SETUP and TEST_TEARDOWN macros for usage.
-    template<bool const is_setup>
-    static void SetSetupTeardown(TestSetupTeardownFunctor& setup_teardown_functor)
-    {
-        TestSetupTeardownFunctor*& setup_or_teardown = GetSetupOrTeardown<is_setup>();
-
-        TestString class_name;
-        if (setup_or_teardown != NULL)
-            class_name.Assign(setup_or_teardown->GetClassName());
-
-        // If setup_or_teardown is null or class name has changed then set the functor.
-        if (class_name != setup_teardown_functor.GetClassName())
-            setup_or_teardown = &setup_teardown_functor;
-    }
-
 // Call the user defined setup and tear down functions via TestClass::Execute.
 public:
     void Setup()
     {
-        SetupTeardown<true>();
+        TestSetupTeardown& setup_teardown = privateSetupTeardown();
+        if (setup_teardown.IsSetupSet())
+            setup_teardown.Execute<true>();
     }
 
     void Teardown()
     {
-        SetupTeardown<false>();
+        TestSetupTeardown& setup_teardown = privateSetupTeardown();
+        if (setup_teardown.IsTeardownSet() && setup_teardown.IsSetupRun())
+            setup_teardown.Execute<false>();
     }
 
 // Set the appropriate class objects via using the TEST_SETUP and TEST_TEARDOWN macros.
 public:
     static void SetSetup(TestSetupTeardownFunctor& setup_functor)
     {
-        SetSetupTeardown<true>(setup_functor);
+        TestSetupTeardown& setup_teardown = privateSetupTeardown();
+
+        if (setup_teardown.IsSetupRun() &&
+            (setup_teardown.GetSetupClassName() != setup_functor.GetClassName()))
+        {
+            // If tear down execute is not run before setting new setup functor,
+            // Then the class has changed and we need to complete the previous
+            // tear down before starting a new class fixture.
+            setup_teardown.Execute<false>();
+        }
+
+        setup_teardown.SetSetupFunctor(setup_functor);
     }
 
     static void SetTeardown(TestSetupTeardownFunctor& teardown_functor)
     {
-        SetSetupTeardown<false>(teardown_functor);
+        TestSetupTeardown& setup_teardown = privateSetupTeardown();
+        setup_teardown.SetTeardownFunctor(teardown_functor);
+    }
+
+    static void ClearSetupTeardown()
+    {
+        TestSetupTeardown& setup_teardown = privateSetupTeardown();
+        setup_teardown.Clear();
     }
 
 // General helper functions.
@@ -1009,24 +1003,12 @@ class TestClass
         return prev_test;
     }
 
-    static TestSetupTeardownFunctor*& GetSetup()
+    static TestSetupTeardown& privateSetupTeardown()
     {
-        static TestSetupTeardownFunctor* setup_functor;
-        return setup_functor;
+        static TestSetupTeardown setup_teardown;
+        return setup_teardown;
     }
-
-    static TestSetupTeardownFunctor*& GetTeardown()
-    {
-        static TestSetupTeardownFunctor* teardown_functor;
-        return teardown_functor;
-    }
-
-    template<bool const is_setup>
-    static TestSetupTeardownFunctor*& GetSetupOrTeardown()
-    {
-        return is_setup ? GetSetup() : GetTeardown();
-    }
-
+    
 // Data for this test.
 private:
     TestMemoryLeakCheck m_leak_check;

test/TestClassSharedData.hpp

@@ -18,6 +18,7 @@ limitations under the License.
 #define OCL_GUARD_TEST_TESTCLASSSHAREDDATA_HPP
 
 #include "StdioTestLog.hpp"
+#include "TestString.hpp"
 #include <cstddef>
 
 namespace ocl
@@ -224,6 +225,21 @@ class TestClassSharedData
         m_total_tests = total_tests;
     }
 
+    char const* GetClassName() const throw()
+    {
+        return m_class_name;
+    }
+
+    void SetClassName(char const* class_name) throw()
+    {
+        m_class_name = class_name;
+    }
+
+    bool IsClassNameSame(char const* class_name) const
+    {
+        return TestString(m_class_name) == class_name;
+    }
+
     void IncTotalTests()
     {
         ++m_total_tests;
@@ -276,6 +292,9 @@ class TestClassSharedData
     SizeType m_total_timed_functions;
     SizeType m_total_tests;
 
+    // Last class name set for TestClass.
+    char const* m_class_name;
+
     // message for start of each test.
     const char* m_success_message;
     const char* m_failed_message;

test/TestMacros.hpp

@@ -39,10 +39,10 @@ TEST_MEMBER_FUNCTION(MyString, SetSize, size_t)
 #include "TestSetupTeardownFunctor.hpp"
 
 #define TEST_SETUP_TEARDOWN(Type, is_setup, class_name) \
-    class TestSetupTeardownFunctor_##Type_##class_name : public ocl::TestSetupTeardownFunctor \
+    class TestSetupTeardownFunctor_##Type##_##class_name : public ocl::TestSetupTeardownFunctor \
     { \
         public: \
-        TestSetupTeardownFunctor_##Type_##class_name(char const* name = #class_name) : \
+        TestSetupTeardownFunctor_##Type##_##class_name(char const* name = #class_name) : \
             ocl::TestSetupTeardownFunctor(name, is_setup) \
         { \
             if (IsSetup()) \
@@ -51,12 +51,12 @@ TEST_MEMBER_FUNCTION(MyString, SetSize, size_t)
                 ocl::TestClass::SetTeardown(*this); \
         } \
         void Execute(); \
-    } TestSetupTeardownFunctor_##Type_##class_name##_instance; \
-    void TestSetupTeardownFunctor_##Type_##class_name::Execute()
+    } TestSetupTeardownFunctor_##Type##_##class_name##_instance; \
+    void TestSetupTeardownFunctor_##Type##_##class_name::Execute()
 
-#define TEST_SETUP(class_name) TEST_SETUP_TEARDOWN(class_name, true, Setup)
+#define TEST_SETUP(class_name) TEST_SETUP_TEARDOWN(Setup, true, class_name)
 
-#define TEST_TEARDOWN(class_name)  TEST_SETUP_TEARDOWN(class_name, false, Teardown)
+#define TEST_TEARDOWN(class_name)  TEST_SETUP_TEARDOWN(Teardown, false, class_name)
 
 #ifndef TEST
 #define TEST(name) \

test/TestSetupTeardown.hpp

@@ -0,0 +1,134 @@
+/*
+Copyright 2016 Colin Girling
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#ifndef OCL_GUARD_TEST_TESTSETUPTEARDOWN_HPP
+#define OCL_GUARD_TEST_TESTSETUPTEARDOWN_HPP
+
+#include "TestSetupTeardownFunctor.hpp"
+#include "TestString.hpp"
+#include <cstddef>
+
+namespace ocl
+{
+
+class TestSetupTeardown
+{
+public:
+    TestSetupTeardown()
+        : m_setup_functor(NULL)
+        , m_teardown_functor(NULL)
+        , m_setup_run(false)
+    {
+    }
+
+    bool IsSetupSet() const throw()
+    {
+        return m_setup_functor != NULL;
+    }
+
+    bool IsTeardownSet() const throw()
+    {
+        return m_teardown_functor != NULL;
+    }
+
+    bool IsSetupTeardownSet() const throw()
+    {
+        return (m_setup_functor != NULL) && (m_teardown_functor != NULL);
+    }
+
+    bool IsSetupRun() const throw()
+    {
+        return m_setup_run;
+    }
+
+    TestString GetSetupClassName() const
+    {
+        TestString class_name(m_setup_functor != NULL ?
+                              m_setup_functor->GetClassName() : "");
+        return class_name;
+    }
+
+    TestString GetTeardownClassName() const
+    {
+        TestString class_name(m_teardown_functor != NULL ?
+                              m_teardown_functor->GetClassName() : "");
+        return class_name;
+    }
+
+    template<bool const is_setup>
+    char const* GetClassName() const throw()
+    {
+        return is_setup ? GetSetupClassName() : GetTeardownClassName();
+    }
+
+    TestSetupTeardownFunctor* GetSetupFunctor()
+    {
+        return m_setup_functor;
+    }
+
+    void SetSetupFunctor(TestSetupTeardownFunctor& setup_functor)
+    {
+        m_setup_functor = &setup_functor;
+    }
+
+    TestSetupTeardownFunctor* GetTeardownFunctor()
+    {
+        return m_teardown_functor;
+    }
+
+    void SetTeardownFunctor(TestSetupTeardownFunctor& teardown_functor)
+    {
+        m_teardown_functor = &teardown_functor;
+    }
+
+    template<bool const is_setup>
+    TestSetupTeardownFunctor* GetSetupTeardownFunctor()
+    {
+        return is_setup ? GetSetupFunctor() : GetTeardownFunctor();
+    }
+
+    template<bool const is_setup>
+    TestSetupTeardownFunctor*& SetupOrTeardownFunctor()
+    {
+        return is_setup ? m_setup_functor : m_teardown_functor;
+    }
+
+    template<bool const is_setup>
+    void Execute()
+    {
+        TestSetupTeardownFunctor* functor = SetupOrTeardownFunctor<is_setup>();
+        if (functor != NULL)
+        {
+            m_setup_run = is_setup;
+            functor->Execute();
+        }
+    }
+
+    void Clear()
+    {
+        m_setup_functor = NULL;
+        m_teardown_functor = NULL;
+    }
+
+private:
+    TestSetupTeardownFunctor* m_setup_functor;
+    TestSetupTeardownFunctor* m_teardown_functor;
+    bool m_setup_run;
+};
+
+}
+
+#endif // OCL_GUARD_TEST_TESTSETUPTEARDOWN_HPP

test/TestString.hpp

@@ -44,7 +44,7 @@ class TestString
         : m_length(size_type_default)
         , m_string(NULL)
     {
-        if (str != NULL)
+        if ((str != NULL) && (*str != '\0'))
             TestStringUtility::UnsafeAllocateCopy(m_string, m_length, str);
     }
 
@@ -132,14 +132,18 @@ class TestString
     {
         if (m_string == NULL)
             return (str == NULL) || (*str == '\0');
-        return ::strcmp(m_string, str) == 0;
+        if (str != NULL)
+            return ::strcmp(m_string, str) == 0;
+        return false;
     }
 
     bool operator ==(TestString const& str) const
     {
         if (m_string == NULL)
-            return str.m_string == NULL;
-        return ::strcmp(m_string, str.Ptr()) == 0;
+            return (str.m_string == NULL) || (*str.m_string == '\0');
+        if (str.m_string != NULL)
+            return ::strcmp(m_string, str.Ptr()) == 0;
+        return false;
     }
 
     bool operator !=(char const* str) const

test/unit_tests/ide/VS2015/test_unit_tests/test_unit_tests.sln

@@ -25,6 +25,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		..\..\..\..\TestMemoryUtility.hpp = ..\..\..\..\TestMemoryUtility.hpp
 		..\..\..\..\TestMinMax.hpp = ..\..\..\..\TestMinMax.hpp
 		..\..\..\..\TestNumericUtility.hpp = ..\..\..\..\TestNumericUtility.hpp
+		..\..\..\..\TestSetupTeardown.hpp = ..\..\..\..\TestSetupTeardown.hpp
 		..\..\..\..\TestSetupTeardownFunctor.hpp = ..\..\..\..\TestSetupTeardownFunctor.hpp
 		..\..\..\..\TestStdioFileFunctor.hpp = ..\..\..\..\TestStdioFileFunctor.hpp
 		..\..\..\..\TestString.hpp = ..\..\..\..\TestString.hpp