Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 11071 for code/trunk/test/core


Ignore:
Timestamp:
Jan 17, 2016, 10:29:21 PM (8 years ago)
Author:
landauf
Message:

merged branch cpp11_v3 back to trunk

Location:
code/trunk
Files:
23 edited
4 copied

Legend:

Unmodified
Added
Removed

  • code/trunk

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

    r10624 r11071  
    1919    class/SuperTest.cc
    2020    command/CommandTest.cc
     21    command/FunctorPtrTest.cc
     22    command/FunctorTest.cc
     23    command/ExecutorPtrTest.cc
    2124    object/ClassFactoryTest.cc
    2225    object/ContextTest.cc
    … …  
    2528    object/ListableTest.cc
    2629    object/ObjectListBaseTest.cc
     30    object/ObjectListTest.cc
    2731    object/ObjectListIteratorTest.cc
    2832    object/StrongPtrTest.cc

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

    r10624 r11071  
    2020        {
    2121            public:
    22                 virtual void SetUp()
     22                virtual void SetUp() override
    2323                {
    2424                    new IdentifierManager();
    … …  
    2626                }
    2727
    28                 virtual void TearDown()
     28                virtual void TearDown() override
    2929                {
    3030                    ModuleInstance::getCurrentModuleInstance()->unloadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    … …  
    3737    {
    3838        IdentifiableClass* test = new IdentifiableClass();
    39         ASSERT_TRUE(test != NULL);
     39        ASSERT_TRUE(test != nullptr);
    4040        delete test;
    4141    }

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

    r10624 r11071  
    8686                }
    8787
    88                 virtual void test1() {}
     88                virtual void test1() override {}
    8989        };
    9090
    … …  
    9797                }
    9898
    99                 virtual void test1() {}
    100                 virtual void test2() {}
     99                virtual void test1() override {}
     100                virtual void test2() override {}
    101101        };
    102102
    … …  
    109109                }
    110110
    111                 virtual void test1() {}
    112                 virtual void test2() {}
     111                virtual void test1() override {}
     112                virtual void test2() override {}
    113113        };
    114114
    … …  
    121121                }
    122122
    123                 virtual void test1() {}
    124                 virtual void test2() {}
     123                virtual void test1() override {}
     124                virtual void test2() override {}
    125125        };
    126126
    … …  
    140140        {
    141141            public:
    142                 virtual void SetUp()
     142                virtual void SetUp() override
    143143                {
    144144                    new IdentifierManager();
    145145                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    146                     Context::setRootContext(new Context(NULL));
     146                    Context::setRootContext(new Context(nullptr));
    147147                    Identifier::initConfigValues_s = false; // TODO: hack!
    148148                    IdentifierManager::getInstance().createClassHierarchy();
    149149                }
    150150
    151                 virtual void TearDown()
     151                virtual void TearDown() override
    152152                {
    153153                    IdentifierManager::getInstance().destroyClassHierarchy();

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

    r10624 r11071  
    3636                }
    3737
    38                 virtual void test() {}
     38                virtual void test() override {}
    3939        };
    4040
    … …  
    4747        {
    4848            public:
    49                 virtual void SetUp()
     49                virtual void SetUp() override
    5050                {
    5151                    new IdentifierManager();
    5252                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    53                     Context::setRootContext(new Context(NULL));
     53                    Context::setRootContext(new Context(nullptr));
    5454                    Identifier::initConfigValues_s = false; // TODO: hack!
    5555                    IdentifierManager::getInstance().createClassHierarchy();
    5656                }
    5757
    58                 virtual void TearDown()
     58                virtual void TearDown() override
    5959                {
    6060                    IdentifierManager::getInstance().destroyClassHierarchy();

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

    r11052 r11071  
    107107        {
    108108            public:
    109                 virtual void SetUp()
     109                virtual void SetUp() override
    110110                {
    111111                    new IdentifierManager();
    112112                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    113                     Context::setRootContext(new Context(NULL));
     113                    Context::setRootContext(new Context(nullptr));
    114114                    Identifier::initConfigValues_s = false; // TODO: hack!
    115115                    IdentifierManager::getInstance().createClassHierarchy();
    116116                }
    117117
    118                 virtual void TearDown()
     118                virtual void TearDown() override
    119119                {
    120120                    IdentifierManager::getInstance().destroyClassHierarchy();

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

    r10624 r11071  
    3838                }
    3939
    40                 virtual void test() {}
     40                virtual void test() override {}
    4141        };
    4242
    … …  
    4949        {
    5050            public:
    51                 virtual void SetUp()
     51                virtual void SetUp() override
    5252                {
    5353                    new IdentifierManager();
    5454                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    55                     Context::setRootContext(new Context(NULL));
     55                    Context::setRootContext(new Context(nullptr));
    5656                    Identifier::initConfigValues_s = false; // TODO: hack!
    5757                    IdentifierManager::getInstance().createClassHierarchy();
    5858                }
    5959
    60                 virtual void TearDown()
     60                virtual void TearDown() override
    6161                {
    6262                    IdentifierManager::getInstance().destroyClassHierarchy();

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

    r10624 r11071  
    2727        {
    2828            public:
    29                 virtual void SetUp()
     29                virtual void SetUp() override
    3030                {
    3131                    new IdentifierManager();
    … …  
    3333                }
    3434
    35                 virtual void TearDown()
     35                virtual void TearDown() override
    3636                {
    3737                    ModuleInstance::getCurrentModuleInstance()->unloadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    … …  
    4646
    4747        Identifier* identifier = Class(TestClass);
    48         EXPECT_TRUE(identifier != NULL);
     48        EXPECT_TRUE(identifier != nullptr);
    4949    }
    5050
    … …  
    5454
    5555        Identifier* identifier = Class(TestSubclass);
    56         EXPECT_TRUE(identifier != NULL);
     56        EXPECT_TRUE(identifier != nullptr);
    5757    }
    5858

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

    r10624 r11071  
    1616        {
    1717            public:
    18                 virtual void SetUp()
     18                virtual void SetUp() override
    1919                {
    2020                    new IdentifierManager();
    21                     Context::setRootContext(new Context(NULL));
     21                    Context::setRootContext(new Context(nullptr));
    2222                }
    2323
    24                 virtual void TearDown()
     24                virtual void TearDown() override
    2525                {
    2626                    Context::destroyRootContext();
    … …  
    3333    {
    3434        TestClass* test = new TestClass();
    35         ASSERT_TRUE(test != NULL);
     35        ASSERT_TRUE(test != nullptr);
    3636        delete test;
    3737    }

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

    r10624 r11071  
    3131        {
    3232            public:
    33                 virtual void SetUp()
     33                virtual void SetUp() override
    3434                {
    3535                    new IdentifierManager();
    36                     Context::setRootContext(new Context(NULL));
     36                    Context::setRootContext(new Context(nullptr));
    3737                }
    3838
    39                 virtual void TearDown()
     39                virtual void TearDown() override
    4040                {
    4141                    Context::destroyRootContext();
    … …  
    4848    {
    4949        TestClass1* test = new TestClass1();
    50         ASSERT_TRUE(test != NULL);
     50        ASSERT_TRUE(test != nullptr);
    5151        delete test;
    5252    }
    … …  
    5555    {
    5656        TestClass2* test = new TestClass2();
    57         ASSERT_TRUE(test != NULL);
     57        ASSERT_TRUE(test != nullptr);
    5858        delete test;
    5959    }

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

    r10624 r11071  
    1313        {
    1414            public:
    15                 TestClass(Context* context = NULL) { RegisterObject(TestClass); }
     15                TestClass(Context* context = nullptr) { RegisterObject(TestClass); }
    1616        };
    1717
    … …  
    1919        {
    2020            public:
    21                 TestSubclass(Context* context = NULL) { RegisterObject(TestSubclass); }
     21                TestSubclass(Context* context = nullptr) { RegisterObject(TestSubclass); }
    2222        };
    2323
    … …  
    2929        {
    3030            public:
    31                 virtual void SetUp()
     31                virtual void SetUp() override
    3232                {
    3333                    new IdentifierManager();
    3434                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    35                     Context::setRootContext(new Context(NULL));
     35                    Context::setRootContext(new Context(nullptr));
    3636                    Identifier::initConfigValues_s = false; // TODO: hack!
    3737                    IdentifierManager::getInstance().createClassHierarchy();
    3838                }
    3939
    40                 virtual void TearDown()
     40                virtual void TearDown() override
    4141                {
    4242                    IdentifierManager::getInstance().destroyClassHierarchy();
    … …  
    7777        subclassIdentifier = Class(TestSubclass);
    7878
    79         TestClass* instance = subclassIdentifier.fabricate(NULL);
    80         ASSERT_TRUE(instance != NULL);
     79        TestClass* instance = subclassIdentifier.fabricate(nullptr);
     80        ASSERT_TRUE(instance != nullptr);
    8181        EXPECT_EQ(Class(TestSubclass), instance->getIdentifier());
    8282        delete instance;

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

    r10624 r11071  
    1414        {
    1515            public:
    16                 TestClass(Context* context = NULL) : BaseObject(context), changedNameBase_(false), xmlPortBase_(false), modeBase_(XMLPort::NOP)
     16                TestClass(Context* context = nullptr) : BaseObject(context), changedNameBase_(false), xmlPortBase_(false), modeBase_(XMLPort::NOP)
    1717                {
    1818                    RegisterObject(TestClass);
    1919                }
    2020
    21                 virtual void changedName()
     21                virtual void changedName() override
    2222                {
    2323                    this->changedNameBase_ = true;
    2424                }
    2525
    26                 virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode)
     26                virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override
    2727                {
    2828                    this->xmlPortBase_ = true;
    … …  
    3838        {
    3939            public:
    40                 TestSubclass(Context* context = NULL) : TestClass(context), changedNameSubclass_(false), xmlPortSubclass_(false), modeSubclass_(XMLPort::NOP)
     40                TestSubclass(Context* context = nullptr) : TestClass(context), changedNameSubclass_(false), xmlPortSubclass_(false), modeSubclass_(XMLPort::NOP)
    4141                {
    4242                    RegisterObject(TestSubclass);
    4343                }
    4444
    45                 virtual void changedName()
     45                virtual void changedName() override
    4646                {
    4747                    this->changedNameSubclass_ = true;
    … …  
    5050                }
    5151
    52                 virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode)
     52                virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override
    5353                {
    5454                    this->xmlPortSubclass_ = true;
    … …  
    7070        {
    7171            public:
    72                 virtual void SetUp()
     72                virtual void SetUp() override
    7373                {
    7474                    new IdentifierManager();
    7575                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    76                     Context::setRootContext(new Context(NULL));
     76                    Context::setRootContext(new Context(nullptr));
    7777                    Identifier::initConfigValues_s = false; // TODO: hack!
    7878                    IdentifierManager::getInstance().createClassHierarchy();
    7979                }
    8080
    81                 virtual void TearDown()
     81                virtual void TearDown() override
    8282                {
    8383                    IdentifierManager::getInstance().destroyClassHierarchy();
    … …  
    132132        EXPECT_EQ(XMLPort::NOP, test.modeSubclass_);
    133133
    134         Element* element = NULL;
     134        Element* element = nullptr;
    135135        test.XMLPort(*element, XMLPort::SaveObject);
    136136

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

    r10624 r11071  
    129129                ModifyConsoleCommand("test").popObject();
    130130            else if (a == 1)
    131                 ModifyConsoleCommand("test").setFunction(FunctorPtr(0));
     131                ModifyConsoleCommand("test").setFunction(FunctorPtr(nullptr));
    132132            else if (a == -1)
    133133                ModifyConsoleCommand("test").popFunction();
    … …  
    138138        {
    139139            public:
    140                 virtual void SetUp()
     140                virtual void SetUp() override
    141141                {
    142142                    new IdentifierManager();
    143143                    new ConsoleCommandManager();
    144144                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::CONSOLE_COMMAND);
    145                     Context::setRootContext(new Context(NULL));
     145                    Context::setRootContext(new Context(nullptr));
    146146                    Identifier::initConfigValues_s = false; // TODO: hack!
    147147                    IdentifierManager::getInstance().createClassHierarchy();
    148148                }
    149149
    150                 virtual void TearDown()
     150                virtual void TearDown() override
    151151                {
    152152                    IdentifierManager::getInstance().destroyClassHierarchy();

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

    r10624 r11071  
    1414        {
    1515            public:
    16                 virtual void SetUp()
     16                virtual void SetUp() override
    1717                {
    1818                    new IdentifierManager();
    1919                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    20                     Context::setRootContext(new Context(NULL));
     20                    Context::setRootContext(new Context(nullptr));
    2121                }
    2222
    23                 virtual void TearDown()
     23                virtual void TearDown() override
    2424                {
    2525                    Context::destroyRootContext();
    … …  
    3333    {
    3434        Factory* factory = new ClassFactoryWithContext<BaseObject>();
    35         Identifiable* object = factory->fabricate(NULL);
    36         ASSERT_TRUE(object != NULL);
     35        Identifiable* object = factory->fabricate(nullptr);
     36        ASSERT_TRUE(object != nullptr);
    3737        BaseObject* baseObject = dynamic_cast<BaseObject*>(object);
    38         EXPECT_TRUE(baseObject != NULL);
     38        EXPECT_TRUE(baseObject != nullptr);
    3939        delete object;
    4040        // don't delete factory - it remains in the identifier

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

    r10624 r11071  
    1212        {
    1313            public:
    14                 SubclassContext() : Context(NULL) { RegisterObject(SubclassContext); }
     14                SubclassContext() : Context(nullptr) { RegisterObject(SubclassContext); }
    1515        };
    1616
    … …  
    2121        {
    2222            public:
    23                 virtual void SetUp()
     23                virtual void SetUp() override
    2424                {
    2525                    new IdentifierManager();
    2626                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    27                     Context::setRootContext(new Context(NULL));
     27                    Context::setRootContext(new Context(nullptr));
    2828                }
    2929
    30                 virtual void TearDown()
     30                virtual void TearDown() override
    3131                {
    3232                    Context::destroyRootContext();
    … …  
    3939    TEST_F(ContextTest, CanCreateContext)
    4040    {
    41         Context context(NULL);
     41        Context context(nullptr);
    4242    }
    4343
    … …  
    4949    TEST_F(ContextTest, ContextIsItsOwnContext)
    5050    {
    51         Context context(NULL);
     51        Context context(nullptr);
    5252        EXPECT_EQ(&context, context.getContext());
    5353    }
    … …  
    6868    TEST_F(ContextTest, ContextIsAddedToItsOwnObjectList)
    6969    {
    70         Context context(NULL);
     70        Context context(nullptr);
    7171        ASSERT_EQ(1u, context.getObjectList<Context>()->size());
    7272        EXPECT_TRUE(context.getObjectList<Context>()->begin()->objectBase_ == static_cast<Listable*>(&context));
    … …  
    7575    TEST_F(ContextTest, ContextIsAddedToObjectListOfBaseContext)
    7676    {
    77         Context baseContext(NULL);
     77        Context baseContext(nullptr);
    7878        Context subContext(&baseContext);
    7979

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

    r9603 r11071  
    3232        DestroyableTest* test = new DestroyableTest(destroyed);
    3333        EXPECT_FALSE(destroyed);
    34         EXPECT_TRUE(test != NULL);
     34        EXPECT_TRUE(test != nullptr);
    3535        test->destroy();
    3636        EXPECT_TRUE(destroyed);

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

    r10624 r11071  
    1515        {
    1616            public:
    17             TestInterface() { RegisterObject(TestInterface); }
     17                TestInterface() { RegisterObject(TestInterface); }
    1818        };
    1919
    … …  
    3232        {
    3333            public:
    34                 virtual void SetUp()
     34                virtual void SetUp() override
    3535                {
    3636                    new IdentifierManager();
    3737                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    38                     Context::setRootContext(new Context(NULL));
     38                    Context::setRootContext(new Context(nullptr));
    3939                }
    4040
    41                 virtual void TearDown()
     41                virtual void TearDown() override
    4242                {
    4343                    Context::destroyRootContext();
    … …  
    5555    TEST_F(IteratorTest, CanAssignIterator)
    5656    {
    57         Iterator<TestInterface> it = ObjectList<TestInterface>::begin();
     57        ObjectList<TestInterface> list;
     58        Iterator<TestInterface> it = list.begin();
    5859    }
    5960
    … …  
    6162    {
    6263        size_t i = 0;
    63         for (Iterator<TestInterface> it = ObjectList<TestInterface>::begin(); it != ObjectList<TestInterface>::end(); ++it)
     64        ObjectList<TestInterface> list;
     65        for (Iterator<TestInterface> it = list.begin(); it != list.end(); ++it)
    6466            ++i;
    6567        EXPECT_EQ(0u, i);
    … …  
    7779
    7880        // iterate over interfaces but use a TestClass iterator - now we can call TestClass::test()
    79         for (Iterator<TestClass> it = ObjectList<TestInterface>::begin(); it != ObjectList<TestInterface>::end(); ++it)
     81        ObjectList<TestInterface> list;
     82        for (Iterator<TestClass> it = list.begin(); it != list.end(); ++it)
    8083            it->test();
    8184    }
     85
     86    TEST_F(IteratorTest, CanIterateOverInterfaceListWithInterfaceIterator)
     87    {
     88        TestClass testClass;
     89        TestInterface testInterface;
     90
     91        size_t i = 0;
     92        ObjectList<TestInterface> list;
     93        for (Iterator<TestInterface> it = list.begin(); it != list.end(); ++it)
     94        {
     95            ++i;
     96            if (i == 1u) EXPECT_EQ(&testClass, *it);
     97            if (i == 2u) EXPECT_EQ(&testInterface, *it);
     98        }
     99        EXPECT_EQ(2u, i);
     100    }
     101
     102    TEST_F(IteratorTest, CanIterateOverClassListWithClassIterator)
     103    {
     104        TestClass testClass;
     105        TestInterface testInterface;
     106
     107        size_t i = 0;
     108        ObjectList<TestClass> list;
     109        for (Iterator<TestClass> it = list.begin(); it != list.end(); ++it)
     110        {
     111            ++i;
     112            if (i == 1u) EXPECT_EQ(&testClass, *it);
     113        }
     114        EXPECT_EQ(1u, i);
     115    }
     116
     117    TEST_F(IteratorTest, CanIterateOverInterfaceListWithClassIterator)
     118    {
     119        TestClass testClass;
     120        TestInterface testInterface;
     121
     122        size_t i = 0;
     123        ObjectList<TestInterface> list;
     124        for (Iterator<TestClass> it = list.begin(); it != list.end(); ++it)
     125        {
     126            ++i;
     127            if (i == 1u) EXPECT_EQ(&testClass, *it);
     128            if (i == 2u) EXPECT_EQ(nullptr, *it);
     129        }
     130        EXPECT_EQ(2u, i);
     131    }
     132
     133    TEST_F(IteratorTest, CanIterateOverClassListWithInterfaceIterator)
     134    {
     135        TestClass testClass;
     136        TestInterface testInterface;
     137
     138        size_t i = 0;
     139        ObjectList<TestClass> list;
     140        for (Iterator<TestInterface> it = list.begin(); it != list.end(); ++it)
     141        {
     142            ++i;
     143            if (i == 1u) EXPECT_EQ(&testClass, *it);
     144        }
     145        EXPECT_EQ(1u, i);
     146    }
    82147}

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

    r10624 r11071  
    3737        {
    3838            public:
    39                 virtual void SetUp()
     39                virtual void SetUp() override
    4040                {
    4141                    new IdentifierManager();
    4242                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    43                     Context::setRootContext(new Context(NULL));
     43                    Context::setRootContext(new Context(nullptr));
    4444                }
    4545
    46                 virtual void TearDown()
     46                virtual void TearDown() override
    4747                {
    4848                    Context::destroyRootContext();
    … …  
    5656    {
    5757        ListableClassTest* test = new ListableClassTest();
    58         ASSERT_TRUE(test != NULL);
     58        ASSERT_TRUE(test != nullptr);
    5959        delete test;
    6060    }
    … …  
    6363    {
    6464        ListableClassTest test;
    65         EXPECT_EQ(1u, ObjectList<ListableClassTest>::size());
     65        EXPECT_EQ(1u, ObjectList<ListableClassTest>().size());
    6666        EXPECT_TRUE(objectListContains<ListableClassTest>(&test));
    6767    }
    … …  
    7070    {
    7171        ListableSubclassTest test;
    72         EXPECT_EQ(1u, ObjectList<ListableClassTest>::size());
     72        EXPECT_EQ(1u, ObjectList<ListableClassTest>().size());
    7373        EXPECT_TRUE(objectListContains<ListableClassTest>(&test));
    74         EXPECT_EQ(1u, ObjectList<ListableSubclassTest>::size());
     74        EXPECT_EQ(1u, ObjectList<ListableSubclassTest>().size());
    7575        EXPECT_TRUE(objectListContains<ListableSubclassTest>(&test));
    7676    }
    … …  
    7878    TEST_F(ListableTest, RemovesFromObjectList)
    7979    {
    80         EXPECT_EQ(0u, ObjectList<ListableClassTest>::size());
     80        EXPECT_EQ(0u, ObjectList<ListableClassTest>().size());
    8181        {
    8282            ListableClassTest test;
    83             EXPECT_EQ(1u, ObjectList<ListableClassTest>::size());
     83            EXPECT_EQ(1u, ObjectList<ListableClassTest>().size());
    8484            EXPECT_TRUE(objectListContains<ListableClassTest>(&test));
    8585        }
    86         EXPECT_EQ(0u, ObjectList<ListableClassTest>::size());
     86        EXPECT_EQ(0u, ObjectList<ListableClassTest>().size());
    8787    }
    8888
    8989    TEST_F(ListableTest, RemovesFromAllObjectLists)
    9090    {
    91         EXPECT_EQ(0u, ObjectList<ListableClassTest>::size());
    92         EXPECT_EQ(0u, ObjectList<ListableSubclassTest>::size());
     91        EXPECT_EQ(0u, ObjectList<ListableClassTest>().size());
     92        EXPECT_EQ(0u, ObjectList<ListableSubclassTest>().size());
    9393        {
    9494            ListableSubclassTest test;
    95             EXPECT_EQ(1u, ObjectList<ListableClassTest>::size());
     95            EXPECT_EQ(1u, ObjectList<ListableClassTest>().size());
    9696            EXPECT_TRUE(objectListContains<ListableClassTest>(&test));
    97             EXPECT_EQ(1u, ObjectList<ListableSubclassTest>::size());
     97            EXPECT_EQ(1u, ObjectList<ListableSubclassTest>().size());
    9898            EXPECT_TRUE(objectListContains<ListableSubclassTest>(&test));
    9999        }
    100         EXPECT_EQ(0u, ObjectList<ListableClassTest>::size());
    101         EXPECT_EQ(0u, ObjectList<ListableSubclassTest>::size());
     100        EXPECT_EQ(0u, ObjectList<ListableClassTest>().size());
     101        EXPECT_EQ(0u, ObjectList<ListableSubclassTest>().size());
    102102    }
    103103
    104104    TEST_F(ListableTest, CanAddObjectToContext)
    105105    {
    106         Context context(NULL);
     106        Context context(nullptr);
    107107        ListableSubclassTest test;
    108108
    … …  
    118118    TEST_F(ListableTest, CanAddObjectToSubContext)
    119119    {
    120         Context baseContext(NULL);
     120        Context baseContext(nullptr);
    121121        Context subContext(&baseContext);
    122122        ListableSubclassTest test;
    … …  
    139139    {
    140140        Context* rootContext = Context::getRootContext();
    141         Context newContext(NULL);
     141        Context newContext(nullptr);
    142142        ListableSubclassTest test;
    143143

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

    r9661 r11071  
    2424    {
    2525        ObjectListBase list;
    26         ObjectListBaseElement* element = new ObjectListElement<Listable>(NULL);
     26        ObjectListBaseElement* element = new ObjectListElement<Listable>(nullptr);
    2727        list.addElement(element);
    2828        EXPECT_EQ(1u, list.size());
    … …  
    3232    {
    3333        ObjectListBase list;
    34         ObjectListBaseElement* element = new ObjectListElement<Listable>(NULL);
     34        ObjectListBaseElement* element = new ObjectListElement<Listable>(nullptr);
    3535        list.addElement(element);
    3636        EXPECT_EQ(1u, list.size());
    … …  
    4343    {
    4444        ObjectListBase list;
    45         list.addElement(new ObjectListElement<Listable>(NULL));
     45        list.addElement(new ObjectListElement<Listable>(nullptr));
    4646        EXPECT_EQ(1u, list.size());
    4747    }
    … …  
    5252        EXPECT_EQ(0u, list.size());
    5353        {
    54             ObjectListElement<Listable> element1(NULL);
     54            ObjectListElement<Listable> element1(nullptr);
    5555            list.addElement(&element1);
    5656            EXPECT_EQ(1u, list.size());
    5757            {
    58                 ObjectListElement<Listable> element1(NULL);
     58                ObjectListElement<Listable> element1(nullptr);
    5959                list.addElement(&element1);
    6060                EXPECT_EQ(2u, list.size());
    6161                {
    62                     ObjectListElement<Listable> element1(NULL);
     62                    ObjectListElement<Listable> element1(nullptr);
    6363                    list.addElement(&element1);
    6464                    EXPECT_EQ(3u, list.size());
    … …  
    7676        ObjectListElementRemovalListenerMock listener;
    7777        list.registerRemovalListener(&listener);
    78         ObjectListBaseElement* element = new ObjectListElement<Listable>(NULL);
     78        ObjectListBaseElement* element = new ObjectListElement<Listable>(nullptr);
    7979        list.addElement(element);
    8080        EXPECT_CALL(listener, removedElement(element));

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

    r10624 r11071  
    33
    44#include "core/object/ObjectListIterator.h"
    5 #include "core/object/Listable.h"
     5#include "core/class/OrxonoxClass.h"
     6#include "core/class/OrxonoxInterface.h"
    67#include "core/CoreIncludes.h"
    78#include "core/module/ModuleInstance.h"
    … …  
    1112    namespace
    1213    {
    13         class ListableTest : public Listable
     14        class TestInterface : virtual public OrxonoxInterface
    1415        {
    1516            public:
    16                 ListableTest() { RegisterObject(ListableTest); }
     17                TestInterface() { RegisterObject(TestInterface); }
     18        };
     19
     20        class TestClass : public OrxonoxClass, public TestInterface
     21        {
     22            public:
     23                TestClass() { RegisterObject(TestClass); }
    1724                MOCK_METHOD0(test, void());
    1825        };
    1926
    20         RegisterClassNoArgs(ListableTest);
     27        RegisterClassNoArgs(TestInterface);
     28        RegisterClassNoArgs(TestClass);
    2129
    2230        // Fixture
    … …  
    2432        {
    2533            public:
    26                 virtual void SetUp()
     34                virtual void SetUp() override
    2735                {
    2836                    new IdentifierManager();
    2937                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    30                     Context::setRootContext(new Context(NULL));
     38                    Context::setRootContext(new Context(nullptr));
    3139                }
    3240
    33                 virtual void TearDown()
     41                virtual void TearDown() override
    3442                {
    3543                    Context::destroyRootContext();
    … …  
    4250    TEST_F(ObjectListIteratorTest, CanCreateIterator)
    4351    {
    44         ObjectListIterator<ListableTest> it;
     52        ObjectListIterator<TestClass> it;
    4553    }
    4654
    4755    TEST_F(ObjectListIteratorTest, CanAssignIterator)
    4856    {
    49         ObjectListIterator<ListableTest> it = ObjectList<ListableTest>::begin();
     57        ObjectList<TestClass> list;
     58        ObjectListIterator<TestClass> it = list.begin();
    5059    }
    5160
    … …  
    5362    {
    5463        size_t i = 0;
    55         for (ObjectListIterator<ListableTest> it = ObjectList<ListableTest>::begin(); it != ObjectList<ListableTest>::end(); ++it)
     64        ObjectList<TestClass> list;
     65        for (ObjectListIterator<TestClass> it = list.begin(); it != list.end(); ++it)
    5666            ++i;
    5767        EXPECT_EQ(0u, i);
    … …  
    6070    TEST_F(ObjectListIteratorTest, CanIterateOverFullList)
    6171    {
    62         ListableTest test1;
    63         ListableTest test2;
    64         ListableTest test3;
     72        TestClass test1;
     73        TestClass test2;
     74        TestClass test3;
     75        TestInterface interface;
    6576
    6677        size_t i = 0;
    67         for (ObjectListIterator<ListableTest> it = ObjectList<ListableTest>::begin(); it != ObjectList<ListableTest>::end(); ++it)
     78        ObjectList<TestClass> list;
     79        for (ObjectListIterator<TestClass> it = list.begin(); it != list.end(); ++it)
    6880        {
    6981            ++i;
    … …  
    7789    TEST_F(ObjectListIteratorTest, CanIterateReverseOverFullList)
    7890    {
    79         ListableTest test1;
    80         ListableTest test2;
    81         ListableTest test3;
     91        TestClass test1;
     92        TestClass test2;
     93        TestClass test3;
     94        TestInterface interface;
    8295
    8396        size_t i = 0;
    84         for (ObjectListIterator<ListableTest> it = ObjectList<ListableTest>::rbegin(); it != ObjectList<ListableTest>::rend(); --it)
     97        ObjectList<TestClass> list;
     98        for (ObjectListIterator<TestClass> it = list.rbegin(); it != list.rend(); --it)
    8599        {
    86100            ++i;
    … …  
    94108    TEST_F(ObjectListIteratorTest, CanCallObjects)
    95109    {
    96         ListableTest test1;
    97         ListableTest test2;
    98         ListableTest test3;
     110        TestClass test1;
     111        TestClass test2;
     112        TestClass test3;
     113        TestInterface interface;
    99114
    100115        EXPECT_CALL(test1, test());
    … …  
    102117        EXPECT_CALL(test3, test());
    103118
    104         for (ObjectListIterator<ListableTest> it = ObjectList<ListableTest>::begin(); it != ObjectList<ListableTest>::end(); ++it)
     119        ObjectList<TestClass> list;
     120        for (ObjectListIterator<TestClass> it = list.begin(); it != list.end(); ++it)
    105121            it->test();
    106122    }

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

    r10624 r11071  
     1#include <utility>
    12#include <gtest/gtest.h>
    23#include "core/object/StrongPtr.h"
    … …  
    2324        StrongPtr<DestroyableTest> strongPtr = test;
    2425        EXPECT_EQ(test, strongPtr.get());
     26        EXPECT_EQ(test, &(*strongPtr));
     27        EXPECT_EQ(static_cast<Destroyable*>(test), strongPtr.getBase());
     28        test->destroy();
     29    }
     30
     31    TEST(StrongPtrTest, CanHaveMultiplePointers)
     32    {
     33        bool bla;
     34        DestroyableTest* test = new DestroyableTest(bla);
     35        StrongPtr<DestroyableTest> strongPtr1 = test;
     36        StrongPtr<DestroyableTest> strongPtr2 = test;
     37        StrongPtr<DestroyableTest> strongPtr3 = test;
     38        EXPECT_EQ(test, strongPtr1.get());
     39        EXPECT_EQ(test, strongPtr2.get());
     40        EXPECT_EQ(test, strongPtr3.get());
     41        EXPECT_EQ(3u, test->getReferenceCount());
    2542        test->destroy();
    2643    }
    … …  
    94111    void isNull(const StrongPtr<DestroyableTest> strongPtr)
    95112    {
    96         EXPECT_TRUE(strongPtr == NULL);
    97         EXPECT_TRUE(strongPtr == 0);
     113        EXPECT_TRUE(strongPtr == nullptr);
     114        EXPECT_TRUE(strongPtr == nullptr);
    98115        EXPECT_TRUE(!strongPtr);
    99         EXPECT_FALSE(strongPtr != NULL);
    100         EXPECT_FALSE(strongPtr != 0);
     116        EXPECT_FALSE(strongPtr != nullptr);
     117        EXPECT_FALSE(strongPtr != nullptr);
    101118        EXPECT_FALSE(strongPtr);
    102119    }
    … …  
    109126        }
    110127        {
    111             StrongPtr<DestroyableTest> strongPtr = NULL;
     128            StrongPtr<DestroyableTest> strongPtr = nullptr;
    112129            isNull(strongPtr);
    113130        }
    114131        {
    115132            StrongPtr<DestroyableTest> strongPtr;
    116             strongPtr = NULL;
    117             isNull(strongPtr);
    118         }
    119         {
    120             StrongPtr<DestroyableTest> strongPtr = 0;
     133            strongPtr = nullptr;
     134            isNull(strongPtr);
     135        }
     136        {
     137            StrongPtr<DestroyableTest> strongPtr = nullptr;
    121138            isNull(strongPtr);
    122139        }
    123140        {
    124141            StrongPtr<DestroyableTest> strongPtr;
    125             strongPtr = 0;
     142            strongPtr = nullptr;
    126143            isNull(strongPtr);
    127144        }
    … …  
    133150        DestroyableTest* test = new DestroyableTest(destroyed);
    134151        StrongPtr<DestroyableTest> strongPtr = test;
    135         EXPECT_FALSE(strongPtr == NULL);
    136         EXPECT_FALSE(strongPtr == 0);
     152        EXPECT_FALSE(strongPtr == nullptr);
     153        EXPECT_FALSE(strongPtr == nullptr);
    137154        EXPECT_FALSE(!strongPtr);
    138         EXPECT_TRUE(strongPtr != NULL);
    139         EXPECT_TRUE(strongPtr != 0);
     155        EXPECT_TRUE(strongPtr != nullptr);
     156        EXPECT_TRUE(strongPtr != nullptr);
    140157        EXPECT_TRUE(strongPtr);
    141158        test->destroy();
    142159    }
     160
     161    TEST(StrongPtrTest, TestConstructors)
     162    {
     163        bool bla;
     164        DestroyableTest* test = new DestroyableTest(bla);
     165
     166        // default
     167        StrongPtr<DestroyableTest> strongPtr1;
     168        EXPECT_EQ(nullptr, strongPtr1.get());
     169
     170        // pointer
     171        StrongPtr<DestroyableTest> strongPtr2a = test;
     172        StrongPtr<DestroyableTest> strongPtr2b(test);
     173        EXPECT_EQ(test, strongPtr2a.get());
     174        EXPECT_EQ(test, strongPtr2b.get());
     175
     176        // copy
     177        StrongPtr<DestroyableTest> strongPtr3a = strongPtr2a;
     178        StrongPtr<DestroyableTest> strongPtr3b(strongPtr2b);
     179        EXPECT_EQ(test, strongPtr3a.get());
     180        EXPECT_EQ(test, strongPtr3b.get());
     181
     182        // move
     183        StrongPtr<DestroyableTest> strongPtr4a = std::move(strongPtr3a);
     184        StrongPtr<DestroyableTest> strongPtr4b(std::move(strongPtr3b));
     185        EXPECT_EQ(test, strongPtr4a.get());
     186        EXPECT_EQ(test, strongPtr4b.get());
     187
     188        // other
     189        StrongPtr<Destroyable> strongPtr5a = strongPtr4a;
     190        StrongPtr<Destroyable> strongPtr5b(strongPtr4b);
     191        EXPECT_EQ(test, strongPtr5a.get());
     192        EXPECT_EQ(test, strongPtr5b.get());
     193
     194        // weakPtr
     195        WeakPtr<DestroyableTest> weakPtr = test;
     196        StrongPtr<DestroyableTest> strongPtr6a = weakPtr;
     197        StrongPtr<DestroyableTest> strongPtr6b(weakPtr);
     198        EXPECT_EQ(test, strongPtr6a.get());
     199        EXPECT_EQ(test, strongPtr6b.get());
     200
     201        // weakPtr other
     202        StrongPtr<Destroyable> strongPtr7a = weakPtr;
     203        StrongPtr<Destroyable> strongPtr7b(weakPtr);
     204        EXPECT_EQ(test, strongPtr7a.get());
     205        EXPECT_EQ(test, strongPtr7b.get());
     206
     207        test->destroy();
     208    }
     209
     210    TEST(StrongPtrTest, TestAssignments)
     211    {
     212        bool bla;
     213        DestroyableTest* test = new DestroyableTest(bla);
     214
     215        // pointer
     216        StrongPtr<DestroyableTest> strongPtr1;
     217        strongPtr1 = test;
     218        EXPECT_EQ(test, strongPtr1.get());
     219
     220        // copy
     221        StrongPtr<DestroyableTest> strongPtr2;
     222        strongPtr2 = strongPtr1;
     223        EXPECT_EQ(test, strongPtr2.get());
     224
     225        // move
     226        StrongPtr<DestroyableTest> strongPtr3;
     227        strongPtr3 = std::move(strongPtr2);
     228        EXPECT_EQ(test, strongPtr3.get());
     229
     230        // other
     231        StrongPtr<Destroyable> strongPtr4;
     232        strongPtr4 = strongPtr3;
     233        EXPECT_EQ(test, strongPtr4.get());
     234
     235        // weakPtr
     236        WeakPtr<DestroyableTest> weakPtr = test;
     237        StrongPtr<DestroyableTest> strongPtr5;
     238        strongPtr5 = weakPtr;
     239        EXPECT_EQ(test, strongPtr5.get());
     240
     241        // weakPtr other
     242        StrongPtr<Destroyable> strongPtr6;
     243        strongPtr6 = weakPtr;
     244        EXPECT_EQ(test, strongPtr6.get());
     245
     246        test->destroy();
     247    }
     248
     249    TEST(StrongPtrTest, TestStrongPtrInVector)
     250    {
     251        bool bla;
     252        DestroyableTest* test = new DestroyableTest(bla);
     253
     254        std::vector<StrongPtr<DestroyableTest>> vector;
     255        vector.push_back(test);
     256        vector.push_back(test);
     257        vector.push_back(test);
     258
     259        ASSERT_EQ(3, vector.size());
     260        EXPECT_EQ(test, vector[0].get());
     261        EXPECT_EQ(test, vector[1].get());
     262        EXPECT_EQ(test, vector[2].get());
     263        EXPECT_EQ(3u, test->getReferenceCount());
     264
     265        vector.clear();
     266        EXPECT_EQ(0u, test->getReferenceCount());
     267
     268        test->destroy();
     269    }
     270
     271    TEST(StrongPtrTest, TestReset)
     272    {
     273        bool bla;
     274        DestroyableTest* test = new DestroyableTest(bla);
     275        StrongPtr<DestroyableTest> strongPtr(test);
     276        EXPECT_EQ(test, strongPtr.get());
     277        EXPECT_EQ(1u, test->getReferenceCount());
     278        strongPtr.reset();
     279        EXPECT_EQ(nullptr, strongPtr.get());
     280        EXPECT_EQ(0u, test->getReferenceCount());
     281
     282        test->destroy();
     283    }
     284
     285    TEST(StrongPtrTest, TestSwap)
     286    {
     287        bool bla;
     288        DestroyableTest* test1 = new DestroyableTest(bla);
     289        DestroyableTest* test2 = new DestroyableTest(bla);
     290
     291        StrongPtr<DestroyableTest> strongPtr1(test1);
     292        StrongPtr<DestroyableTest> strongPtr2(test2);
     293        EXPECT_EQ(test1, strongPtr1.get());
     294        EXPECT_EQ(test2, strongPtr2.get());
     295        EXPECT_EQ(1u, test1->getReferenceCount());
     296        EXPECT_EQ(1u, test2->getReferenceCount());
     297
     298        strongPtr1.swap(strongPtr2);
     299
     300        EXPECT_EQ(test2, strongPtr1.get());
     301        EXPECT_EQ(test1, strongPtr2.get());
     302        EXPECT_EQ(1u, test1->getReferenceCount());
     303        EXPECT_EQ(1u, test2->getReferenceCount());
     304
     305        test1->destroy();
     306        test2->destroy();
     307    }
    143308}

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

    r10624 r11071  
     1#include <utility>
    12#include <gtest/gtest.h>
    23#include <gmock/gmock.h>
    … …  
    2425        WeakPtr<DestroyableTest> weakPtr = test;
    2526        EXPECT_EQ(test, weakPtr.get());
     27        EXPECT_EQ(test, &(*weakPtr));
     28        EXPECT_EQ(static_cast<Destroyable*>(test), weakPtr.getBase());
    2629        test->destroy();
    2730    }
    … …  
    3336        EXPECT_EQ(test, weakPtr.get());
    3437        test->destroy();
    35         EXPECT_EQ(NULL, weakPtr.get());
     38        EXPECT_EQ(nullptr, weakPtr.get());
     39    }
     40
     41    TEST(WeakPtrTest, CanHaveMultiplePointers)
     42    {
     43        DestroyableTest* test = new DestroyableTest();
     44        WeakPtr<DestroyableTest> weakPtr1 = test;
     45        WeakPtr<DestroyableTest> weakPtr2 = test;
     46        WeakPtr<DestroyableTest> weakPtr3 = test;
     47        EXPECT_EQ(test, weakPtr1.get());
     48        EXPECT_EQ(test, weakPtr2.get());
     49        EXPECT_EQ(test, weakPtr3.get());
     50        test->destroy();
     51        EXPECT_EQ(nullptr, weakPtr1.get());
     52        EXPECT_EQ(nullptr, weakPtr2.get());
     53        EXPECT_EQ(nullptr, weakPtr3.get());
    3654    }
    3755
    … …  
    4866    void isNull(const WeakPtr<DestroyableTest> weakPtr)
    4967    {
    50         EXPECT_TRUE(weakPtr == NULL);
    51         EXPECT_TRUE(weakPtr == 0);
     68        EXPECT_TRUE(weakPtr == nullptr);
     69        EXPECT_TRUE(weakPtr == nullptr);
    5270        EXPECT_TRUE(!weakPtr);
    53         EXPECT_FALSE(weakPtr != NULL);
    54         EXPECT_FALSE(weakPtr != 0);
     71        EXPECT_FALSE(weakPtr != nullptr);
     72        EXPECT_FALSE(weakPtr != nullptr);
    5573        EXPECT_FALSE(weakPtr);
    5674    }
    … …  
    6381        }
    6482        {
    65             WeakPtr<DestroyableTest> weakPtr = NULL;
     83            WeakPtr<DestroyableTest> weakPtr = nullptr;
    6684            isNull(weakPtr);
    6785        }
    6886        {
    6987            WeakPtr<DestroyableTest> weakPtr;
    70             weakPtr = NULL;
    71             isNull(weakPtr);
    72         }
    73         {
    74             WeakPtr<DestroyableTest> weakPtr = 0;
     88            weakPtr = nullptr;
     89            isNull(weakPtr);
     90        }
     91        {
     92            WeakPtr<DestroyableTest> weakPtr = nullptr;
    7593            isNull(weakPtr);
    7694        }
    7795        {
    7896            WeakPtr<DestroyableTest> weakPtr;
    79             weakPtr = 0;
     97            weakPtr = nullptr;
    8098            isNull(weakPtr);
    8199        }
    … …  
    86104        DestroyableTest* test = new DestroyableTest();
    87105        WeakPtr<DestroyableTest> weakPtr = test;
    88         EXPECT_FALSE(weakPtr == NULL);
    89         EXPECT_FALSE(weakPtr == 0);
     106        EXPECT_FALSE(weakPtr == nullptr);
     107        EXPECT_FALSE(weakPtr == nullptr);
    90108        EXPECT_FALSE(!weakPtr);
    91         EXPECT_TRUE(weakPtr != NULL);
    92         EXPECT_TRUE(weakPtr != 0);
     109        EXPECT_TRUE(weakPtr != nullptr);
     110        EXPECT_TRUE(weakPtr != nullptr);
    93111        EXPECT_TRUE(weakPtr);
    94112        test->destroy();
    95113    }
     114
     115    TEST(WeakPtrTest, TestConstructors)
     116    {
     117        DestroyableTest* test = new DestroyableTest();
     118
     119        // default
     120        WeakPtr<DestroyableTest> weakPtr1;
     121        EXPECT_EQ(nullptr, weakPtr1.get());
     122
     123        // pointer
     124        WeakPtr<DestroyableTest> weakPtr2a = test;
     125        WeakPtr<DestroyableTest> weakPtr2b(test);
     126        EXPECT_EQ(test, weakPtr2a.get());
     127        EXPECT_EQ(test, weakPtr2b.get());
     128
     129        // copy
     130        WeakPtr<DestroyableTest> weakPtr3a = weakPtr2a;
     131        WeakPtr<DestroyableTest> weakPtr3b(weakPtr2b);
     132        EXPECT_EQ(test, weakPtr3a.get());
     133        EXPECT_EQ(test, weakPtr3b.get());
     134
     135        // move
     136        WeakPtr<DestroyableTest> weakPtr4a = std::move(weakPtr3a);
     137        WeakPtr<DestroyableTest> weakPtr4b(std::move(weakPtr3b));
     138        EXPECT_EQ(test, weakPtr4a.get());
     139        EXPECT_EQ(test, weakPtr4b.get());
     140
     141        // other
     142        WeakPtr<Destroyable> weakPtr5a = weakPtr4a;
     143        WeakPtr<Destroyable> weakPtr5b(weakPtr4b);
     144        EXPECT_EQ(test, weakPtr5a.get());
     145        EXPECT_EQ(test, weakPtr5b.get());
     146
     147        test->destroy();
     148    }
     149
     150    TEST(WeakPtrTest, TestAssignments)
     151    {
     152        DestroyableTest* test = new DestroyableTest();
     153
     154        // pointer
     155        WeakPtr<DestroyableTest> weakPtr1;
     156        weakPtr1 = test;
     157        EXPECT_EQ(test, weakPtr1.get());
     158
     159        // copy
     160        WeakPtr<DestroyableTest> weakPtr2;
     161        weakPtr2 = weakPtr1;
     162        EXPECT_EQ(test, weakPtr2.get());
     163
     164        // move
     165        WeakPtr<DestroyableTest> weakPtr3;
     166        weakPtr3 = std::move(weakPtr2);
     167        EXPECT_EQ(test, weakPtr3.get());
     168
     169        // other
     170        WeakPtr<Destroyable> weakPtr4;
     171        weakPtr4 = weakPtr3;
     172        EXPECT_EQ(test, weakPtr4.get());
     173
     174        test->destroy();
     175    }
     176
     177    TEST(WeakPtrTest, TestWeakPtrInVector)
     178    {
     179        DestroyableTest* test = new DestroyableTest();
     180
     181        std::vector<WeakPtr<DestroyableTest>> vector;
     182        vector.push_back(test);
     183        vector.push_back(test);
     184        vector.push_back(test);
     185
     186        ASSERT_EQ(3, vector.size());
     187        EXPECT_EQ(test, vector[0].get());
     188        EXPECT_EQ(test, vector[1].get());
     189        EXPECT_EQ(test, vector[2].get());
     190
     191        test->destroy();
     192
     193        EXPECT_EQ(nullptr, vector[0].get());
     194        EXPECT_EQ(nullptr, vector[1].get());
     195        EXPECT_EQ(nullptr, vector[2].get());
     196    }
     197
     198    TEST(WeakPtrTest, TestReset)
     199    {
     200        DestroyableTest* test = new DestroyableTest();
     201        WeakPtr<DestroyableTest> weakPtr(test);
     202        EXPECT_EQ(test, weakPtr.get());
     203        weakPtr.reset();
     204        EXPECT_EQ(nullptr, weakPtr.get());
     205
     206        test->destroy();
     207    }
     208
     209    TEST(WeakPtrTest, TestSwap)
     210    {
     211        DestroyableTest* test1 = new DestroyableTest();
     212        DestroyableTest* test2 = new DestroyableTest();
     213
     214        WeakPtr<DestroyableTest> weakPtr1(test1);
     215        WeakPtr<DestroyableTest> weakPtr2(test2);
     216        EXPECT_EQ(test1, weakPtr1.get());
     217        EXPECT_EQ(test2, weakPtr2.get());
     218
     219        weakPtr1.swap(weakPtr2);
     220
     221        EXPECT_EQ(test2, weakPtr1.get());
     222        EXPECT_EQ(test1, weakPtr2.get());
     223
     224        test1->destroy();
     225        test2->destroy();
     226    }
    96227}

  • code/trunk/test/core/singleton/ScopeTest.cc

    r10544 r11071  
    2626        {
    2727            public:
    28                 virtual void SetUp()
     28                virtual void SetUp() override
    2929                {
    3030                    new IdentifierManager();
    … …  
    3232                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    3333                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::SCOPED_SINGLETON_WRAPPER);
    34                     Context::setRootContext(new Context(NULL));
     34                    Context::setRootContext(new Context(nullptr));
    3535                }
    3636
    37                 virtual void TearDown()
     37                virtual void TearDown() override
    3838                {
    3939                    Context::destroyRootContext();
Note: See TracChangeset for help on using the changeset viewer.