Index: code/branches/core6/test/core/class/OrxonoxClassTest.cc
===================================================================
--- code/branches/core6/test/core/class/OrxonoxClassTest.cc	(revision 9648)
+++ code/branches/core6/test/core/class/OrxonoxClassTest.cc	(revision 9649)
@@ -1,4 +1,5 @@
 #include <gtest/gtest.h>
 #include "core/class/OrxonoxClass.h"
+#include "core/object/Context.h"
 
 namespace orxonox
@@ -9,7 +10,22 @@
         {
         };
+
+        // Fixture
+        class OrxonoxClassTest : public ::testing::Test
+        {
+            public:
+                virtual void SetUp()
+                {
+                    Context::setRootContext(new Context(NULL));
+                }
+
+                virtual void TearDown()
+                {
+                    Context::setRootContext(NULL);
+                }
+        };
     }
 
-    TEST(OrxonoxClassTest, CanCreate)
+    TEST_F(OrxonoxClassTest, CanCreate)
     {
         TestClass* test = new TestClass();
Index: code/branches/core6/test/core/class/OrxonoxInterfaceTest.cc
===================================================================
--- code/branches/core6/test/core/class/OrxonoxInterfaceTest.cc	(revision 9648)
+++ code/branches/core6/test/core/class/OrxonoxInterfaceTest.cc	(revision 9649)
@@ -2,4 +2,5 @@
 #include "core/class/OrxonoxInterface.h"
 #include "core/class/OrxonoxClass.h"
+#include "core/object/Context.h"
 
 namespace orxonox
@@ -24,7 +25,22 @@
         {
         };
+
+        // Fixture
+        class OrxonoxInterfaceTest : public ::testing::Test
+        {
+            public:
+                virtual void SetUp()
+                {
+                    Context::setRootContext(new Context(NULL));
+                }
+
+                virtual void TearDown()
+                {
+                    Context::setRootContext(NULL);
+                }
+        };
     }
 
-    TEST(OrxonoxInterfaceTest, CanCreate1)
+    TEST_F(OrxonoxInterfaceTest, CanCreate1)
     {
         TestClass1* test = new TestClass1();
@@ -33,5 +49,5 @@
     }
 
-    TEST(OrxonoxInterfaceTest, CanCreate2)
+    TEST_F(OrxonoxInterfaceTest, CanCreate2)
     {
         TestClass2* test = new TestClass2();
Index: code/branches/core6/test/core/class/SubclassIdentifierTest.cc
===================================================================
--- code/branches/core6/test/core/class/SubclassIdentifierTest.cc	(revision 9648)
+++ code/branches/core6/test/core/class/SubclassIdentifierTest.cc	(revision 9649)
@@ -32,8 +32,12 @@
 
                     IdentifierManager::getInstance().createClassHierarchy();
+
+                    Context::setRootContext(new Context(NULL));
                 }
 
                 virtual void TearDown()
                 {
+                    Context::setRootContext(NULL);
+
                     IdentifierManager::getInstance().destroyAllIdentifiers();
                 }
Index: code/branches/core6/test/core/class/SuperTest.cc
===================================================================
--- code/branches/core6/test/core/class/SuperTest.cc	(revision 9648)
+++ code/branches/core6/test/core/class/SuperTest.cc	(revision 9649)
@@ -62,5 +62,5 @@
         };
 
-        // Fixture
+       // Fixture
         class SuperTest : public ::testing::Test
         {
@@ -76,8 +76,12 @@
 
                     IdentifierManager::getInstance().createClassHierarchy();
+
+                    Context::setRootContext(new Context(NULL));
                 }
 
                 virtual void TearDown()
                 {
+                    Context::setRootContext(NULL);
+
                     IdentifierManager::getInstance().destroyAllIdentifiers();
                 }
Index: code/branches/core6/test/core/object/ClassFactoryTest.cc
===================================================================
--- code/branches/core6/test/core/object/ClassFactoryTest.cc	(revision 9648)
+++ code/branches/core6/test/core/object/ClassFactoryTest.cc	(revision 9649)
@@ -2,8 +2,27 @@
 #include "core/object/ClassFactory.h"
 #include "core/BaseObject.h"
+#include "core/object/Context.h"
 
 namespace orxonox
 {
-    TEST(ClassFactoryTest, CanFabricateObject)
+    namespace
+    {
+        // Fixture
+        class ClassFactoryTest : public ::testing::Test
+        {
+            public:
+                virtual void SetUp()
+                {
+                    Context::setRootContext(new Context(NULL));
+                }
+
+                virtual void TearDown()
+                {
+                    Context::setRootContext(NULL);
+                }
+        };
+    }
+
+    TEST_F(ClassFactoryTest, CanFabricateObject)
     {
         Factory* factory = new ClassFactoryWithContext<BaseObject>();
Index: code/branches/core6/test/core/object/ContextTest.cc
===================================================================
--- code/branches/core6/test/core/object/ContextTest.cc	(revision 9648)
+++ code/branches/core6/test/core/object/ContextTest.cc	(revision 9649)
@@ -13,17 +13,32 @@
                 SubclassContext() : Context(NULL) { RegisterRootObject(SubclassContext); }
         };
+
+        // Fixture
+        class ContextTest : public ::testing::Test
+        {
+            public:
+                virtual void SetUp()
+                {
+                    Context::setRootContext(new Context(NULL));
+                }
+
+                virtual void TearDown()
+                {
+                    Context::setRootContext(NULL);
+                }
+        };
     }
 
-    TEST(ContextTest, CanCreateContext)
+    TEST_F(ContextTest, CanCreateContext)
     {
         Context context(NULL);
     }
 
-    TEST(ContextTest, CanCreateSubclassContext)
+    TEST_F(ContextTest, CanCreateSubclassContext)
     {
         SubclassContext context;
     }
 
-    TEST(ContextTest, ContextIsItsOwnContext)
+    TEST_F(ContextTest, ContextIsItsOwnContext)
     {
         Context context(NULL);
@@ -31,5 +46,5 @@
     }
 
-    TEST(ContextTest, SubclassContextIsItsOwnContext)
+    TEST_F(ContextTest, SubclassContextIsItsOwnContext)
     {
         SubclassContext context;
@@ -37,5 +52,5 @@
     }
 
-    TEST(ContextTest, SubclassAddsToItsOwnObjectList)
+    TEST_F(ContextTest, SubclassAddsToItsOwnObjectList)
     {
         SubclassContext context;
Index: code/branches/core6/test/core/object/IteratorTest.cc
===================================================================
--- code/branches/core6/test/core/object/IteratorTest.cc	(revision 9648)
+++ code/branches/core6/test/core/object/IteratorTest.cc	(revision 9649)
@@ -23,17 +23,32 @@
                 MOCK_METHOD0(test, void());
         };
+
+        // Fixture
+        class IteratorTest : public ::testing::Test
+        {
+            public:
+                virtual void SetUp()
+                {
+                    Context::setRootContext(new Context(NULL));
+                }
+
+                virtual void TearDown()
+                {
+                    Context::setRootContext(NULL);
+                }
+        };
     }
 
-    TEST(IteratorTest, CanCreateIterator)
+    TEST_F(IteratorTest, CanCreateIterator)
     {
         Iterator<TestInterface> it;
     }
 
-    TEST(IteratorTest, CanAssignIterator)
+    TEST_F(IteratorTest, CanAssignIterator)
     {
         Iterator<TestInterface> it = ObjectList<TestInterface>::begin();
     }
 
-    TEST(IteratorTest, CanIterateOverEmptyList)
+    TEST_F(IteratorTest, CanIterateOverEmptyList)
     {
         size_t i = 0;
@@ -43,5 +58,5 @@
     }
 
-    TEST(IteratorTest, CanCallObjects)
+    TEST_F(IteratorTest, CanCallObjects)
     {
         TestClass test1;
Index: code/branches/core6/test/core/object/ListableTest.cc
===================================================================
--- code/branches/core6/test/core/object/ListableTest.cc	(revision 9648)
+++ code/branches/core6/test/core/object/ListableTest.cc	(revision 9649)
@@ -7,11 +7,11 @@
     namespace
     {
-        class ListableTest : public Listable
+        class ListableClassTest : public Listable
         {
             public:
-                ListableTest() { RegisterRootObject(ListableTest); }
+            ListableClassTest() { RegisterRootObject(ListableClassTest); }
         };
 
-        class ListableSubclassTest : public ListableTest
+        class ListableSubclassTest : public ListableClassTest
         {
             public:
@@ -28,56 +28,71 @@
             return false;
         }
-    }
-
-    TEST(ListableTest, CanCreate)
-    {
-        ListableTest* test = new ListableTest();
+
+        // Fixture
+        class ListableTest : public ::testing::Test
+        {
+            public:
+                virtual void SetUp()
+                {
+                    Context::setRootContext(new Context(NULL));
+                }
+
+                virtual void TearDown()
+                {
+                    Context::setRootContext(NULL);
+                }
+        };
+    }
+
+    TEST_F(ListableTest, CanCreate)
+    {
+        ListableClassTest* test = new ListableClassTest();
         ASSERT_TRUE(test != NULL);
         delete test;
     }
 
-    TEST(ListableTest, AddsToObjectList)
-    {
-        ListableTest test;
-        EXPECT_EQ(1u, ObjectList<ListableTest>::size());
-        EXPECT_TRUE(objectListContains<ListableTest>(&test));
-    }
-
-    TEST(ListableTest, AddsToAllObjectLists)
-    {
-        ListableSubclassTest test;
-        EXPECT_EQ(1u, ObjectList<ListableTest>::size());
-        EXPECT_TRUE(objectListContains<ListableTest>(&test));
+    TEST_F(ListableTest, AddsToObjectList)
+    {
+        ListableClassTest test;
+        EXPECT_EQ(1u, ObjectList<ListableClassTest>::size());
+        EXPECT_TRUE(objectListContains<ListableClassTest>(&test));
+    }
+
+    TEST_F(ListableTest, AddsToAllObjectLists)
+    {
+        ListableSubclassTest test;
+        EXPECT_EQ(1u, ObjectList<ListableClassTest>::size());
+        EXPECT_TRUE(objectListContains<ListableClassTest>(&test));
         EXPECT_EQ(1u, ObjectList<ListableSubclassTest>::size());
         EXPECT_TRUE(objectListContains<ListableSubclassTest>(&test));
     }
 
-    TEST(ListableTest, RemovesFromObjectList)
-    {
-        EXPECT_EQ(0u, ObjectList<ListableTest>::size());
-        {
-            ListableTest test;
-            EXPECT_EQ(1u, ObjectList<ListableTest>::size());
-            EXPECT_TRUE(objectListContains<ListableTest>(&test));
+    TEST_F(ListableTest, RemovesFromObjectList)
+    {
+        EXPECT_EQ(0u, ObjectList<ListableClassTest>::size());
+        {
+            ListableClassTest test;
+            EXPECT_EQ(1u, ObjectList<ListableClassTest>::size());
+            EXPECT_TRUE(objectListContains<ListableClassTest>(&test));
         }
-        EXPECT_EQ(0u, ObjectList<ListableTest>::size());
-    }
-
-    TEST(ListableTest, RemovesFromAllObjectLists)
-    {
-        EXPECT_EQ(0u, ObjectList<ListableTest>::size());
+        EXPECT_EQ(0u, ObjectList<ListableClassTest>::size());
+    }
+
+    TEST_F(ListableTest, RemovesFromAllObjectLists)
+    {
+        EXPECT_EQ(0u, ObjectList<ListableClassTest>::size());
         EXPECT_EQ(0u, ObjectList<ListableSubclassTest>::size());
         {
             ListableSubclassTest test;
-            EXPECT_EQ(1u, ObjectList<ListableTest>::size());
-            EXPECT_TRUE(objectListContains<ListableTest>(&test));
+            EXPECT_EQ(1u, ObjectList<ListableClassTest>::size());
+            EXPECT_TRUE(objectListContains<ListableClassTest>(&test));
             EXPECT_EQ(1u, ObjectList<ListableSubclassTest>::size());
             EXPECT_TRUE(objectListContains<ListableSubclassTest>(&test));
         }
-        EXPECT_EQ(0u, ObjectList<ListableTest>::size());
+        EXPECT_EQ(0u, ObjectList<ListableClassTest>::size());
         EXPECT_EQ(0u, ObjectList<ListableSubclassTest>::size());
     }
 
-    TEST(ListableTest, CanAddObjectToContext)
+    TEST_F(ListableTest, CanAddObjectToContext)
     {
         Context context(NULL);
@@ -87,11 +102,11 @@
 
         // object is in new context
-        EXPECT_EQ(1u, context.getObjectList<ListableTest>()->size());
-        EXPECT_TRUE(objectListContains<ListableTest>(&test, &context));
+        EXPECT_EQ(1u, context.getObjectList<ListableClassTest>()->size());
+        EXPECT_TRUE(objectListContains<ListableClassTest>(&test, &context));
         EXPECT_EQ(1u, context.getObjectList<ListableSubclassTest>()->size());
         EXPECT_TRUE(objectListContains<ListableSubclassTest>(&test, &context));
     }
 
-    TEST(ListableTest, CanAddObjectToSubContext)
+    TEST_F(ListableTest, CanAddObjectToSubContext)
     {
         Context baseContext(NULL);
@@ -102,16 +117,16 @@
 
         // object is in both contexts
-        EXPECT_EQ(1u, baseContext.getObjectList<ListableTest>()->size());
-        EXPECT_TRUE(objectListContains<ListableTest>(&test, &baseContext));
+        EXPECT_EQ(1u, baseContext.getObjectList<ListableClassTest>()->size());
+        EXPECT_TRUE(objectListContains<ListableClassTest>(&test, &baseContext));
         EXPECT_EQ(1u, baseContext.getObjectList<ListableSubclassTest>()->size());
         EXPECT_TRUE(objectListContains<ListableSubclassTest>(&test, &baseContext));
 
-        EXPECT_EQ(1u, subContext.getObjectList<ListableTest>()->size());
-        EXPECT_TRUE(objectListContains<ListableTest>(&test, &subContext));
+        EXPECT_EQ(1u, subContext.getObjectList<ListableClassTest>()->size());
+        EXPECT_TRUE(objectListContains<ListableClassTest>(&test, &subContext));
         EXPECT_EQ(1u, subContext.getObjectList<ListableSubclassTest>()->size());
         EXPECT_TRUE(objectListContains<ListableSubclassTest>(&test, &subContext));
     }
 
-    TEST(ListableTest, CanChangeContext)
+    TEST_F(ListableTest, CanChangeContext)
     {
         Context* rootContext = Context::getRootContext();
@@ -120,12 +135,12 @@
 
         // object is in root context
-        EXPECT_EQ(1u, rootContext->getObjectList<ListableTest>()->size());
-        EXPECT_TRUE(objectListContains<ListableTest>(&test, rootContext));
+        EXPECT_EQ(1u, rootContext->getObjectList<ListableClassTest>()->size());
+        EXPECT_TRUE(objectListContains<ListableClassTest>(&test, rootContext));
         EXPECT_EQ(1u, rootContext->getObjectList<ListableSubclassTest>()->size());
         EXPECT_TRUE(objectListContains<ListableSubclassTest>(&test, rootContext));
 
         // object is NOT in new context
-        EXPECT_EQ(0u, newContext.getObjectList<ListableTest>()->size());
-        EXPECT_FALSE(objectListContains<ListableTest>(&test, &newContext));
+        EXPECT_EQ(0u, newContext.getObjectList<ListableClassTest>()->size());
+        EXPECT_FALSE(objectListContains<ListableClassTest>(&test, &newContext));
         EXPECT_EQ(0u, newContext.getObjectList<ListableSubclassTest>()->size());
         EXPECT_FALSE(objectListContains<ListableSubclassTest>(&test, &newContext));
@@ -134,17 +149,17 @@
 
         // object was removed from root context
-        EXPECT_EQ(0u, rootContext->getObjectList<ListableTest>()->size());
-        EXPECT_FALSE(objectListContains<ListableTest>(&test, rootContext));
+        EXPECT_EQ(0u, rootContext->getObjectList<ListableClassTest>()->size());
+        EXPECT_FALSE(objectListContains<ListableClassTest>(&test, rootContext));
         EXPECT_EQ(0u, rootContext->getObjectList<ListableSubclassTest>()->size());
         EXPECT_FALSE(objectListContains<ListableSubclassTest>(&test, rootContext));
 
         // object is now in new context
-        EXPECT_EQ(1u, newContext.getObjectList<ListableTest>()->size());
-        EXPECT_TRUE(objectListContains<ListableTest>(&test, &newContext));
+        EXPECT_EQ(1u, newContext.getObjectList<ListableClassTest>()->size());
+        EXPECT_TRUE(objectListContains<ListableClassTest>(&test, &newContext));
         EXPECT_EQ(1u, newContext.getObjectList<ListableSubclassTest>()->size());
         EXPECT_TRUE(objectListContains<ListableSubclassTest>(&test, &newContext));
     }
 
-    TEST(ListableTest, CanChangeToSubContext)
+    TEST_F(ListableTest, CanChangeToSubContext)
     {
         Context* rootContext = Context::getRootContext();
@@ -153,12 +168,12 @@
 
         // object is in root context
-        EXPECT_EQ(1u, rootContext->getObjectList<ListableTest>()->size());
-        EXPECT_TRUE(objectListContains<ListableTest>(&test, rootContext));
+        EXPECT_EQ(1u, rootContext->getObjectList<ListableClassTest>()->size());
+        EXPECT_TRUE(objectListContains<ListableClassTest>(&test, rootContext));
         EXPECT_EQ(1u, rootContext->getObjectList<ListableSubclassTest>()->size());
         EXPECT_TRUE(objectListContains<ListableSubclassTest>(&test, rootContext));
 
         // object is NOT in sub context
-        EXPECT_EQ(0u, subContext.getObjectList<ListableTest>()->size());
-        EXPECT_FALSE(objectListContains<ListableTest>(&test, &subContext));
+        EXPECT_EQ(0u, subContext.getObjectList<ListableClassTest>()->size());
+        EXPECT_FALSE(objectListContains<ListableClassTest>(&test, &subContext));
         EXPECT_EQ(0u, subContext.getObjectList<ListableSubclassTest>()->size());
         EXPECT_FALSE(objectListContains<ListableSubclassTest>(&test, &subContext));
@@ -167,17 +182,17 @@
 
         // object is still in root context
-        EXPECT_EQ(1u, rootContext->getObjectList<ListableTest>()->size());
-        EXPECT_TRUE(objectListContains<ListableTest>(&test, rootContext));
+        EXPECT_EQ(1u, rootContext->getObjectList<ListableClassTest>()->size());
+        EXPECT_TRUE(objectListContains<ListableClassTest>(&test, rootContext));
         EXPECT_EQ(1u, rootContext->getObjectList<ListableSubclassTest>()->size());
         EXPECT_TRUE(objectListContains<ListableSubclassTest>(&test, rootContext));
 
         // object is now also in sub context
-        EXPECT_EQ(1u, subContext.getObjectList<ListableTest>()->size());
-        EXPECT_TRUE(objectListContains<ListableTest>(&test, &subContext));
+        EXPECT_EQ(1u, subContext.getObjectList<ListableClassTest>()->size());
+        EXPECT_TRUE(objectListContains<ListableClassTest>(&test, &subContext));
         EXPECT_EQ(1u, subContext.getObjectList<ListableSubclassTest>()->size());
         EXPECT_TRUE(objectListContains<ListableSubclassTest>(&test, &subContext));
     }
 
-    TEST(ListableTest, CanChangeFromSubcontextToSubContext)
+    TEST_F(ListableTest, CanChangeFromSubcontextToSubContext)
     {
         Context* rootContext = Context::getRootContext();
@@ -189,18 +204,18 @@
 
         // object is in root context
-        EXPECT_EQ(1u, rootContext->getObjectList<ListableTest>()->size());
-        EXPECT_TRUE(objectListContains<ListableTest>(&test, rootContext));
+        EXPECT_EQ(1u, rootContext->getObjectList<ListableClassTest>()->size());
+        EXPECT_TRUE(objectListContains<ListableClassTest>(&test, rootContext));
         EXPECT_EQ(1u, rootContext->getObjectList<ListableSubclassTest>()->size());
         EXPECT_TRUE(objectListContains<ListableSubclassTest>(&test, rootContext));
 
         // object is also in sub context 1
-        EXPECT_EQ(1u, subContext1.getObjectList<ListableTest>()->size());
-        EXPECT_TRUE(objectListContains<ListableTest>(&test, &subContext1));
+        EXPECT_EQ(1u, subContext1.getObjectList<ListableClassTest>()->size());
+        EXPECT_TRUE(objectListContains<ListableClassTest>(&test, &subContext1));
         EXPECT_EQ(1u, subContext1.getObjectList<ListableSubclassTest>()->size());
         EXPECT_TRUE(objectListContains<ListableSubclassTest>(&test, &subContext1));
 
         // object is NOT in sub context 2
-        EXPECT_EQ(0u, subContext2.getObjectList<ListableTest>()->size());
-        EXPECT_FALSE(objectListContains<ListableTest>(&test, &subContext2));
+        EXPECT_EQ(0u, subContext2.getObjectList<ListableClassTest>()->size());
+        EXPECT_FALSE(objectListContains<ListableClassTest>(&test, &subContext2));
         EXPECT_EQ(0u, subContext2.getObjectList<ListableSubclassTest>()->size());
         EXPECT_FALSE(objectListContains<ListableSubclassTest>(&test, &subContext2));
@@ -209,18 +224,18 @@
 
         // object is still in root context
-        EXPECT_EQ(1u, rootContext->getObjectList<ListableTest>()->size());
-        EXPECT_TRUE(objectListContains<ListableTest>(&test, rootContext));
+        EXPECT_EQ(1u, rootContext->getObjectList<ListableClassTest>()->size());
+        EXPECT_TRUE(objectListContains<ListableClassTest>(&test, rootContext));
         EXPECT_EQ(1u, rootContext->getObjectList<ListableSubclassTest>()->size());
         EXPECT_TRUE(objectListContains<ListableSubclassTest>(&test, rootContext));
 
         // object was removed from sub context 1
-        EXPECT_EQ(0u, subContext1.getObjectList<ListableTest>()->size());
-        EXPECT_FALSE(objectListContains<ListableTest>(&test, &subContext1));
+        EXPECT_EQ(0u, subContext1.getObjectList<ListableClassTest>()->size());
+        EXPECT_FALSE(objectListContains<ListableClassTest>(&test, &subContext1));
         EXPECT_EQ(0u, subContext1.getObjectList<ListableSubclassTest>()->size());
         EXPECT_FALSE(objectListContains<ListableSubclassTest>(&test, &subContext1));
 
         // object is now in sub context 2
-        EXPECT_EQ(1u, subContext2.getObjectList<ListableTest>()->size());
-        EXPECT_TRUE(objectListContains<ListableTest>(&test, &subContext2));
+        EXPECT_EQ(1u, subContext2.getObjectList<ListableClassTest>()->size());
+        EXPECT_TRUE(objectListContains<ListableClassTest>(&test, &subContext2));
         EXPECT_EQ(1u, subContext2.getObjectList<ListableSubclassTest>()->size());
         EXPECT_TRUE(objectListContains<ListableSubclassTest>(&test, &subContext2));
Index: code/branches/core6/test/core/object/ObjectListIteratorTest.cc
===================================================================
--- code/branches/core6/test/core/object/ObjectListIteratorTest.cc	(revision 9648)
+++ code/branches/core6/test/core/object/ObjectListIteratorTest.cc	(revision 9649)
@@ -16,17 +16,32 @@
                 MOCK_METHOD0(test, void());
         };
+
+        // Fixture
+        class ObjectListIteratorTest : public ::testing::Test
+        {
+            public:
+                virtual void SetUp()
+                {
+                    Context::setRootContext(new Context(NULL));
+                }
+
+                virtual void TearDown()
+                {
+                    Context::setRootContext(NULL);
+                }
+        };
     }
 
-    TEST(ObjectListIteratorTest, CanCreateIterator)
+    TEST_F(ObjectListIteratorTest, CanCreateIterator)
     {
         ObjectListIterator<ListableTest> it;
     }
 
-    TEST(ObjectListIteratorTest, CanAssignIterator)
+    TEST_F(ObjectListIteratorTest, CanAssignIterator)
     {
         ObjectListIterator<ListableTest> it = ObjectList<ListableTest>::begin();
     }
 
-    TEST(ObjectListIteratorTest, CanIterateOverEmptyList)
+    TEST_F(ObjectListIteratorTest, CanIterateOverEmptyList)
     {
         size_t i = 0;
@@ -36,5 +51,5 @@
     }
 
-    TEST(ObjectListIteratorTest, CanIterateOverFullList)
+    TEST_F(ObjectListIteratorTest, CanIterateOverFullList)
     {
         ListableTest test1;
@@ -53,5 +68,5 @@
     }
 
-    TEST(ObjectListIteratorTest, CanIterateReverseOverFullList)
+    TEST_F(ObjectListIteratorTest, CanIterateReverseOverFullList)
     {
         ListableTest test1;
@@ -70,5 +85,5 @@
     }
 
-    TEST(ObjectListIteratorTest, CanCallObjects)
+    TEST_F(ObjectListIteratorTest, CanCallObjects)
     {
         ListableTest test1;
