Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Apr 26, 2015, 4:16:49 PM (10 years ago)
Author:
landauf
Message:

added function to destroy the class hierarchy (i.e. reset all information about parents and children in Identifiers).
tests now use a fixture to create and destroy class hierarchy. this makes them independent of the order of execution (and also fixes the three *_NoFixture tests)

Location:
code/branches/core7/test/core
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • code/branches/core7/test/core/class/IdentifierClassHierarchyTest.cc

    r10400 r10403  
    44#include "core/class/OrxonoxClass.h"
    55#include "core/class/OrxonoxInterface.h"
     6#include "core/module/ModuleInstance.h"
    67
    78namespace orxonox
    … …  
    141142                virtual void SetUp()
    142143                {
     144                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances();
     145                    ModuleInstance::setCurrentModuleInstance(new ModuleInstance()); // overwrite ModuleInstance because the old one is now loaded and shouln't be used anymore. TODO: better solution?
     146                    Identifier::initConfigValues_s = false; // TODO: hack!
     147                    IdentifierManager::getInstance().createClassHierarchy();
    143148                }
    144149
    145150                virtual void TearDown()
    146151                {
     152                    IdentifierManager::getInstance().destroyClassHierarchy();
    147153                }
    148154        };
    … …  
    159165    }
    160166
    161 //    TEST(IdentifierClassHierarchyTest_NoFixture, NoInitialization)
    162 //    {
    163 //        {
    164 //            Identifier* identifier = Class(BaseInterface1);
    165 //            EXPECT_EQ(0u, identifier->getChildren().size());
    166 //            EXPECT_EQ(0u, identifier->getParents().size());
    167 //        }
    168 //        {
    169 //            Identifier* identifier = Class(BaseInterface2);
    170 //            EXPECT_EQ(0u, identifier->getChildren().size());
    171 //            EXPECT_EQ(0u, identifier->getParents().size());
    172 //        }
    173 //        {
    174 //            Identifier* identifier = Class(Interface1);
    175 //            EXPECT_EQ(0u, identifier->getChildren().size());
    176 //            EXPECT_EQ(0u, identifier->getParents().size());
    177 //        }
    178 //        {
    179 //            Identifier* identifier = Class(Interface2);
    180 //            EXPECT_EQ(0u, identifier->getChildren().size());
    181 //            EXPECT_EQ(0u, identifier->getParents().size());
    182 //        }
    183 //        {
    184 //            Identifier* identifier = Class(BaseClass);
    185 //            EXPECT_EQ(0u, identifier->getChildren().size());
    186 //            EXPECT_EQ(0u, identifier->getParents().size());
    187 //        }
    188 //        {
    189 //            Identifier* identifier = Class(Class0);
    190 //            EXPECT_EQ(0u, identifier->getChildren().size());
    191 //            EXPECT_EQ(0u, identifier->getParents().size());
    192 //        }
    193 //        {
    194 //            Identifier* identifier = Class(Class1);
    195 //            EXPECT_EQ(0u, identifier->getChildren().size());
    196 //            EXPECT_EQ(0u, identifier->getParents().size());
    197 //        }
    198 //        {
    199 //            Identifier* identifier = Class(Class2a);
    200 //            EXPECT_EQ(0u, identifier->getChildren().size());
    201 //            EXPECT_EQ(0u, identifier->getParents().size());
    202 //        }
    203 //        {
    204 //            Identifier* identifier = Class(Class2b);
    205 //            EXPECT_EQ(0u, identifier->getChildren().size());
    206 //            EXPECT_EQ(0u, identifier->getParents().size());
    207 //        }
    208 //        {
    209 //            Identifier* identifier = Class(Class3);
    210 //            EXPECT_EQ(0u, identifier->getChildren().size());
    211 //            EXPECT_EQ(0u, identifier->getParents().size());
    212 //        }
    213 //    }
     167    TEST(IdentifierClassHierarchyTest_NoFixture, NoInitialization)
     168    {
     169        {
     170            Identifier* identifier = Class(BaseInterface1);
     171            EXPECT_EQ(0u, identifier->getChildren().size());
     172            EXPECT_EQ(0u, identifier->getParents().size());
     173        }
     174        {
     175            Identifier* identifier = Class(BaseInterface2);
     176            EXPECT_EQ(0u, identifier->getChildren().size());
     177            EXPECT_EQ(0u, identifier->getParents().size());
     178        }
     179        {
     180            Identifier* identifier = Class(Interface1);
     181            EXPECT_EQ(0u, identifier->getChildren().size());
     182            EXPECT_EQ(0u, identifier->getParents().size());
     183        }
     184        {
     185            Identifier* identifier = Class(Interface2);
     186            EXPECT_EQ(0u, identifier->getChildren().size());
     187            EXPECT_EQ(0u, identifier->getParents().size());
     188        }
     189        {
     190            Identifier* identifier = Class(BaseClass);
     191            EXPECT_EQ(0u, identifier->getChildren().size());
     192            EXPECT_EQ(0u, identifier->getParents().size());
     193        }
     194        {
     195            Identifier* identifier = Class(Class0);
     196            EXPECT_EQ(0u, identifier->getChildren().size());
     197            EXPECT_EQ(0u, identifier->getParents().size());
     198        }
     199        {
     200            Identifier* identifier = Class(Class1);
     201            EXPECT_EQ(0u, identifier->getChildren().size());
     202            EXPECT_EQ(0u, identifier->getParents().size());
     203        }
     204        {
     205            Identifier* identifier = Class(Class2a);
     206            EXPECT_EQ(0u, identifier->getChildren().size());
     207            EXPECT_EQ(0u, identifier->getParents().size());
     208        }
     209        {
     210            Identifier* identifier = Class(Class2b);
     211            EXPECT_EQ(0u, identifier->getChildren().size());
     212            EXPECT_EQ(0u, identifier->getParents().size());
     213        }
     214        {
     215            Identifier* identifier = Class(Class3);
     216            EXPECT_EQ(0u, identifier->getChildren().size());
     217            EXPECT_EQ(0u, identifier->getParents().size());
     218        }
     219    }
    214220
    215221    TEST_F(IdentifierClassHierarchyTest, TestBaseInterface1)

  • code/branches/core7/test/core/class/IdentifierExternalClassHierarchyTest.cc

    r10400 r10403  
    22#include "core/CoreIncludes.h"
    33#include "core/class/Identifiable.h"
     4#include "core/module/ModuleInstance.h"
    45
    56namespace orxonox
    … …  
    4849                virtual void SetUp()
    4950                {
     51                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances();
     52                    ModuleInstance::setCurrentModuleInstance(new ModuleInstance()); // overwrite ModuleInstance because the old one is now loaded and shouln't be used anymore. TODO: better solution?
     53                    Identifier::initConfigValues_s = false; // TODO: hack!
     54                    IdentifierManager::getInstance().createClassHierarchy();
    5055                }
    5156
    5257                virtual void TearDown()
    5358                {
     59                    IdentifierManager::getInstance().destroyClassHierarchy();
    5460                }
    5561        };
    … …  
    6672    }
    6773
    68 //    TEST(IdentifierExternalClassHierarchyTest_NoFixture, NoInitialization)
    69 //    {
    70 //        {
    71 //            Identifier* identifier = Class(Interface);
    72 //            EXPECT_EQ(0u, identifier->getChildren().size());
    73 //            EXPECT_EQ(0u, identifier->getParents().size());
    74 //        }
    75 //        {
    76 //            Identifier* identifier = Class(BaseClass);
    77 //            EXPECT_EQ(0u, identifier->getChildren().size());
    78 //            EXPECT_EQ(0u, identifier->getParents().size());
    79 //        }
    80 //        {
    81 //            Identifier* identifier = Class(RealClass);
    82 //            EXPECT_EQ(0u, identifier->getChildren().size());
    83 //            EXPECT_EQ(0u, identifier->getParents().size());
    84 //        }
    85 //    }
     74    TEST(IdentifierExternalClassHierarchyTest_NoFixture, NoInitialization)
     75    {
     76        {
     77            Identifier* identifier = Class(Interface);
     78            EXPECT_EQ(0u, identifier->getChildren().size());
     79            EXPECT_EQ(0u, identifier->getParents().size());
     80        }
     81        {
     82            Identifier* identifier = Class(BaseClass);
     83            EXPECT_EQ(0u, identifier->getChildren().size());
     84            EXPECT_EQ(0u, identifier->getParents().size());
     85        }
     86        {
     87            Identifier* identifier = Class(RealClass);
     88            EXPECT_EQ(0u, identifier->getChildren().size());
     89            EXPECT_EQ(0u, identifier->getParents().size());
     90        }
     91    }
    8692
    8793    TEST_F(IdentifierExternalClassHierarchyTest, TestInterface)

  • code/branches/core7/test/core/class/IdentifierNestedClassHierarchyTest.cc

    r10400 r10403  
    44#include "core/class/OrxonoxClass.h"
    55#include "core/class/OrxonoxInterface.h"
     6#include "core/module/ModuleInstance.h"
    67
    78namespace orxonox
    … …  
    108109                virtual void SetUp()
    109110                {
     111                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances();
     112                    ModuleInstance::setCurrentModuleInstance(new ModuleInstance()); // overwrite ModuleInstance because the old one is now loaded and shouln't be used anymore. TODO: better solution?
     113                    Identifier::initConfigValues_s = false; // TODO: hack!
     114                    IdentifierManager::getInstance().createClassHierarchy();
    110115                }
    111116
    112117                virtual void TearDown()
    113118                {
     119                    IdentifierManager::getInstance().destroyClassHierarchy();
    114120                }
    115121        };

  • code/branches/core7/test/core/class/IdentifierSimpleClassHierarchyTest.cc

    r10400 r10403  
    44#include "core/class/OrxonoxClass.h"
    55#include "core/class/OrxonoxInterface.h"
     6#include "core/module/ModuleInstance.h"
    67
    78namespace orxonox
    … …  
    5051                virtual void SetUp()
    5152                {
     53                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances();
     54                    ModuleInstance::setCurrentModuleInstance(new ModuleInstance()); // overwrite ModuleInstance because the old one is now loaded and shouln't be used anymore. TODO: better solution?
     55                    Identifier::initConfigValues_s = false; // TODO: hack!
     56                    IdentifierManager::getInstance().createClassHierarchy();
    5257                }
    5358
    5459                virtual void TearDown()
    5560                {
     61                    IdentifierManager::getInstance().destroyClassHierarchy();
    5662                }
    5763        };
    … …  
    6874    }
    6975
    70 //    TEST(IdentifierSimpleClassHierarchyTest_NoFixture, NoInitialization)
    71 //    {
    72 //        {
    73 //            Identifier* identifier = Class(Interface);
    74 //            EXPECT_EQ(0u, identifier->getChildren().size());
    75 //            EXPECT_EQ(0u, identifier->getParents().size());
    76 //        }
    77 //        {
    78 //            Identifier* identifier = Class(BaseClass);
    79 //            EXPECT_EQ(0u, identifier->getChildren().size());
    80 //            EXPECT_EQ(0u, identifier->getParents().size());
    81 //        }
    82 //        {
    83 //            Identifier* identifier = Class(RealClass);
    84 //            EXPECT_EQ(0u, identifier->getChildren().size());
    85 //            EXPECT_EQ(0u, identifier->getParents().size());
    86 //        }
    87 //    }
     76    TEST(IdentifierSimpleClassHierarchyTest_NoFixture, NoInitialization)
     77    {
     78        {
     79            Identifier* identifier = Class(Interface);
     80            EXPECT_EQ(0u, identifier->getChildren().size());
     81            EXPECT_EQ(0u, identifier->getParents().size());
     82        }
     83        {
     84            Identifier* identifier = Class(BaseClass);
     85            EXPECT_EQ(0u, identifier->getChildren().size());
     86            EXPECT_EQ(0u, identifier->getParents().size());
     87        }
     88        {
     89            Identifier* identifier = Class(RealClass);
     90            EXPECT_EQ(0u, identifier->getChildren().size());
     91            EXPECT_EQ(0u, identifier->getParents().size());
     92        }
     93    }
    8894
    8995    TEST_F(IdentifierSimpleClassHierarchyTest, TestInterface)

  • code/branches/core7/test/core/class/SubclassIdentifierTest.cc

    r10400 r10403  
    44#include "core/class/SubclassIdentifier.h"
    55#include "core/class/OrxonoxClass.h"
     6#include "core/module/ModuleInstance.h"
    67
    78namespace orxonox
    … …  
    3031                virtual void SetUp()
    3132                {
     33                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances();
     34                    ModuleInstance::setCurrentModuleInstance(new ModuleInstance()); // overwrite ModuleInstance because the old one is now loaded and shouln't be used anymore. TODO: better solution?
     35                    Identifier::initConfigValues_s = false; // TODO: hack!
     36                    IdentifierManager::getInstance().createClassHierarchy();
     37
    3238                    Context::setRootContext(new Context(NULL));
    3339                }
    … …  
    3642                {
    3743                    Context::setRootContext(NULL);
     44
     45                    IdentifierManager::getInstance().destroyClassHierarchy();
    3846                }
    3947        };

  • code/branches/core7/test/core/class/SuperTest.cc

    r10400 r10403  
    55#include "core/BaseObject.h"
    66#include "core/class/Super.h"
     7#include "core/module/ModuleInstance.h"
    78
    89namespace orxonox
    … …  
    6566        RegisterClass(TestSubclass);
    6667
    67        // Fixture
     68        // Fixture
    6869        class SuperTest : public ::testing::Test
    6970        {
    … …  
    7172                virtual void SetUp()
    7273                {
     74                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances();
     75                    ModuleInstance::setCurrentModuleInstance(new ModuleInstance()); // overwrite ModuleInstance because the old one is now loaded and shouln't be used anymore. TODO: better solution?
     76                    Identifier::initConfigValues_s = false; // TODO: hack!
     77                    IdentifierManager::getInstance().createClassHierarchy();
     78
    7379                    Context::setRootContext(new Context(NULL));
    7480                }
    … …  
    7783                {
    7884                    Context::setRootContext(NULL);
     85
     86                    IdentifierManager::getInstance().destroyClassHierarchy();
    7987                }
    8088        };

  • code/branches/core7/test/core/command/CommandTest.cc

    r10400 r10403  
    133133                ModifyConsoleCommand("test").popFunction();
    134134        }
     135
     136        // Fixture
     137        class CommandTest : public ::testing::Test
     138        {
     139            public:
     140                virtual void SetUp()
     141                {
     142                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances();
     143                    ModuleInstance::setCurrentModuleInstance(new ModuleInstance()); // overwrite ModuleInstance because the old one is now loaded and shouln't be used anymore. TODO: better solution?
     144                    Identifier::initConfigValues_s = false; // TODO: hack!
     145                    IdentifierManager::getInstance().createClassHierarchy();
     146                }
     147
     148                virtual void TearDown()
     149                {
     150                    IdentifierManager::getInstance().destroyClassHierarchy();
     151                }
     152        };
    135153    }
    136154
    … …  
    142160    }
    143161
    144     TEST(CommandTest, ModuleTest)
     162    TEST_F(CommandTest, ModuleTest)
    145163    {
    146         ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances();
    147         Identifier::initConfigValues_s = false; // TODO: hack!
    148         IdentifierManager::getInstance().createClassHierarchy();
    149 
    150164        test(0, 0, 0);
    151165        CommandExecutor::execute("test 0", false);
Note: See TracChangeset for help on using the changeset viewer.