Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 10624 for code/trunk/test


Ignore:
Timestamp:
Oct 4, 2015, 9:12:21 PM (9 years ago)
Author:
landauf
Message:

merged branch core7 back to trunk

Location:
code/trunk
Files:
2 deleted
23 edited
3 copied

Legend:

Unmodified
Added
Removed

  • code/trunk

  • code/trunk/test/core/CMakeLists.txt

    r10188 r10624  
    1212    class/IdentifierClassHierarchyTest.cc
    1313    class/IdentifierSimpleClassHierarchyTest.cc
     14    class/IdentifierNestedClassHierarchyTest.cc
    1415    class/IdentifierExternalClassHierarchyTest.cc
    1516    class/OrxonoxClassTest.cc
    … …  
    2526    object/ObjectListBaseTest.cc
    2627    object/ObjectListIteratorTest.cc
    27     object/SmartPtrTest.cc
     28    object/StrongPtrTest.cc
    2829    object/WeakPtrTest.cc
     30    singleton/ScopeTest.cc
    2931)
    3032ADD_DEPENDENCIES(all_tests core_test)

  • code/trunk/test/core/class/IdentifiableTest.cc

    r9659 r10624  
    22#include "core/CoreIncludes.h"
    33#include "core/class/Identifiable.h"
     4#include "core/module/ModuleInstance.h"
    45
    56namespace orxonox
    … …  
    78    namespace
    89    {
    9         class IdentifiableTest : public Identifiable
     10        class IdentifiableClass : public Identifiable
    1011        {
    1112            public:
    12                 IdentifiableTest() { RegisterObject(IdentifiableTest); }
     13                IdentifiableClass() { RegisterObject(IdentifiableClass); }
     14        };
     15
     16        RegisterClassNoArgs(IdentifiableClass);
     17
     18        // Fixture
     19        class IdentifiableTest : public ::testing::Test
     20        {
     21            public:
     22                virtual void SetUp()
     23                {
     24                    new IdentifierManager();
     25                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
     26                }
     27
     28                virtual void TearDown()
     29                {
     30                    ModuleInstance::getCurrentModuleInstance()->unloadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
     31                    delete &IdentifierManager::getInstance();
     32                }
    1333        };
    1434    }
    1535
    16     TEST(IdentifiableTest, CanCreate)
     36    TEST_F(IdentifiableTest, CanCreate)
    1737    {
    18         IdentifiableTest* test = new IdentifiableTest();
     38        IdentifiableClass* test = new IdentifiableClass();
    1939        ASSERT_TRUE(test != NULL);
    2040        delete test;
    2141    }
    2242
    23     TEST(IdentifiableTest, HasIdentifierAssigned)
     43    TEST_F(IdentifiableTest, HasIdentifierAssigned)
    2444    {
    25         IdentifiableTest test;
     45        IdentifiableClass test;
    2646        EXPECT_TRUE(test.getIdentifier());
    2747    }
    2848
    29     TEST(IdentifiableTest, CanBeIdentified)
     49    TEST_F(IdentifiableTest, CanBeIdentified)
    3050    {
    31         IdentifiableTest test;
    32         EXPECT_TRUE(test.isA(Class(IdentifiableTest)));
     51        IdentifiableClass test;
     52        EXPECT_TRUE(test.isA(Class(IdentifiableClass)));
    3353    }
    3454}

  • code/trunk/test/core/class/IdentifierClassHierarchyTest.cc

    r9659 r10624  
    44#include "core/class/OrxonoxClass.h"
    55#include "core/class/OrxonoxInterface.h"
     6#include "core/module/ModuleInstance.h"
    67
    78namespace orxonox
    … …  
    1920    namespace
    2021    {
    21         class BaseInterface1 : public OrxonoxInterface
     22        class BaseInterface1 : virtual public OrxonoxInterface
    2223        {
    2324            public:
    … …  
    3031        };
    3132
    32         class BaseInterface2 : public OrxonoxInterface
     33        class BaseInterface2 : virtual public OrxonoxInterface
    3334        {
    3435            public:
    … …  
    124125        };
    125126
     127        RegisterAbstractClass(BaseInterface1).inheritsFrom<OrxonoxInterface>();
     128        RegisterAbstractClass(BaseInterface2).inheritsFrom<OrxonoxInterface>();
     129        RegisterAbstractClass(Interface1).inheritsFrom<BaseInterface1>();
     130        RegisterAbstractClass(Interface2).inheritsFrom<BaseInterface2>();
     131        RegisterClassNoArgs(BaseClass);
     132        RegisterClassNoArgs(Class0);
     133        RegisterClassNoArgs(Class1);
     134        RegisterClassNoArgs(Class2a);
     135        RegisterClassNoArgs(Class2b);
     136        RegisterClassNoArgs(Class3);
     137
    126138        // Fixture
    127139        class IdentifierClassHierarchyTest : public ::testing::Test
    … …  
    130142                virtual void SetUp()
    131143                {
    132                     registerClass("Context", new ClassFactoryWithContext<Context>());
    133                     registerClass("Listable", new ClassFactoryWithContext<Listable>());
    134                     registerClass("Configurable", new ClassFactoryNoArgs<Configurable>());
    135                     registerClass("OrxonoxInterface", new ClassFactoryNoArgs<OrxonoxInterface>());
    136                     registerClass("OrxonoxClass", new ClassFactoryNoArgs<OrxonoxClass>());
    137                     registerClass("BaseInterface1", static_cast<ClassFactory<BaseInterface1>*>(NULL), false).inheritsFrom(Class(OrxonoxInterface));
    138                     registerClass("BaseInterface2", static_cast<ClassFactory<BaseInterface2>*>(NULL), false).inheritsFrom(Class(OrxonoxInterface));
    139                     registerClass("Interface1", static_cast<ClassFactory<Interface1>*>(NULL), false).inheritsFrom(Class(BaseInterface1));
    140                     registerClass("Interface2", static_cast<ClassFactory<Interface2>*>(NULL), false).inheritsFrom(Class(BaseInterface2));
    141                     registerClass("BaseClass", new ClassFactoryNoArgs<BaseClass>());
    142                     registerClass("Class0", new ClassFactoryNoArgs<Class0>());
    143                     registerClass("Class1", new ClassFactoryNoArgs<Class1>());
    144                     registerClass("Class2a", new ClassFactoryNoArgs<Class2a>());
    145                     registerClass("Class2b", new ClassFactoryNoArgs<Class2b>());
    146                     registerClass("Class3", new ClassFactoryNoArgs<Class3>());
    147 
     144                    new IdentifierManager();
     145                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
     146                    Context::setRootContext(new Context(NULL));
     147                    Identifier::initConfigValues_s = false; // TODO: hack!
    148148                    IdentifierManager::getInstance().createClassHierarchy();
    149149                }
    … …  
    151151                virtual void TearDown()
    152152                {
    153                     IdentifierManager::getInstance().destroyAllIdentifiers();
    154                 }
    155         };
     153                    IdentifierManager::getInstance().destroyClassHierarchy();
     154                    Context::destroyRootContext();
     155                    ModuleInstance::getCurrentModuleInstance()->unloadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
     156                    delete &IdentifierManager::getInstance();
     157                }
     158        };
     159
     160        bool contains(const std::list<const Identifier*> identifiers, Identifier* identifier)
     161        {
     162            return std::find(identifiers.begin(), identifiers.end(), identifier) != identifiers.end();
     163        }
    156164
    157165        bool contains(const std::set<const Identifier*> identifiers, Identifier* identifier)
    158166        {
    159167            return identifiers.find(identifier) != identifiers.end();
    160         }
    161     }
    162 
    163     TEST(IdentifierClassHierarchyTest_NoFixture, NoInitialization)
    164     {
    165         {
    166             Identifier* identifier = Class(BaseInterface1);
    167             EXPECT_EQ(0u, identifier->getChildren().size());
    168             EXPECT_EQ(0u, identifier->getParents().size());
    169         }
    170         {
    171             Identifier* identifier = Class(BaseInterface2);
    172             EXPECT_EQ(0u, identifier->getChildren().size());
    173             EXPECT_EQ(0u, identifier->getParents().size());
    174         }
    175         {
    176             Identifier* identifier = Class(Interface1);
    177             EXPECT_EQ(0u, identifier->getChildren().size());
    178             EXPECT_EQ(0u, identifier->getParents().size());
    179         }
    180         {
    181             Identifier* identifier = Class(Interface2);
    182             EXPECT_EQ(0u, identifier->getChildren().size());
    183             EXPECT_EQ(0u, identifier->getParents().size());
    184         }
    185         {
    186             Identifier* identifier = Class(BaseClass);
    187             EXPECT_EQ(0u, identifier->getChildren().size());
    188             EXPECT_EQ(0u, identifier->getParents().size());
    189         }
    190         {
    191             Identifier* identifier = Class(Class0);
    192             EXPECT_EQ(0u, identifier->getChildren().size());
    193             EXPECT_EQ(0u, identifier->getParents().size());
    194         }
    195         {
    196             Identifier* identifier = Class(Class1);
    197             EXPECT_EQ(0u, identifier->getChildren().size());
    198             EXPECT_EQ(0u, identifier->getParents().size());
    199         }
    200         {
    201             Identifier* identifier = Class(Class2a);
    202             EXPECT_EQ(0u, identifier->getChildren().size());
    203             EXPECT_EQ(0u, identifier->getParents().size());
    204         }
    205         {
    206             Identifier* identifier = Class(Class2b);
    207             EXPECT_EQ(0u, identifier->getChildren().size());
    208             EXPECT_EQ(0u, identifier->getParents().size());
    209         }
    210         {
    211             Identifier* identifier = Class(Class3);
    212             EXPECT_EQ(0u, identifier->getChildren().size());
    213             EXPECT_EQ(0u, identifier->getParents().size());
    214168        }
    215169    }

  • code/trunk/test/core/class/IdentifierExternalClassHierarchyTest.cc

    r9659 r10624  
    22#include "core/CoreIncludes.h"
    33#include "core/class/Identifiable.h"
     4#include "core/module/ModuleInstance.h"
    45
    56namespace orxonox
    … …  
    3839        };
    3940
     41        RegisterAbstractClass(Interface).inheritsFrom<Identifiable>();
     42        RegisterClassNoArgs(BaseClass);
     43        RegisterClassNoArgs(RealClass);
     44
    4045        // Fixture
    4146        class IdentifierExternalClassHierarchyTest : public ::testing::Test
    … …  
    4449                virtual void SetUp()
    4550                {
    46                     registerClass("Context", new ClassFactoryWithContext<Context>());
    47                     registerClass("Listable", new ClassFactoryWithContext<Listable>());
    48                     registerClass("Interface", static_cast<ClassFactory<Interface>*>(NULL), false).inheritsFrom(Class(Identifiable));
    49                     registerClass("BaseClass", new ClassFactoryNoArgs<BaseClass>());
    50                     registerClass("RealClass", new ClassFactoryNoArgs<RealClass>());
    51 
     51                    new IdentifierManager();
     52                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
     53                    Context::setRootContext(new Context(NULL));
     54                    Identifier::initConfigValues_s = false; // TODO: hack!
    5255                    IdentifierManager::getInstance().createClassHierarchy();
    5356                }
    … …  
    5558                virtual void TearDown()
    5659                {
    57                     IdentifierManager::getInstance().destroyAllIdentifiers();
     60                    IdentifierManager::getInstance().destroyClassHierarchy();
     61                    Context::destroyRootContext();
     62                    ModuleInstance::getCurrentModuleInstance()->unloadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
     63                    delete &IdentifierManager::getInstance();
    5864                }
    5965        };
     66
     67        bool contains(const std::list<const Identifier*> identifiers, Identifier* identifier)
     68        {
     69            return std::find(identifiers.begin(), identifiers.end(), identifier) != identifiers.end();
     70        }
    6071
    6172        bool contains(const std::set<const Identifier*> identifiers, Identifier* identifier)
    6273        {
    6374            return identifiers.find(identifier) != identifiers.end();
    64         }
    65     }
    66 
    67     TEST(IdentifierExternalClassHierarchyTest_NoFixture, NoInitialization)
    68     {
    69         {
    70             Identifier* identifier = Class(Interface);
    71             EXPECT_EQ(0u, identifier->getChildren().size());
    72             EXPECT_EQ(0u, identifier->getParents().size());
    73         }
    74         {
    75             Identifier* identifier = Class(BaseClass);
    76             EXPECT_EQ(0u, identifier->getChildren().size());
    77             EXPECT_EQ(0u, identifier->getParents().size());
    78         }
    79         {
    80             Identifier* identifier = Class(RealClass);
    81             EXPECT_EQ(0u, identifier->getChildren().size());
    82             EXPECT_EQ(0u, identifier->getParents().size());
    8375        }
    8476    }

  • code/trunk/test/core/class/IdentifierSimpleClassHierarchyTest.cc

    r9659 r10624  
    44#include "core/class/OrxonoxClass.h"
    55#include "core/class/OrxonoxInterface.h"
     6#include "core/module/ModuleInstance.h"
    67
    78namespace orxonox
    … …  
    910    namespace
    1011    {
    11         class Interface : public OrxonoxInterface
     12        class Interface : virtual public OrxonoxInterface
    1213        {
    1314            public:
    … …  
    4041        };
    4142
     43        RegisterAbstractClass(Interface).inheritsFrom<OrxonoxInterface>();
     44        RegisterClassNoArgs(BaseClass);
     45        RegisterClassNoArgs(RealClass);
     46
    4247        // Fixture
    4348        class IdentifierSimpleClassHierarchyTest : public ::testing::Test
    … …  
    4651                virtual void SetUp()
    4752                {
    48                     registerClass("Context", new ClassFactoryWithContext<Context>());
    49                     registerClass("Listable", new ClassFactoryWithContext<Listable>());
    50                     registerClass("Configurable", new ClassFactoryNoArgs<Configurable>());
    51                     registerClass("OrxonoxInterface", new ClassFactoryNoArgs<OrxonoxInterface>());
    52                     registerClass("OrxonoxClass", new ClassFactoryNoArgs<OrxonoxClass>());
    53                     registerClass("Interface", static_cast<ClassFactory<Interface>*>(NULL), false).inheritsFrom(Class(OrxonoxInterface));
    54                     registerClass("BaseClass", new ClassFactoryNoArgs<BaseClass>());
    55                     registerClass("RealClass", new ClassFactoryNoArgs<RealClass>());
    56 
     53                    new IdentifierManager();
     54                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
     55                    Context::setRootContext(new Context(NULL));
     56                    Identifier::initConfigValues_s = false; // TODO: hack!
    5757                    IdentifierManager::getInstance().createClassHierarchy();
    5858                }
    … …  
    6060                virtual void TearDown()
    6161                {
    62                     IdentifierManager::getInstance().destroyAllIdentifiers();
     62                    IdentifierManager::getInstance().destroyClassHierarchy();
     63                    Context::destroyRootContext();
     64                    ModuleInstance::getCurrentModuleInstance()->unloadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
     65                    delete &IdentifierManager::getInstance();
    6366                }
    6467        };
     68
     69        bool contains(const std::list<const Identifier*> identifiers, Identifier* identifier)
     70        {
     71            return std::find(identifiers.begin(), identifiers.end(), identifier) != identifiers.end();
     72        }
    6573
    6674        bool contains(const std::set<const Identifier*> identifiers, Identifier* identifier)
    6775        {
    6876            return identifiers.find(identifier) != identifiers.end();
    69         }
    70     }
    71 
    72     TEST(IdentifierSimpleClassHierarchyTest_NoFixture, NoInitialization)
    73     {
    74         {
    75             Identifier* identifier = Class(Interface);
    76             EXPECT_EQ(0u, identifier->getChildren().size());
    77             EXPECT_EQ(0u, identifier->getParents().size());
    78         }
    79         {
    80             Identifier* identifier = Class(BaseClass);
    81             EXPECT_EQ(0u, identifier->getChildren().size());
    82             EXPECT_EQ(0u, identifier->getParents().size());
    83         }
    84         {
    85             Identifier* identifier = Class(RealClass);
    86             EXPECT_EQ(0u, identifier->getChildren().size());
    87             EXPECT_EQ(0u, identifier->getParents().size());
    8877        }
    8978    }

  • code/trunk/test/core/class/IdentifierTest.cc

    r9659 r10624  
    22#include "core/CoreIncludes.h"
    33#include "core/class/Identifiable.h"
     4#include "core/module/ModuleInstance.h"
    45
    56namespace orxonox
    … …  
    1819                TestSubclass() { RegisterObject(TestSubclass); }
    1920        };
     21
     22        RegisterClassNoArgs(TestClass);
     23        RegisterClassNoArgs(TestSubclass);
     24
     25        // Fixture
     26        class IdentifierTest : public ::testing::Test
     27        {
     28            public:
     29                virtual void SetUp()
     30                {
     31                    new IdentifierManager();
     32                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
     33                }
     34
     35                virtual void TearDown()
     36                {
     37                    ModuleInstance::getCurrentModuleInstance()->unloadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
     38                    delete &IdentifierManager::getInstance();
     39                }
     40        };
    2041    }
    2142
    22     TEST(IdentifierTest, IdentifierExistsOfClass)
     43    TEST_F(IdentifierTest, IdentifierExistsOfClass)
    2344    {
    2445        TestClass test;
    … …  
    2849    }
    2950
    30     TEST(IdentifierTest, IdentifierExistsOfSubclass)
     51    TEST_F(IdentifierTest, IdentifierExistsOfSubclass)
    3152    {
    3253        TestSubclass test;
    … …  
    3657    }
    3758
    38     TEST(IdentifierTest, HasNameOfClass)
     59    TEST_F(IdentifierTest, HasNameOfClass)
    3960    {
    4061        TestClass test;
    … …  
    4465    }
    4566
    46     TEST(IdentifierTest, HasNameOfSubClass)
     67    TEST_F(IdentifierTest, HasNameOfSubClass)
    4768    {
    4869        TestSubclass test;

  • code/trunk/test/core/class/OrxonoxClassTest.cc

    r9649 r10624  
    11#include <gtest/gtest.h>
    22#include "core/class/OrxonoxClass.h"
     3#include "core/class/IdentifierManager.h"
    34#include "core/object/Context.h"
    45
    … …  
    1718                virtual void SetUp()
    1819                {
     20                    new IdentifierManager();
    1921                    Context::setRootContext(new Context(NULL));
    2022                }
    … …  
    2224                virtual void TearDown()
    2325                {
    24                     Context::setRootContext(NULL);
     26                    Context::destroyRootContext();
     27                    delete &IdentifierManager::getInstance();
    2528                }
    2629        };

  • code/trunk/test/core/class/OrxonoxInterfaceTest.cc

    r9649 r10624  
    22#include "core/class/OrxonoxInterface.h"
    33#include "core/class/OrxonoxClass.h"
     4#include "core/class/IdentifierManager.h"
    45#include "core/object/Context.h"
    56
    … …  
    3233                virtual void SetUp()
    3334                {
     35                    new IdentifierManager();
    3436                    Context::setRootContext(new Context(NULL));
    3537                }
    … …  
    3739                virtual void TearDown()
    3840                {
    39                     Context::setRootContext(NULL);
     41                    Context::destroyRootContext();
     42                    delete &IdentifierManager::getInstance();
    4043                }
    4144        };

  • code/trunk/test/core/class/SubclassIdentifierTest.cc

    r9659 r10624  
    44#include "core/class/SubclassIdentifier.h"
    55#include "core/class/OrxonoxClass.h"
     6#include "core/module/ModuleInstance.h"
    67
    78namespace orxonox
    … …  
    2122        };
    2223
     24        RegisterClass(TestClass);
     25        RegisterClass(TestSubclass);
     26
    2327        // Fixture
    2428        class SubclassIdentifierTest : public ::testing::Test
    … …  
    2731                virtual void SetUp()
    2832                {
    29                     registerClass("OrxonoxClass", new ClassFactoryNoArgs<OrxonoxClass>());
    30                     registerClass("TestClass", new ClassFactoryWithContext<TestClass>());
    31                     registerClass("TestSubclass", new ClassFactoryWithContext<TestSubclass>());
    32 
     33                    new IdentifierManager();
     34                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
     35                    Context::setRootContext(new Context(NULL));
     36                    Identifier::initConfigValues_s = false; // TODO: hack!
    3337                    IdentifierManager::getInstance().createClassHierarchy();
    34 
    35                     Context::setRootContext(new Context(NULL));
    3638                }
    3739
    3840                virtual void TearDown()
    3941                {
    40                     Context::setRootContext(NULL);
    41 
    42                     IdentifierManager::getInstance().destroyAllIdentifiers();
     42                    IdentifierManager::getInstance().destroyClassHierarchy();
     43                    Context::destroyRootContext();
     44                    ModuleInstance::getCurrentModuleInstance()->unloadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
     45                    delete &IdentifierManager::getInstance();
    4346                }
    4447        };

  • code/trunk/test/core/class/SuperTest.cc

    r9659 r10624  
    55#include "core/BaseObject.h"
    66#include "core/class/Super.h"
     7#include "core/module/ModuleInstance.h"
    78
    89namespace orxonox
    … …  
    6263        };
    6364
    64        // Fixture
     65        RegisterClass(TestClass);
     66        RegisterClass(TestSubclass);
     67
     68        // Fixture
    6569        class SuperTest : public ::testing::Test
    6670        {
    … …  
    6872                virtual void SetUp()
    6973                {
    70                     IdentifierManager::getInstance().destroyAllIdentifiers();
    71 
    72                     registerClass("OrxonoxClass", new ClassFactoryNoArgs<OrxonoxClass>());
    73                     registerClass("BaseObject", new ClassFactoryWithContext<BaseObject>());
    74                     registerClass("TestClass", new ClassFactoryWithContext<TestClass>());
    75                     registerClass("TestSubclass", new ClassFactoryWithContext<TestSubclass>());
    76 
     74                    new IdentifierManager();
     75                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
     76                    Context::setRootContext(new Context(NULL));
     77                    Identifier::initConfigValues_s = false; // TODO: hack!
    7778                    IdentifierManager::getInstance().createClassHierarchy();
    78 
    79                     Context::setRootContext(new Context(NULL));
    8079                }
    8180
    8281                virtual void TearDown()
    8382                {
    84                     Context::setRootContext(NULL);
    85 
    86                     IdentifierManager::getInstance().destroyAllIdentifiers();
     83                    IdentifierManager::getInstance().destroyClassHierarchy();
     84                    Context::destroyRootContext();
     85                    ModuleInstance::getCurrentModuleInstance()->unloadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
     86                    delete &IdentifierManager::getInstance();
    8787                }
    8888        };
    … …  
    9797
    9898            EXPECT_EQ(1u, identifier->getDirectParents().size());
    99             EXPECT_TRUE(identifier->getDirectParents().find(Class(TestClass)) != identifier->getDirectParents().end());
     99            EXPECT_TRUE(std::find(identifier->getDirectParents().begin(), identifier->getDirectParents().end(), Class(TestClass)) != identifier->getDirectParents().end());
    100100        }
    101101        {
    … …  
    106106
    107107            EXPECT_EQ(1u, identifier->getDirectParents().size());
    108             EXPECT_TRUE(identifier->getDirectParents().find(Class(BaseObject)) != identifier->getDirectParents().end());
     108            EXPECT_TRUE(std::find(identifier->getDirectParents().begin(), identifier->getDirectParents().end(), Class(BaseObject)) != identifier->getDirectParents().end());
    109109        }
    110110    }

  • code/trunk/test/core/command/CommandTest.cc

    r9603 r10624  
    11#include <gtest/gtest.h>
    2 #include "core/command/ConsoleCommand.h"
     2#include "core/class/Identifier.h"
     3#include "core/class/IdentifierManager.h"
     4#include "core/command/ConsoleCommandIncludes.h"
    35#include "core/command/CommandExecutor.h"
    46#include "core/object/Destroyable.h"
     7#include "core/module/ModuleInstance.h"
    58
    69namespace orxonox
    … …  
    130133                ModifyConsoleCommand("test").popFunction();
    131134        }
     135
     136        // Fixture
     137        class CommandTest : public ::testing::Test
     138        {
     139            public:
     140                virtual void SetUp()
     141                {
     142                    new IdentifierManager();
     143                    new ConsoleCommandManager();
     144                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::CONSOLE_COMMAND);
     145                    Context::setRootContext(new Context(NULL));
     146                    Identifier::initConfigValues_s = false; // TODO: hack!
     147                    IdentifierManager::getInstance().createClassHierarchy();
     148                }
     149
     150                virtual void TearDown()
     151                {
     152                    IdentifierManager::getInstance().destroyClassHierarchy();
     153                    Context::destroyRootContext();
     154                    ModuleInstance::getCurrentModuleInstance()->unloadAllStaticallyInitializedInstances(StaticInitialization::CONSOLE_COMMAND);
     155                    delete &ConsoleCommandManager::getInstance();
     156                    delete &IdentifierManager::getInstance();
     157                }
     158        };
    132159    }
    133160
    … …  
    139166    }
    140167
    141     TEST(CommandTest, ModuleTest)
     168    TEST_F(CommandTest, ModuleTest)
    142169    {
    143170        test(0, 0, 0);

  • code/trunk/test/core/object/ClassFactoryTest.cc

    r9649 r10624  
    33#include "core/BaseObject.h"
    44#include "core/object/Context.h"
     5#include "core/module/ModuleInstance.h"
     6#include "core/CoreIncludes.h"
    57
    68namespace orxonox
    … …  
    1416                virtual void SetUp()
    1517                {
     18                    new IdentifierManager();
     19                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    1620                    Context::setRootContext(new Context(NULL));
    1721                }
    … …  
    1923                virtual void TearDown()
    2024                {
    21                     Context::setRootContext(NULL);
     25                    Context::destroyRootContext();
     26                    ModuleInstance::getCurrentModuleInstance()->unloadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
     27                    delete &IdentifierManager::getInstance();
    2228                }
    2329        };

  • code/trunk/test/core/object/ContextTest.cc

    r9659 r10624  
    33#include "core/class/OrxonoxClass.h"
    44#include "core/CoreIncludes.h"
     5#include "core/module/ModuleInstance.h"
    56
    67namespace orxonox
    … …  
    1415        };
    1516
     17        RegisterClassNoArgs(SubclassContext);
     18
    1619        // Fixture
    1720        class ContextTest : public ::testing::Test
    … …  
    2023                virtual void SetUp()
    2124                {
     25                    new IdentifierManager();
     26                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    2227                    Context::setRootContext(new Context(NULL));
    2328                }
    … …  
    2530                virtual void TearDown()
    2631                {
    27                     Context::setRootContext(NULL);
     32                    Context::destroyRootContext();
     33                    ModuleInstance::getCurrentModuleInstance()->unloadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
     34                    delete &IdentifierManager::getInstance();
    2835                }
    2936        };

  • code/trunk/test/core/object/IteratorTest.cc

    r9659 r10624  
    66#include "core/class/OrxonoxInterface.h"
    77#include "core/CoreIncludes.h"
     8#include "core/module/ModuleInstance.h"
    89
    910namespace orxonox
    … …  
    2425        };
    2526
     27        RegisterClassNoArgs(TestInterface);
     28        RegisterClassNoArgs(TestClass);
     29
    2630        // Fixture
    2731        class IteratorTest : public ::testing::Test
    … …  
    3034                virtual void SetUp()
    3135                {
     36                    new IdentifierManager();
     37                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    3238                    Context::setRootContext(new Context(NULL));
    3339                }
    … …  
    3541                virtual void TearDown()
    3642                {
    37                     Context::setRootContext(NULL);
     43                    Context::destroyRootContext();
     44                    ModuleInstance::getCurrentModuleInstance()->unloadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
     45                    delete &IdentifierManager::getInstance();
    3846                }
    3947        };

  • code/trunk/test/core/object/ListableTest.cc

    r9659 r10624  
    22#include "core/object/Listable.h"
    33#include "core/CoreIncludes.h"
     4#include "core/module/ModuleInstance.h"
    45
    56namespace orxonox
    … …  
    1011        {
    1112            public:
    12             ListableClassTest() { RegisterObject(ListableClassTest); }
     13                ListableClassTest() { RegisterObject(ListableClassTest); }
    1314        };
    1415
    … …  
    1819                ListableSubclassTest() { RegisterObject(ListableSubclassTest); }
    1920        };
     21
     22        RegisterClassNoArgs(ListableClassTest);
     23        RegisterClassNoArgs(ListableSubclassTest);
    2024
    2125        template <class T>
    … …  
    3539                virtual void SetUp()
    3640                {
     41                    new IdentifierManager();
     42                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    3743                    Context::setRootContext(new Context(NULL));
    3844                }
    … …  
    4046                virtual void TearDown()
    4147                {
    42                     Context::setRootContext(NULL);
     48                    Context::destroyRootContext();
     49                    ModuleInstance::getCurrentModuleInstance()->unloadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
     50                    delete &IdentifierManager::getInstance();
    4351                }
    4452        };

  • code/trunk/test/core/object/ObjectListIteratorTest.cc

    r9659 r10624  
    55#include "core/object/Listable.h"
    66#include "core/CoreIncludes.h"
     7#include "core/module/ModuleInstance.h"
    78
    89namespace orxonox
    … …  
    1718        };
    1819
     20        RegisterClassNoArgs(ListableTest);
     21
    1922        // Fixture
    2023        class ObjectListIteratorTest : public ::testing::Test
    … …  
    2326                virtual void SetUp()
    2427                {
     28                    new IdentifierManager();
     29                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    2530                    Context::setRootContext(new Context(NULL));
    2631                }
    … …  
    2833                virtual void TearDown()
    2934                {
    30                     Context::setRootContext(NULL);
     35                    Context::destroyRootContext();
     36                    ModuleInstance::getCurrentModuleInstance()->unloadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
     37                    delete &IdentifierManager::getInstance();
    3138                }
    3239        };

  • code/trunk/test/core/object/WeakPtrTest.cc

    r9603 r10624  
    4545        test->destroy();
    4646    }
     47
     48    void isNull(const WeakPtr<DestroyableTest> weakPtr)
     49    {
     50        EXPECT_TRUE(weakPtr == NULL);
     51        EXPECT_TRUE(weakPtr == 0);
     52        EXPECT_TRUE(!weakPtr);
     53        EXPECT_FALSE(weakPtr != NULL);
     54        EXPECT_FALSE(weakPtr != 0);
     55        EXPECT_FALSE(weakPtr);
     56    }
     57
     58    TEST(WeakPtrTest, IsNull)
     59    {
     60        {
     61            WeakPtr<DestroyableTest> weakPtr;
     62            isNull(weakPtr);
     63        }
     64        {
     65            WeakPtr<DestroyableTest> weakPtr = NULL;
     66            isNull(weakPtr);
     67        }
     68        {
     69            WeakPtr<DestroyableTest> weakPtr;
     70            weakPtr = NULL;
     71            isNull(weakPtr);
     72        }
     73        {
     74            WeakPtr<DestroyableTest> weakPtr = 0;
     75            isNull(weakPtr);
     76        }
     77        {
     78            WeakPtr<DestroyableTest> weakPtr;
     79            weakPtr = 0;
     80            isNull(weakPtr);
     81        }
     82    }
     83
     84    TEST(WeakPtrTest, IsNotNull)
     85    {
     86        DestroyableTest* test = new DestroyableTest();
     87        WeakPtr<DestroyableTest> weakPtr = test;
     88        EXPECT_FALSE(weakPtr == NULL);
     89        EXPECT_FALSE(weakPtr == 0);
     90        EXPECT_FALSE(!weakPtr);
     91        EXPECT_TRUE(weakPtr != NULL);
     92        EXPECT_TRUE(weakPtr != 0);
     93        EXPECT_TRUE(weakPtr);
     94        test->destroy();
     95    }
    4796}

  • code/trunk/test/util/CMakeLists.txt

    r10188 r10624  
    1313    MultiTypeTest.cc
    1414    OutputTest.cc
    15     ScopeTest.cc
    1615    SharedPtrTest.cc
    1716    SingletonTest.cc

  • code/trunk/test/util/output/ConsoleWriterTest.cc

    r9547 r10624  
    77namespace orxonox
    88{
    9     TEST(ConsoleWriterTest, Disable)
     9    namespace
    1010    {
    11         // reset output manager
    12         OutputManager::Testing::getInstancePointer() = new OutputManager();
     11        // Fixture
     12        class ConsoleWriterTest : public ::testing::Test
     13        {
     14            public:
     15                virtual void SetUp()
     16                {
     17                    // reset output manager
     18                    OutputManager::Testing::getInstancePointer() = new OutputManager();
     19                }
    1320
     21                virtual void TearDown()
     22                {
     23                }
     24        };
     25    }
     26
     27    TEST_F(ConsoleWriterTest, Disable)
     28    {
    1429        std::ostream stream(NULL);
    1530        EXPECT_EQ(0U, OutputManager::getInstance().getListeners().size());
    … …  
    2035    }
    2136
    22     TEST(ConsoleWriterTest, Enable)
     37    TEST_F(ConsoleWriterTest, Enable)
    2338    {
    24         // reset output manager
    25         OutputManager::Testing::getInstancePointer() = new OutputManager();
    26 
    2739        std::ostream stream(NULL);
    2840        ConsoleWriter writer(stream);
    … …  
    3345    }
    3446
    35     TEST(ConsoleWriterTest, WritesNoOutputToOutputStream)
     47    TEST_F(ConsoleWriterTest, WritesNoOutputToOutputStream)
    3648    {
    3749        std::stringbuf buffer;
    … …  
    4456    }
    4557
    46     TEST(ConsoleWriterTest, WritesOutputToOutputStream)
     58    TEST_F(ConsoleWriterTest, WritesOutputToOutputStream)
    4759    {
    4860        std::stringbuf buffer;
    … …  
    6375    }
    6476
    65     TEST(ConsoleWriterTest, DefaultConsoleWriterUsesCout)
     77    TEST_F(ConsoleWriterTest, DefaultConsoleWriterUsesCout)
    6678    {
    6779        OutputManager::getInstanceAndCreateListeners();

  • code/trunk/test/util/output/LogWriterTest.cc

    r9549 r10624  
    33#include "util/output/LogWriter.h"
    44#include "util/Convert.h"
     5#include "util/output/OutputManager.h"
     6#include "util/SharedPtr.h"
    57
    68namespace orxonox
    … …  
    1416                    { this->LogWriter::printLine(line, level); }
    1517        };
     18
     19        // Fixture
     20        class LogWriterTest : public ::testing::Test
     21        {
     22            public:
     23                virtual void SetUp()
     24                {
     25                    // reset output manager
     26                    OutputManager::Testing::getInstancePointer() = new OutputManager();
     27                }
     28
     29                virtual void TearDown()
     30                {
     31                }
     32        };
    1633    }
    1734
    1835    // test constructor opens file
    19     TEST(LogWriterTest, ConstructorOpensFile)
     36    TEST_F(LogWriterTest, ConstructorOpensFile)
    2037    {
    2138        LogWriter logWriter;
    … …  
    6481    }
    6582
    66     TEST(LogWriterTest, SetLogDirectoryOpensNewFile)
     83    TEST_F(LogWriterTest, SetLogDirectoryOpensNewFile)
    6784    {
    6885        std::string path = "./orxonox.log";
    … …  
    83100
    84101    // prints output to logfile
    85     TEST(LogWriterTest, PrintsOutputToLogfile)
     102    TEST_F(LogWriterTest, PrintsOutputToLogfile)
    86103    {
    87104        std::string path;
    … …  
    103120
    104121    // prints time to logfile
    105     TEST(LogWriterTest, PrintsTimestampToLogfile)
     122    TEST_F(LogWriterTest, PrintsTimestampToLogfile)
    106123    {
    107124        std::string path;
    … …  
    152169    }
    153170
    154     TEST(LogWriterTest, ArchivesOldLogFile)
     171    TEST_F(LogWriterTest, ArchivesOldLogFile)
    155172    {
    156173        deleteAllLogFiles();
    … …  
    196213    }
    197214
    198     TEST(LogWriterTest, ArchivesNineLogFiles)
     215    TEST_F(LogWriterTest, ArchivesNineLogFiles)
    199216    {
    200217        deleteAllLogFiles();

  • code/trunk/test/util/output/MemoryWriterTest.cc

    r9545 r10624  
    44#include "util/output/MemoryWriter.h"
    55#include "util/output/OutputManager.h"
     6#include "util/SharedPtr.h"
    67
    78namespace orxonox
    … …  
    1415                MOCK_METHOD3(output, void(OutputLevel, const OutputContextContainer&, const std::vector<std::string>&));
    1516        };
     17
     18        // Fixture
     19        class MemoryWriterTest : public ::testing::Test
     20        {
     21            public:
     22                virtual void SetUp()
     23                {
     24                    // reset output manager
     25                    OutputManager::Testing::getInstancePointer() = new OutputManager();
     26                }
     27
     28                virtual void TearDown()
     29                {
     30                }
     31        };
    1632    }
    1733
    18     TEST(MemoryWriterTest, Disable)
     34    TEST_F(MemoryWriterTest, Disable)
    1935    {
    2036        EXPECT_EQ(0U, OutputManager::getInstance().getListeners().size());
    … …  
    2541    }
    2642
    27     TEST(MemoryWriterTest, ResendOutput)
     43    TEST_F(MemoryWriterTest, ResendOutput)
    2844    {
    2945        MemoryWriter writer;

  • code/trunk/test/util/output/OutputManagerTest.cc

    r9547 r10624  
    9898
    9999        EXPECT_FALSE(manager.getListeners().empty());
     100
     101        manager.unregisterListener(&listener);
    100102    }
    101103
    … …  
    123125
    124126        EXPECT_FALSE(listener.getListeners().empty());
     127
     128        manager.unregisterListener(&listener);
    125129    }
    126130
    … …  
    156160        EXPECT_EQ(level::verbose_more, manager.getCombinedAdditionalContextsLevelMask());
    157161        EXPECT_EQ(context::unittest2().mask, manager.getCombinedAdditionalContextsMask());
     162
     163        manager.unregisterListener(&listener);
    158164    }
    159165
    … …  
    193199
    194200        EXPECT_EQ(level::internal_warning, manager.getCombinedLevelMask());
     201
     202        manager.unregisterListener(&listener);
    195203    }
    196204
    … …  
    208216
    209217        EXPECT_EQ(level::internal_warning, manager.getCombinedAdditionalContextsLevelMask());
     218
     219        manager.unregisterListener(&listener);
    210220    }
    211221
    … …  
    223233
    224234        EXPECT_EQ(context::unittest2().mask, manager.getCombinedAdditionalContextsMask());
     235
     236        manager.unregisterListener(&listener);
    225237    }
    226238
    … …  
    254266        EXPECT_EQ(level::verbose | level::verbose_more | level::verbose_ultra, manager.getCombinedAdditionalContextsLevelMask());
    255267        EXPECT_EQ(context::unittest1().mask | context::unittest2().mask | context::unittest3().mask, manager.getCombinedAdditionalContextsMask());
     268
     269        manager.unregisterListener(&listener1);
     270        manager.unregisterListener(&listener2);
     271        manager.unregisterListener(&listener3);
    256272    }
    257273
    … …  
    287303        EXPECT_TRUE(manager.acceptsOutput(level::verbose_more, context::unittest2()));
    288304        EXPECT_FALSE(manager.acceptsOutput(level::verbose_ultra, context::unittest2()));
     305
     306        manager.unregisterListener(&listener);
    289307    }
    290308
    … …  
    302320
    303321        manager.pushMessage(level::user_status, context::unittest1(), "some output");
     322
     323        manager.unregisterListener(&listener);
    304324    }
    305325
    … …  
    319339
    320340        manager.pushMessage(level::user_status, context::unittest1(), "some output\nand some more output\n!!!");
     341
     342        manager.unregisterListener(&listener);
    321343    }
    322344
Note: See TracChangeset for help on using the changeset viewer.