[Orxonox-commit 4980] r9649 - in code/branches/core6: src/libraries/core src/libraries/core/object test/core/class test/core/object
landauf at orxonox.net
landauf at orxonox.net
Wed Aug 14 18:42:28 CEST 2013
Author: landauf
Date: 2013-08-14 18:42:28 +0200 (Wed, 14 Aug 2013)
New Revision: 9649
Modified:
code/branches/core6/src/libraries/core/Core.cc
code/branches/core6/src/libraries/core/object/Context.cc
code/branches/core6/src/libraries/core/object/Context.h
code/branches/core6/test/core/class/OrxonoxClassTest.cc
code/branches/core6/test/core/class/OrxonoxInterfaceTest.cc
code/branches/core6/test/core/class/SubclassIdentifierTest.cc
code/branches/core6/test/core/class/SuperTest.cc
code/branches/core6/test/core/object/ClassFactoryTest.cc
code/branches/core6/test/core/object/ContextTest.cc
code/branches/core6/test/core/object/IteratorTest.cc
code/branches/core6/test/core/object/ListableTest.cc
code/branches/core6/test/core/object/ObjectListIteratorTest.cc
Log:
added ability to set the root-context explicitly (and also to destroy it before the class-hierarchy is destroyed).
currently it's not possible to set the root context explicitly during startup of the game because it is already used by static initialization
Modified: code/branches/core6/src/libraries/core/Core.cc
===================================================================
--- code/branches/core6/src/libraries/core/Core.cc 2013-08-14 15:44:53 UTC (rev 9648)
+++ code/branches/core6/src/libraries/core/Core.cc 2013-08-14 16:42:28 UTC (rev 9649)
@@ -247,6 +247,7 @@
safeObjectDelete(&languageInstance_);
safeObjectDelete(&configFileManager_);
ConsoleCommand::destroyAll();
+ Context::setRootContext(NULL);
IdentifierManager::getInstance().destroyAllIdentifiers();
safeObjectDelete(&signalHandler_);
safeObjectDelete(&dynLibManager_);
Modified: code/branches/core6/src/libraries/core/object/Context.cc
===================================================================
--- code/branches/core6/src/libraries/core/object/Context.cc 2013-08-14 15:44:53 UTC (rev 9648)
+++ code/branches/core6/src/libraries/core/object/Context.cc 2013-08-14 16:42:28 UTC (rev 9649)
@@ -36,6 +36,8 @@
namespace orxonox
{
+ Context* Context::rootContext_s = 0;
+
Context::Context(Context* context) : Listable(this), parentContext_(context)
{
// we have to call Listable(this) to avoid circular initialization when creating a Context because Listable calls Context::getRootContext() by
@@ -53,10 +55,18 @@
delete this->objectLists_[i];
}
+ /*static*/ void Context::setRootContext(Context* context)
+ {
+ if (Context::rootContext_s)
+ delete Context::rootContext_s;
+ Context::rootContext_s = context;
+ }
+
/*static*/ Context* Context::getRootContext()
{
- static Context rootContext(NULL);
- return &rootContext;
+ if (!Context::rootContext_s)
+ Context::rootContext_s = new Context(NULL);
+ return Context::rootContext_s;
}
ObjectListBase* Context::getObjectList(const Identifier* identifier)
Modified: code/branches/core6/src/libraries/core/object/Context.h
===================================================================
--- code/branches/core6/src/libraries/core/object/Context.h 2013-08-14 15:44:53 UTC (rev 9648)
+++ code/branches/core6/src/libraries/core/object/Context.h 2013-08-14 16:42:28 UTC (rev 9649)
@@ -45,6 +45,7 @@
class _CoreExport Context : virtual public Listable
{
public:
+ static void setRootContext(Context* context);
static Context* getRootContext();
Context(Context* context);
@@ -71,6 +72,8 @@
private:
Context* parentContext_;
std::vector<ObjectListBase*> objectLists_;
+
+ static Context* rootContext_s;
};
}
Modified: code/branches/core6/test/core/class/OrxonoxClassTest.cc
===================================================================
--- code/branches/core6/test/core/class/OrxonoxClassTest.cc 2013-08-14 15:44:53 UTC (rev 9648)
+++ code/branches/core6/test/core/class/OrxonoxClassTest.cc 2013-08-14 16:42:28 UTC (rev 9649)
@@ -1,5 +1,6 @@
#include <gtest/gtest.h>
#include "core/class/OrxonoxClass.h"
+#include "core/object/Context.h"
namespace orxonox
{
@@ -8,9 +9,24 @@
class TestClass : public OrxonoxClass
{
};
+
+ // 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();
ASSERT_TRUE(test != NULL);
Modified: code/branches/core6/test/core/class/OrxonoxInterfaceTest.cc
===================================================================
--- code/branches/core6/test/core/class/OrxonoxInterfaceTest.cc 2013-08-14 15:44:53 UTC (rev 9648)
+++ code/branches/core6/test/core/class/OrxonoxInterfaceTest.cc 2013-08-14 16:42:28 UTC (rev 9649)
@@ -1,6 +1,7 @@
#include <gtest/gtest.h>
#include "core/class/OrxonoxInterface.h"
#include "core/class/OrxonoxClass.h"
+#include "core/object/Context.h"
namespace orxonox
{
@@ -23,16 +24,31 @@
class TestClass2 : public OrxonoxClass, public Interface1, public Interface2, public Interface3
{
};
+
+ // 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();
ASSERT_TRUE(test != NULL);
delete test;
}
- TEST(OrxonoxInterfaceTest, CanCreate2)
+ TEST_F(OrxonoxInterfaceTest, CanCreate2)
{
TestClass2* test = new TestClass2();
ASSERT_TRUE(test != NULL);
Modified: code/branches/core6/test/core/class/SubclassIdentifierTest.cc
===================================================================
--- code/branches/core6/test/core/class/SubclassIdentifierTest.cc 2013-08-14 15:44:53 UTC (rev 9648)
+++ code/branches/core6/test/core/class/SubclassIdentifierTest.cc 2013-08-14 16:42:28 UTC (rev 9649)
@@ -31,10 +31,14 @@
registerClass("TestSubclass", new ClassFactoryWithContext<TestSubclass>());
IdentifierManager::getInstance().createClassHierarchy();
+
+ Context::setRootContext(new Context(NULL));
}
virtual void TearDown()
{
+ Context::setRootContext(NULL);
+
IdentifierManager::getInstance().destroyAllIdentifiers();
}
};
Modified: code/branches/core6/test/core/class/SuperTest.cc
===================================================================
--- code/branches/core6/test/core/class/SuperTest.cc 2013-08-14 15:44:53 UTC (rev 9648)
+++ code/branches/core6/test/core/class/SuperTest.cc 2013-08-14 16:42:28 UTC (rev 9649)
@@ -61,7 +61,7 @@
XMLPort::Mode modeSubclass_;
};
- // Fixture
+ // Fixture
class SuperTest : public ::testing::Test
{
public:
@@ -75,10 +75,14 @@
registerClass("TestSubclass", new ClassFactoryWithContext<TestSubclass>());
IdentifierManager::getInstance().createClassHierarchy();
+
+ Context::setRootContext(new Context(NULL));
}
virtual void TearDown()
{
+ Context::setRootContext(NULL);
+
IdentifierManager::getInstance().destroyAllIdentifiers();
}
};
Modified: code/branches/core6/test/core/object/ClassFactoryTest.cc
===================================================================
--- code/branches/core6/test/core/object/ClassFactoryTest.cc 2013-08-14 15:44:53 UTC (rev 9648)
+++ code/branches/core6/test/core/object/ClassFactoryTest.cc 2013-08-14 16:42:28 UTC (rev 9649)
@@ -1,11 +1,30 @@
#include <gtest/gtest.h>
#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>();
Identifiable* object = factory->fabricate(NULL);
ASSERT_TRUE(object != NULL);
Modified: code/branches/core6/test/core/object/ContextTest.cc
===================================================================
--- code/branches/core6/test/core/object/ContextTest.cc 2013-08-14 15:44:53 UTC (rev 9648)
+++ code/branches/core6/test/core/object/ContextTest.cc 2013-08-14 16:42:28 UTC (rev 9649)
@@ -12,31 +12,46 @@
public:
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);
EXPECT_EQ(&context, context.getContext());
}
- TEST(ContextTest, SubclassContextIsItsOwnContext)
+ TEST_F(ContextTest, SubclassContextIsItsOwnContext)
{
SubclassContext context;
EXPECT_EQ(&context, context.getContext());
}
- TEST(ContextTest, SubclassAddsToItsOwnObjectList)
+ TEST_F(ContextTest, SubclassAddsToItsOwnObjectList)
{
SubclassContext context;
EXPECT_EQ(&context, context.getContext());
Modified: code/branches/core6/test/core/object/IteratorTest.cc
===================================================================
--- code/branches/core6/test/core/object/IteratorTest.cc 2013-08-14 15:44:53 UTC (rev 9648)
+++ code/branches/core6/test/core/object/IteratorTest.cc 2013-08-14 16:42:28 UTC (rev 9649)
@@ -22,19 +22,34 @@
TestClass() { RegisterRootObject(TestClass); }
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;
for (Iterator<TestInterface> it = ObjectList<TestInterface>::begin(); it != ObjectList<TestInterface>::end(); ++it)
@@ -42,7 +57,7 @@
EXPECT_EQ(0u, i);
}
- TEST(IteratorTest, CanCallObjects)
+ TEST_F(IteratorTest, CanCallObjects)
{
TestClass test1;
TestClass test2;
Modified: code/branches/core6/test/core/object/ListableTest.cc
===================================================================
--- code/branches/core6/test/core/object/ListableTest.cc 2013-08-14 15:44:53 UTC (rev 9648)
+++ code/branches/core6/test/core/object/ListableTest.cc 2013-08-14 16:42:28 UTC (rev 9649)
@@ -6,13 +6,13 @@
{
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:
ListableSubclassTest() { RegisterObject(ListableSubclassTest); }
@@ -27,58 +27,73 @@
return true;
return false;
}
+
+ // Fixture
+ class ListableTest : public ::testing::Test
+ {
+ public:
+ virtual void SetUp()
+ {
+ Context::setRootContext(new Context(NULL));
+ }
+
+ virtual void TearDown()
+ {
+ Context::setRootContext(NULL);
+ }
+ };
}
- TEST(ListableTest, CanCreate)
+ TEST_F(ListableTest, CanCreate)
{
- ListableTest* test = new ListableTest();
+ ListableClassTest* test = new ListableClassTest();
ASSERT_TRUE(test != NULL);
delete test;
}
- TEST(ListableTest, AddsToObjectList)
+ TEST_F(ListableTest, AddsToObjectList)
{
- ListableTest test;
- EXPECT_EQ(1u, ObjectList<ListableTest>::size());
- EXPECT_TRUE(objectListContains<ListableTest>(&test));
+ ListableClassTest test;
+ EXPECT_EQ(1u, ObjectList<ListableClassTest>::size());
+ EXPECT_TRUE(objectListContains<ListableClassTest>(&test));
}
- TEST(ListableTest, AddsToAllObjectLists)
+ TEST_F(ListableTest, AddsToAllObjectLists)
{
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));
}
- TEST(ListableTest, RemovesFromObjectList)
+ TEST_F(ListableTest, RemovesFromObjectList)
{
- EXPECT_EQ(0u, ObjectList<ListableTest>::size());
+ EXPECT_EQ(0u, ObjectList<ListableClassTest>::size());
{
- ListableTest test;
- EXPECT_EQ(1u, ObjectList<ListableTest>::size());
- EXPECT_TRUE(objectListContains<ListableTest>(&test));
+ ListableClassTest test;
+ EXPECT_EQ(1u, ObjectList<ListableClassTest>::size());
+ EXPECT_TRUE(objectListContains<ListableClassTest>(&test));
}
- EXPECT_EQ(0u, ObjectList<ListableTest>::size());
+ EXPECT_EQ(0u, ObjectList<ListableClassTest>::size());
}
- TEST(ListableTest, RemovesFromAllObjectLists)
+ TEST_F(ListableTest, RemovesFromAllObjectLists)
{
- EXPECT_EQ(0u, ObjectList<ListableTest>::size());
+ 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);
ListableSubclassTest test;
@@ -86,13 +101,13 @@
test.setContext(&context);
// 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);
Context subContext(&baseContext);
@@ -101,84 +116,84 @@
test.setContext(&subContext);
// 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();
Context newContext(NULL);
ListableSubclassTest test;
// 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));
test.setContext(&newContext);
// 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();
Context subContext(rootContext);
ListableSubclassTest test;
// 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));
test.setContext(&subContext);
// 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();
Context subContext1(rootContext);
@@ -188,40 +203,40 @@
test.setContext(&subContext1);
// 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));
test.setContext(&subContext2);
// 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));
}
Modified: code/branches/core6/test/core/object/ObjectListIteratorTest.cc
===================================================================
--- code/branches/core6/test/core/object/ObjectListIteratorTest.cc 2013-08-14 15:44:53 UTC (rev 9648)
+++ code/branches/core6/test/core/object/ObjectListIteratorTest.cc 2013-08-14 16:42:28 UTC (rev 9649)
@@ -15,19 +15,34 @@
ListableTest() { RegisterRootObject(ListableTest); }
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;
for (ObjectListIterator<ListableTest> it = ObjectList<ListableTest>::begin(); it != ObjectList<ListableTest>::end(); ++it)
@@ -35,7 +50,7 @@
EXPECT_EQ(0u, i);
}
- TEST(ObjectListIteratorTest, CanIterateOverFullList)
+ TEST_F(ObjectListIteratorTest, CanIterateOverFullList)
{
ListableTest test1;
ListableTest test2;
@@ -52,7 +67,7 @@
EXPECT_EQ(3u, i);
}
- TEST(ObjectListIteratorTest, CanIterateReverseOverFullList)
+ TEST_F(ObjectListIteratorTest, CanIterateReverseOverFullList)
{
ListableTest test1;
ListableTest test2;
@@ -69,7 +84,7 @@
EXPECT_EQ(3u, i);
}
- TEST(ObjectListIteratorTest, CanCallObjects)
+ TEST_F(ObjectListIteratorTest, CanCallObjects)
{
ListableTest test1;
ListableTest test2;
More information about the Orxonox-commit
mailing list