Changeset 936Tweet

Timestamp:

Sep 9, 2011, 4:39:00 PM (11 years ago)

Author:

sam

Message:

lolunit: protect against multiple registration of the same fixture type.

File:

• trunk/src/lol/unit.h (modified) (14 diffs)

trunk/src/lol/unit.h

@@ -45 +45 @@
     virtual ~FixtureBase() {}
 
-    /* The FixtureBase class keeps track of all instanciated children
-     * fixtures through this method. */
-    static FixtureBase *GetOrSetTest(FixtureBase *set = NULL)
-    {
-        static FixtureBase *head = NULL, *tail = NULL;
-        if (set)
-        {
-            if (!head)
-                head = set;
-            if (tail)
-                tail->m_next = set;
-            tail = set;
-        }
-        return head;
-    }
-
-    virtual void runFixture() = 0;
+    static void AddFixture(FixtureBase *fixture)
+    {
+        /* Protect against several instances of the same Fixture subclass */
+        if (fixture->MarkFixture())
+            return;
+        FixtureListHelper(fixture);
+    }
+    static FixtureBase *FixtureList() { return FixtureListHelper(NULL); }
+
+    virtual void RunFixture() = 0;
+    virtual bool MarkFixture() = 0;
 
     /* Prevent compiler complaints about unreachable code */
@@ -71 +65 @@
     char const *m_fixturename, *m_currentname;
     std::stringstream m_errorlog, m_context;
+
+private:
+    /* The FixtureBase class keeps track of all instanciated children
+     * fixtures through this method. */
+    static FixtureBase *FixtureListHelper(FixtureBase *set)
+    {
+        static FixtureBase *head = NULL, *tail = NULL;
+
+        if (set)
+        {
+            if (!head) head = set;
+            if (tail) tail->m_next = set;
+            tail = set;
+        }
+        return head;
+    }
 };
-
-#define LOLUNIT_FIXTURE(FixtureName) \
-    class FixtureName; \
-    template<typename T> struct Make##FixtureName \
-    { \
-        Make##FixtureName() { p = new T(); } \
-        ~Make##FixtureName() { delete p; } \
-        T *p; \
-    }; \
-    Make##FixtureName<FixtureName> lol_unit_fixture_##FixtureName; \
-    static char const *LolUnitFixtureName(FixtureName *p) \
-    { \
-        (void)p; \
-        return #FixtureName; \
-    } \
-    class FixtureName : public lol::Fixture<FixtureName>
 
 /*
@@ -98 +92 @@
     typedef T FixtureClass;
 
-    class TestCase
-    {
-    public:
+    struct TestCase
+    {
         void (FixtureClass::* m_fun)();
         char const *m_testname;
         TestCase *m_next;
-
-        static void AddTestCase(TestCase *that, char const *name,
-                                void (FixtureClass::*fun)())
-        {
-            that->m_fun = fun;
-            that->m_testname = name;
-            that->m_next = NULL;
-            GetOrSetTestCase(that);
-        }
     };
 
     Fixture<T>()
     {
-        GetOrSetTest(this);
+        AddFixture(this);
     }
 
     /* Run all test cases in this fixture. */
-    virtual void runFixture()
+    virtual void RunFixture()
     {
         m_errorlog.str("");
         m_testcases = 0;
         m_failcases = 0;
-        for (TestCase *c = GetOrSetTestCase(); c; c = c->m_next)
+        for (TestCase *c = TestCaseList(); c; c = c->m_next)
         {
             m_testcases++;
@@ -140 +124 @@
     }
 
+    /* Mark the current fixture type as already registered and return whether
+     * it was seen before. */
+    virtual bool MarkFixture()
+    {
+        static bool seen = false;
+        if (seen)
+        {
+            SealFixture();
+            return true;
+        }
+        seen = true;
+        return false;
+    }
+
+    /* Manage Fixture sealing. Once SealFixture() has been called, we
+     * will no longer accept TestCase registrations. */
+    static void SealFixture() { SealFixtureHelper(true); }
+    static bool IsFixtureSealed() { return SealFixtureHelper(false); }
+
     /* Each Fixture class specialisation keeps track of its instanciated
-     * test cases through this method. */
-    static TestCase *GetOrSetTestCase(TestCase *set = NULL)
+     * test cases. */
+    static void AddTestCase(TestCase *that, char const *name,
+                            void (FixtureClass::*fun)())
+    {
+        if (IsFixtureSealed())
+            return;
+
+        that->m_fun = fun;
+        that->m_testname = name;
+        that->m_next = NULL;
+        TestCaseListHelper(that);
+    }
+    static TestCase *TestCaseList() { return TestCaseListHelper(NULL); }
+
+private:
+    static bool SealFixtureHelper(bool set)
+    {
+        static bool sealed = false;
+        if (set) sealed = true;
+        return sealed;
+    }
+
+    static TestCase *TestCaseListHelper(TestCase *set)
     {
         static TestCase *head = NULL, *tail = NULL;
@@ -154 +178 @@
     }
 };
-
-#define LOLUNIT_TEST(TestCaseName) \
-    class TestCase##TestCaseName : public TestCase \
-    { \
-    public: \
-        TestCase##TestCaseName() \
-        { \
-            AddTestCase(this, #TestCaseName, \
-                    (void (FixtureClass::*)()) &FixtureClass::TestCaseName); \
-        } \
-    }; \
-    TestCase##TestCaseName lol_unit_test_case_##TestCaseName; \
-    void TestCaseName()
 
 /*
@@ -181 +192 @@
         int failcases = 0, testcases = 0;
 
-        for (FixtureBase *f = FixtureBase::GetOrSetTest(); f; f = f->m_next)
+        for (FixtureBase *f = FixtureBase::FixtureList(); f; f = f->m_next)
         {
             f->setUp();
-            f->runFixture();
+            f->RunFixture();
             f->tearDown();
 
@@ -222 +233 @@
             m_errorlog << std::endl << std::endl; \
             m_errorlog << ++m_failcases << ") test: " \
-                       << LolUnitFixtureName(this) << "::" << m_currentname \
+                       << lol_unit_helper_name(this) << "::" << m_currentname \
                        << " (F) line: " << __LINE__ << " " \
                        << __FILE__ << std::endl; \
@@ -231 +242 @@
             return; \
         } \
-    } while(!True())
+    } while (!True())
 
 #define LOLUNIT_ASSERT_OP(op, modifier, opdesc, msg, a, b) \
@@ -240 +251 @@
             m_errorlog << std::endl << std::endl; \
             m_errorlog << ++m_failcases << ") test: " \
-                       << LolUnitFixtureName(this) << "::" << m_currentname \
+                       << lol_unit_helper_name(this) << "::" << m_currentname \
                        << " (F) line: " << __LINE__ << " " \
                        << __FILE__ << std::endl; \
@@ -251 +262 @@
             return; \
         } \
-    } while(!True())
+    } while (!True())
 
 #define LOLUNIT_MSG(msg) \
@@ -263 +274 @@
             m_errorlog << std::endl << std::endl; \
             m_errorlog << ++m_failcases << ") test: " \
-                       << LolUnitFixtureName(this) << "::" << m_currentname \
+                       << lol_unit_helper_name(this) << "::" << m_currentname \
                        << " (F) line: " << __LINE__ << " " \
                        << __FILE__ << std::endl; \
@@ -278 +289 @@
             return; \
         } \
-    } while(!True())
+    } while (!True())
+
+/*
+ * Public helper macros
+ */
+
+#define LOLUNIT_FIXTURE(N) \
+    class N; \
+    /* This pattern allows us to statically create a Fixture instance \
+     * before its exact implementation was defined. */ \
+    template<typename T> struct lol_unit_helper_fixture_##N \
+    { \
+        lol_unit_helper_fixture_##N() { p = new T(); } \
+        ~lol_unit_helper_fixture_##N() { delete p; } \
+        T *p; \
+    }; \
+    lol_unit_helper_fixture_##N<N> lol_unit_helper_fixture_##N##_instance; \
+    /* Allow to retrieve the class name without using RTTI and without \
+     * knowing the type of "this". */ \
+    static inline char const *lol_unit_helper_name(N *p) \
+    { \
+        (void)p; \
+        return #N; \
+    } \
+    /* Now the user can define the implementation */ \
+    class N : public lol::Fixture<N>
+
+#define LOLUNIT_TEST(N) \
+    /* For each test in the fixture, we create an object that will \
+     * automatically register the test method in a list global to the \
+     * specialised fixture. */ \
+    class lol_unit_helper_test_##N : public TestCase \
+    { \
+    public: \
+        lol_unit_helper_test_##N() \
+        { \
+            AddTestCase(this, #N, \
+                        (void (FixtureClass::*)()) &FixtureClass::N); \
+        } \
+    }; \
+    lol_unit_helper_test_##N lol_unit_helper_test_instance_##N; \
+    void N()
+
+/*
+ * Provide context for error messages
+ */
+
+#define LOLUNIT_SET_CONTEXT(n) \
+    do { \
+        m_context.str(""); \
+        m_context << "- Context : " << #n << " = " << (n) << std::endl; \
+    } while (!True())
+
+#define LOLUNIT_UNSET_CONTEXT(n) \
+    m_context.str("")
 
 /*
@@ -289 +354 @@
         m_errorlog << std::endl << std::endl; \
         m_errorlog << ++m_failcases << ") test: " \
-                   << LolUnitFixtureName(this) << "::" << m_currentname \
+                   << lol_unit_helper_name(this) << "::" << m_currentname \
                    << " (F) line: " << __LINE__ << " " \
                    << __FILE__ << std::endl; \
@@ -297 +362 @@
         m_failure = true; \
         return; \
-    } while(!True())
-
-#define LOLUNIT_SET_CONTEXT(n) \
-    do { \
-        m_context.str(""); \
-        m_context << "- Context : " << #n << " = " << (n) << std::endl; \
-    } while(!True())
-
-#define LOLUNIT_UNSET_CONTEXT(n) \
-    m_context.str("")
+    } while (!True())
 
 #define LOLUNIT_ASSERT(cond) \