Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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:
10 edited
1 copied

Legend:

Unmodified
Added
Removed

  • code/trunk

  • 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    }
Note: See TracChangeset for help on using the changeset viewer.