Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 11071 for code/trunk/test


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:
36 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();

  • code/trunk/test/core_plugin/PluginTest.cc

    r11013 r11071  
    2323                PluginTest()
    2424                {
    25                     this->plugin_ = NULL;
     25                    this->plugin_ = nullptr;
    2626                }
    2727
    … …  
    4444                {
    4545                    delete this->plugin_;
    46                     this->plugin_ = NULL;
    47                 }
    48 
    49                 virtual void TearDown()
     46                    this->plugin_ = nullptr;
     47                }
     48
     49                virtual void TearDown() override
    5050                {
    5151                    // make sure the plugin is unloaded
    … …  
    7777    TEST_F(PluginTest, LoadsIdentifier)
    7878    {
    79         EXPECT_TRUE(getIdentifier() == NULL);
    80         this->loadPlugin();
    81         EXPECT_TRUE(getIdentifier() != NULL);
     79        EXPECT_TRUE(getIdentifier() == nullptr);
     80        this->loadPlugin();
     81        EXPECT_TRUE(getIdentifier() != nullptr);
    8282        this->unloadPlugin();
    8383    }
    … …  
    8686    {
    8787        this->loadPlugin();
    88         EXPECT_TRUE(getIdentifier() != NULL);
    89         this->unloadPlugin();
    90         EXPECT_TRUE(getIdentifier() == NULL);
     88        EXPECT_TRUE(getIdentifier() != nullptr);
     89        this->unloadPlugin();
     90        EXPECT_TRUE(getIdentifier() == nullptr);
    9191    }
    9292
    … …  
    9494    {
    9595        this->loadPlugin();
    96         EXPECT_TRUE(getIdentifier() != NULL);
    97         this->unloadPlugin();
    98         EXPECT_TRUE(getIdentifier() == NULL);
    99         this->loadPlugin();
    100         EXPECT_TRUE(getIdentifier() != NULL);
     96        EXPECT_TRUE(getIdentifier() != nullptr);
     97        this->unloadPlugin();
     98        EXPECT_TRUE(getIdentifier() == nullptr);
     99        this->loadPlugin();
     100        EXPECT_TRUE(getIdentifier() != nullptr);
    101101        this->unloadPlugin();
    102102    }
    … …  
    107107
    108108        Identifier* identifier = getIdentifier();
    109         ASSERT_TRUE(identifier != NULL);
    110 
    111         Identifiable* object = identifier->fabricate(NULL);
    112         ASSERT_TRUE(object != NULL);
     109        ASSERT_TRUE(identifier != nullptr);
     110
     111        Identifiable* object = identifier->fabricate(nullptr);
     112        ASSERT_TRUE(object != nullptr);
    113113
    114114        Testclass* testclass = orxonox_cast<Testclass*>(object);
    115         ASSERT_TRUE(testclass != NULL);
     115        ASSERT_TRUE(testclass != nullptr);
    116116
    117117        EXPECT_EQ(666, testclass->getValue());
    … …  
    131131        std::vector<Testsingleton*> singletons;
    132132
    133         for (ObjectList<Listable>::iterator it = ObjectList<Listable>::begin(); it; ++it)
    134         {
    135             Testsingleton* singleton = dynamic_cast<Testsingleton*>(*it);
     133        for (Listable* listable : ObjectList<Listable>())
     134        {
     135            Testsingleton* singleton = dynamic_cast<Testsingleton*>(listable);
    136136            if (singleton)
    137137                singletons.push_back(singleton);
    … …  
    141141        {
    142142            case 0:
    143                 return NULL;
     143                return nullptr;
    144144            case 1:
    145145                return singletons[0];
    … …  
    151151    TEST_F(PluginTest, LoadsSingleton)
    152152    {
    153         EXPECT_TRUE(getSingleton() == NULL);
    154         this->loadPlugin();
    155         EXPECT_TRUE(getSingleton() != NULL);
     153        EXPECT_TRUE(getSingleton() == nullptr);
     154        this->loadPlugin();
     155        EXPECT_TRUE(getSingleton() != nullptr);
    156156        this->unloadPlugin();
    157157    }
    … …  
    160160    {
    161161        this->loadPlugin();
    162         EXPECT_TRUE(getSingleton() != NULL);
    163         this->unloadPlugin();
    164         EXPECT_TRUE(getSingleton() == NULL);
     162        EXPECT_TRUE(getSingleton() != nullptr);
     163        this->unloadPlugin();
     164        EXPECT_TRUE(getSingleton() == nullptr);
    165165    }
    166166
    … …  
    168168    {
    169169        this->loadPlugin();
    170         EXPECT_TRUE(getSingleton() != NULL);
    171         this->unloadPlugin();
    172         EXPECT_TRUE(getSingleton() == NULL);
    173         this->loadPlugin();
    174         EXPECT_TRUE(getSingleton() != NULL);
     170        EXPECT_TRUE(getSingleton() != nullptr);
     171        this->unloadPlugin();
     172        EXPECT_TRUE(getSingleton() == nullptr);
     173        this->loadPlugin();
     174        EXPECT_TRUE(getSingleton() != nullptr);
    175175        this->unloadPlugin();
    176176    }
    … …  
    181181
    182182        Testsingleton* singleton = getSingleton();
    183         ASSERT_TRUE(singleton != NULL);
     183        ASSERT_TRUE(singleton != nullptr);
    184184
    185185        EXPECT_EQ(999, singleton->getValue());
    … …  
    255255    TEST_F(PluginTest, LoadsConsoleCommand)
    256256    {
    257         EXPECT_TRUE(getConsoleCommand() == NULL);
    258         this->loadPlugin();
    259         EXPECT_TRUE(getConsoleCommand() != NULL);
     257        EXPECT_TRUE(getConsoleCommand() == nullptr);
     258        this->loadPlugin();
     259        EXPECT_TRUE(getConsoleCommand() != nullptr);
    260260        this->unloadPlugin();
    261261    }
    … …  
    264264    {
    265265        this->loadPlugin();
    266         EXPECT_TRUE(getConsoleCommand() != NULL);
    267         this->unloadPlugin();
    268         EXPECT_TRUE(getConsoleCommand() == NULL);
     266        EXPECT_TRUE(getConsoleCommand() != nullptr);
     267        this->unloadPlugin();
     268        EXPECT_TRUE(getConsoleCommand() == nullptr);
    269269    }
    270270
    … …  
    272272    {
    273273        this->loadPlugin();
    274         EXPECT_TRUE(getConsoleCommand() != NULL);
    275         this->unloadPlugin();
    276         EXPECT_TRUE(getConsoleCommand() == NULL);
    277         this->loadPlugin();
    278         EXPECT_TRUE(getConsoleCommand() != NULL);
     274        EXPECT_TRUE(getConsoleCommand() != nullptr);
     275        this->unloadPlugin();
     276        EXPECT_TRUE(getConsoleCommand() == nullptr);
     277        this->loadPlugin();
     278        EXPECT_TRUE(getConsoleCommand() != nullptr);
    279279        this->unloadPlugin();
    280280    }
    … …  
    285285
    286286        ConsoleCommand* command = getConsoleCommand();
    287         ASSERT_TRUE(command != NULL);
     287        ASSERT_TRUE(command != nullptr);
    288288
    289289        EXPECT_EQ(999, (*command->getExecutor())(333, 666).get<int>());

  • code/trunk/test/util/MathTest.cc

    r11052 r11071  
    245245
    246246        // all numbers must satisfy 0 <= <number> < 1
    247         for (std::set<float>::iterator it = numbers.begin(); it != numbers.end(); ++it)
     247        for (float number : numbers)
    248248        {
    249             EXPECT_LE(min, *it);
    250             EXPECT_GT(max, *it);
     249            EXPECT_LE(min, number);
     250            EXPECT_GT(max, number);
    251251        }
    252252    }
    … …  
    268268
    269269        // all numbers must satisfy 0 <= <number> < <max>
    270         for (std::set<float>::iterator it = numbers.begin(); it != numbers.end(); ++it)
     270        for (float number : numbers)
    271271        {
    272             EXPECT_LE(min, *it);
    273             EXPECT_GT(max, *it);
     272            EXPECT_LE(min, number);
     273            EXPECT_GT(max, number);
    274274        }
    275275    }
    … …  
    291291
    292292        // all numbers must satisfy <min> <= <number> < <max>
    293         for (std::set<float>::iterator it = numbers.begin(); it != numbers.end(); ++it)
     293        for (float number : numbers)
    294294        {
    295             EXPECT_LE(min, *it);
    296             EXPECT_GT(max, *it);
     295            EXPECT_LE(min, number);
     296            EXPECT_GT(max, number);
    297297        }
    298298    }
    … …  
    315315
    316316        // all numbers must be either 1 oder -1
    317         for (std::set<float>::iterator it = numbers.begin(); it != numbers.end(); ++it)
    318             EXPECT_TRUE(*it == 1 || *it == -1);
     317        for (float number : numbers)
     318            EXPECT_TRUE(number == 1 || number == -1);
    319319    }
    320320

  • code/trunk/test/util/MultiTypeTest.cc

    r10197 r11071  
    697697        EXPECT_TRUE(mt.null());
    698698    }
     699
     700    ///////////////////////////////
     701    // Strongly typed enum class //
     702    ///////////////////////////////
     703    enum class EnumWithChar : unsigned char
     704    {
     705        ValueA = 'A',
     706        ValueB = 'B',
     707        ValueC = 'C',
     708    };
     709    enum class EnumWithInt
     710    {
     711        Value1 = 50,
     712        Value2 = 0,
     713        Value3,
     714    };
     715
     716    TEST(MultiType, Enum_Constructor)
     717    {
     718        // Constructor:
     719        {
     720            MultiType mt = EnumWithChar::ValueA;
     721
     722            EXPECT_TRUE(mt.isType<EnumWithChar>());
     723            EXPECT_EQ(EnumWithChar::ValueA, mt.get<EnumWithChar>());
     724        }
     725        {
     726            MultiType mt = MultiType(EnumWithInt::Value1);
     727
     728            EXPECT_TRUE(mt.isType<EnumWithInt>());
     729            EXPECT_EQ(EnumWithInt::Value1, mt.get<EnumWithInt>());
     730        }
     731    }
     732
     733    TEST(MultiType, Enum_Assignment)
     734    {
     735        // operator=:
     736        MultiType mt;
     737        mt = EnumWithChar::ValueB;
     738
     739        EXPECT_TRUE(mt.isType<EnumWithChar>());
     740        EXPECT_EQ(EnumWithChar::ValueB, mt.get<EnumWithChar>());
     741    }
     742
     743    TEST(MultiType, Enum_Set)
     744    {
     745        // set(value):
     746        {
     747            MultiType mt;
     748            mt.set(EnumWithInt::Value2); // assign enum to an empty MultiType
     749
     750            EXPECT_TRUE(mt.isType<EnumWithInt>());
     751            EXPECT_EQ(EnumWithInt::Value2, mt.get<EnumWithInt>());
     752        }
     753        {
     754            MultiType mt = "string";
     755            mt.set(EnumWithChar::ValueC); // assign enum to a MultiType with type std::string
     756
     757            EXPECT_TRUE(mt.isType<std::string>());
     758            EXPECT_EQ("C", mt.get<std::string>());
     759        }
     760        {
     761            MultiType mt = EnumWithChar::ValueA;
     762            mt.set(EnumWithChar::ValueB); // assign enum to a MultiType with type std::string
     763
     764            EXPECT_TRUE(mt.isType<EnumWithChar>());
     765            EXPECT_EQ(EnumWithChar::ValueB, mt.get<EnumWithChar>());
     766        }
     767        {
     768            MultiType mt = EnumWithInt::Value3;
     769            mt.set("50"); // assign enum to a MultiType with type std::string
     770
     771            EXPECT_TRUE(mt.isType<EnumWithInt>());
     772            EXPECT_EQ(EnumWithInt::Value1, mt.get<EnumWithInt>());
     773        }
     774    }
     775
     776    TEST(MultiType, Enum_Force)
     777    {
     778        // force(value):
     779        {
     780            MultiType mt = "string";
     781            EXPECT_TRUE(mt.isType<std::string>());
     782            EXPECT_EQ("string", mt.get<std::string>());
     783
     784            mt.force<EnumWithChar>("C");
     785
     786            EXPECT_TRUE(mt.isType<EnumWithChar>());
     787            EXPECT_EQ(EnumWithChar::ValueC, mt.get<EnumWithChar>());
     788        }
     789        {
     790            MultiType mt = EnumWithChar::ValueA;
     791            EXPECT_TRUE(mt.isType<EnumWithChar>());
     792            EXPECT_EQ(EnumWithChar::ValueA, mt.get<EnumWithChar>());
     793
     794            mt.force<std::string>(EnumWithChar::ValueB);
     795
     796            EXPECT_TRUE(mt.isType<std::string>());
     797            EXPECT_EQ("B", mt.get<std::string>());
     798        }
     799    }
     800
     801    TEST(MultiType, Enum_Convert)
     802    {
     803        // convert():
     804        {
     805            MultiType mt = "C";
     806            mt.convert<EnumWithChar>();
     807
     808            EXPECT_TRUE(mt.isType<EnumWithChar>());
     809            EXPECT_EQ(EnumWithChar::ValueC, mt.get<EnumWithChar>());
     810        }
     811        {
     812            MultiType mt = EnumWithChar::ValueA;
     813            mt.convert<std::string>();
     814
     815            EXPECT_TRUE(mt.isType<std::string>());
     816            EXPECT_EQ("A", mt.get<std::string>());
     817        }
     818    }
     819
     820    TEST(MultiType, Enum_Reset)
     821    {
     822        // reset():
     823        {
     824            MultiType mt = EnumWithChar::ValueA;
     825            mt.reset<EnumWithChar>();
     826
     827            EXPECT_TRUE(mt.isType<EnumWithChar>());
     828            EXPECT_TRUE(mt.isType<unsigned char>());
     829            EXPECT_EQ('\0', mt.get<unsigned char>());
     830        }
     831        {
     832            MultiType mt = "string";
     833            mt.reset<EnumWithInt>();
     834
     835            EXPECT_TRUE(mt.isType<EnumWithInt>());
     836            EXPECT_TRUE(mt.isType<int>());
     837            EXPECT_EQ(0, mt.get<int>());
     838        }
     839    }
     840
     841    TEST(MultiType, Enum_IsType)
     842    {
     843        // isType():
     844        {
     845            MultiType mt = EnumWithChar::ValueB;
     846            EXPECT_TRUE(mt.isType<EnumWithChar>());
     847            EXPECT_TRUE(mt.isType<unsigned char>());
     848            EXPECT_FALSE(mt.isType<char>());
     849            EXPECT_FALSE(mt.isType<int>());
     850            EXPECT_FALSE(mt.isType<bool>());
     851            EXPECT_FALSE(mt.isType<std::string>());
     852        }
     853        {
     854            MultiType mt = EnumWithInt::Value3;
     855            EXPECT_TRUE(mt.isType<EnumWithInt>());
     856            EXPECT_TRUE(mt.isType<int>());
     857            EXPECT_FALSE(mt.isType<unsigned char>());
     858            EXPECT_FALSE(mt.isType<char>());
     859            EXPECT_FALSE(mt.isType<bool>());
     860            EXPECT_FALSE(mt.isType<std::string>());
     861        }
     862    }
     863
     864    TEST(MultiType, Enum_ConversionOperator)
     865    {
     866        // conversion operator:
     867        {
     868            MultiType mt = EnumWithChar::ValueA;
     869            EnumWithChar value = mt;
     870            EXPECT_EQ(EnumWithChar::ValueA, value);
     871        }
     872        {
     873            MultiType mt = 'B';
     874            EnumWithChar value = mt;
     875            EXPECT_EQ(EnumWithChar::ValueB, value);
     876        }
     877        {
     878            MultiType mt = EnumWithInt::Value1;
     879            std::string value = mt;
     880            EXPECT_EQ("50", value);
     881        }
     882    }
     883
     884    TEST(MultiType, Enum_GetValue)
     885    {
     886        // getValue():
     887        {
     888            MultiType mt = EnumWithChar::ValueA;
     889            EnumWithChar value;
     890            mt.getValue(&value);
     891            EXPECT_EQ(EnumWithChar::ValueA, value);
     892        }
     893        {
     894            MultiType mt = 'B';
     895            EnumWithChar value;
     896            mt.getValue(&value);
     897            EXPECT_EQ(EnumWithChar::ValueB, value);
     898        }
     899        {
     900            MultiType mt = EnumWithInt::Value1;
     901            std::string value;
     902            mt.getValue(&value);
     903            EXPECT_EQ("50", value);
     904        }
     905    }
     906
     907    TEST(MultiType, Enum_Get)
     908    {
     909        // get():
     910        {
     911            MultiType mt = EnumWithChar::ValueB;
     912            EXPECT_EQ(EnumWithChar::ValueB, mt.get<EnumWithChar>());
     913
     914            EXPECT_EQ('B', mt.get<unsigned char>());
     915            EXPECT_EQ("B", mt.get<std::string>());
     916            EXPECT_EQ(66, mt.get<int>());
     917            EXPECT_TRUE(mt.get<bool>());
     918        }
     919        {
     920            MultiType mt = EnumWithInt::Value1;
     921            EXPECT_EQ(EnumWithInt::Value1, mt.get<EnumWithInt>());
     922
     923            EXPECT_EQ('2', mt.get<unsigned char>());
     924            EXPECT_EQ("50", mt.get<std::string>());
     925            EXPECT_EQ(50, mt.get<int>());
     926            EXPECT_TRUE(mt.get<bool>());
     927        }
     928        {
     929            MultiType mt = EnumWithInt::Value2;
     930            EXPECT_EQ(EnumWithInt::Value2, mt.get<EnumWithInt>());
     931
     932            EXPECT_EQ('\0', mt.get<unsigned char>());
     933            EXPECT_EQ("0", mt.get<std::string>());
     934            EXPECT_EQ(0, mt.get<int>());
     935            EXPECT_FALSE(mt.get<bool>());
     936        }
     937    }
    699938}

  • code/trunk/test/util/SharedPtrTest.cc

    r9114 r11071  
     1#include <memory>
     2#include <utility>
    13#include <gtest/gtest.h>
    24#include <gmock/gmock.h>
    3 #include "util/SharedPtr.h"
    45
    56namespace orxonox
    … …  
    2728        };
    2829
    29         class TestClassMock : public TestClass
     30        class TestChildClassMock : public TestChildClass
    3031        {
    3132            public:
    32                 TestClassMock() {}
    33                 ~TestClassMock() { objectDestroyed(); }
     33                TestChildClassMock() {}
     34                ~TestChildClassMock() { objectDestroyed(); }
    3435
    3536                MOCK_METHOD0(objectDestroyed, void());
    … …  
    3940    TEST(SharedPtr, ConstructorDefault)
    4041    {
    41         SharedPtr<TestClass> test;
    42         EXPECT_EQ(0, test.get());
     42        std::shared_ptr<TestClass> test;
     43        EXPECT_EQ(nullptr, test.get());
    4344    }
    4445
    … …  
    4748        TestClass* pointer = new TestClass();
    4849
    49         SharedPtr<TestClass> test = pointer;
    50         EXPECT_EQ(pointer, test.get());
     50        std::shared_ptr<TestClass> test(pointer);
     51        EXPECT_EQ(pointer, test.get());
     52        EXPECT_EQ(pointer, &(*test));
    5153    }
    5254
    … …  
    5557        TestChildClass* pointer = new TestChildClass();
    5658
    57         SharedPtr<TestClass> test = pointer;
     59        std::shared_ptr<TestClass> test(pointer);
    5860        EXPECT_EQ(pointer, test.get());
    5961    }
    … …  
    6365        TestClass* pointer = new TestClass();
    6466
    65         SharedPtr<TestClass> other = pointer;
    66         EXPECT_EQ(pointer, other.get());
    67 
    68         SharedPtr<TestClass> test = other;
     67        std::shared_ptr<TestClass> other(pointer);
     68        EXPECT_EQ(pointer, other.get());
     69
     70        std::shared_ptr<TestClass> test = other;
    6971        EXPECT_EQ(pointer, test.get());
    7072    }
    … …  
    7476        TestChildClass* pointer = new TestChildClass();
    7577
    76         SharedPtr<TestChildClass> other = pointer;
    77         EXPECT_EQ(pointer, other.get());
    78 
    79         SharedPtr<TestClass> test = other;
     78        std::shared_ptr<TestChildClass> other(pointer);
     79        EXPECT_EQ(pointer, other.get());
     80
     81        std::shared_ptr<TestClass> test = other;
    8082        EXPECT_EQ(pointer, test.get());
    8183    }
    … …  
    8587        TestClass* pointer = new TestClass();
    8688
    87         SharedPtr<TestClass> other = pointer;
    88         EXPECT_EQ(pointer, other.get());
    89 
    90         SharedPtr<TestClass> test;
    91         EXPECT_EQ(0, test.get());
     89        std::shared_ptr<TestClass> other(pointer);
     90        EXPECT_EQ(pointer, other.get());
     91
     92        std::shared_ptr<TestClass> test;
     93        EXPECT_EQ(nullptr, test.get());
    9294
    9395        test = other;
    … …  
    99101        TestChildClass* pointer = new TestChildClass();
    100102
    101         SharedPtr<TestChildClass> other = pointer;
    102         EXPECT_EQ(pointer, other.get());
    103 
    104         SharedPtr<TestClass> test;
    105         EXPECT_EQ(0, test.get());
     103        std::shared_ptr<TestChildClass> other(pointer);
     104        EXPECT_EQ(pointer, other.get());
     105
     106        std::shared_ptr<TestClass> test;
     107        EXPECT_EQ(nullptr, test.get());
    106108
    107109        test = other;
    … …  
    113115        TestChildClass* pointer = new TestChildClass();
    114116
    115         SharedPtr<TestChildClass> other = pointer;
    116         EXPECT_EQ(pointer, other.get());
    117 
    118         SharedPtr<TestClass> test = other.cast<TestClass>();
     117        std::shared_ptr<TestChildClass> other(pointer);
     118        EXPECT_EQ(pointer, other.get());
     119
     120        std::shared_ptr<TestClass> test = std::static_pointer_cast<TestClass>(other);
    119121        EXPECT_EQ(pointer, test.get());
    120122    }
    … …  
    124126        TestClass* pointer = new TestClass();
    125127
    126         SharedPtr<TestClass> test = pointer;
     128        std::shared_ptr<TestClass> test(pointer);
    127129        EXPECT_EQ(pointer, test.get());
    128130
    … …  
    135137    TEST(SharedPtr, Boolean)
    136138    {
    137         SharedPtr<TestClass> test;
    138         EXPECT_EQ(0, test.get());
     139        std::shared_ptr<TestClass> test;
     140        EXPECT_EQ(nullptr, test.get());
    139141        EXPECT_FALSE(test);
    140142
    141143        TestClass* pointer = new TestClass();
    142144
    143         test = pointer;
    144         EXPECT_EQ(pointer, test.get());
    145         EXPECT_TRUE(test);
     145        test.reset(pointer);
     146        EXPECT_EQ(pointer, test.get());
     147        EXPECT_TRUE(static_cast<bool>(test));
    146148    }
    147149
    … …  
    151153        TestClass* pointer2 = new TestClass();
    152154
    153         SharedPtr<TestClass> test1 = pointer1;
    154         SharedPtr<TestClass> test2 = pointer2;
     155        std::shared_ptr<TestClass> test1(pointer1);
     156        std::shared_ptr<TestClass> test2(pointer2);
    155157
    156158        EXPECT_EQ(pointer1, test1.get());
    … …  
    165167    TEST(SharedPtr, ObjectDestroyedOnePointer)
    166168    {
    167         TestClassMock* pointer = new TestClassMock();
    168         SharedPtr<TestClass> test = pointer;
     169        TestChildClassMock* pointer = new TestChildClassMock();
     170        std::shared_ptr<TestClass> test(pointer);
    169171
    170172        EXPECT_CALL(*pointer, objectDestroyed()).Times(1);
    … …  
    173175    TEST(SharedPtr, ObjectDestroyedManyPointers)
    174176    {
    175         TestClassMock* pointer = new TestClassMock();
    176 
    177         SharedPtr<TestClass> test = pointer;
    178         std::vector<SharedPtr<TestClass> > tests;
     177        TestChildClassMock* pointer = new TestChildClassMock();
     178
     179        std::shared_ptr<TestClass> test(pointer);
     180        std::vector<std::shared_ptr<TestClass>> tests;
    179181        for (size_t i = 0; i < 100; ++i)
    180             tests.push_back(SharedPtr<TestClass>(test));
     182            tests.push_back(std::shared_ptr<TestClass>(test));
     183
     184        EXPECT_CALL(*pointer, objectDestroyed()).Times(1);
     185    }
     186
     187    TEST(SharedPtr, TestConstructors)
     188    {
     189        {
     190        TestChildClassMock* pointer = new TestChildClassMock();
     191
     192        // default
     193        std::shared_ptr<TestChildClass> sharedPtr1;
     194        EXPECT_EQ(nullptr, sharedPtr1.get());
     195
     196        // pointer
     197        std::shared_ptr<TestChildClass> sharedPtr2(pointer);
     198        EXPECT_EQ(pointer, sharedPtr2.get());
     199
     200        // copy
     201        std::shared_ptr<TestChildClass> sharedPtr3(sharedPtr2);
     202        EXPECT_EQ(pointer, sharedPtr3.get());
     203
     204        // move
     205        std::shared_ptr<TestChildClass> sharedPtr4(std::move(sharedPtr3));
     206        EXPECT_EQ(pointer, sharedPtr4.get());
     207
     208        // other
     209        std::shared_ptr<TestClass> sharedPtr5(sharedPtr4);
     210        EXPECT_EQ(pointer, sharedPtr5.get());
     211
     212        EXPECT_CALL(*pointer, objectDestroyed()).Times(1);
     213        }
     214    }
     215
     216    TEST(SharedPtr, TestConstructors2)
     217    {
     218        {
     219        TestChildClassMock* pointer = new TestChildClassMock();
     220
     221        // default
     222        std::shared_ptr<TestChildClass> sharedPtr1;
     223        EXPECT_EQ(nullptr, sharedPtr1.get());
     224
     225        // pointer
     226        std::shared_ptr<TestChildClass> sharedPtr2(pointer);
     227        EXPECT_EQ(pointer, sharedPtr2.get());
     228
     229        // copy
     230        std::shared_ptr<TestChildClass> sharedPtr3 = sharedPtr2;
     231        EXPECT_EQ(pointer, sharedPtr3.get());
     232
     233        // move
     234        std::shared_ptr<TestChildClass> sharedPtr4 = std::move(sharedPtr3);
     235        EXPECT_EQ(pointer, sharedPtr4.get());
     236
     237        // other
     238        std::shared_ptr<TestClass> sharedPtr5 = sharedPtr4;
     239        EXPECT_EQ(pointer, sharedPtr5.get());
     240
     241        EXPECT_CALL(*pointer, objectDestroyed()).Times(1);
     242        }
     243    }
     244
     245    TEST(SharedPtr, TestAssignments)
     246    {
     247        TestChildClassMock* pointer = new TestChildClassMock();
     248
     249        std::shared_ptr<TestChildClass> sharedPtr1(pointer);
     250        EXPECT_EQ(pointer, sharedPtr1.get());
     251
     252        // copy
     253        std::shared_ptr<TestChildClass> sharedPtr2;
     254        sharedPtr2 = sharedPtr1;
     255        EXPECT_EQ(pointer, sharedPtr2.get());
     256
     257        // move
     258        std::shared_ptr<TestChildClass> sharedPtr3;
     259        sharedPtr3 = std::move(sharedPtr2);
     260        EXPECT_EQ(pointer, sharedPtr3.get());
     261
     262        // other
     263        std::shared_ptr<TestClass> sharedPtr4;
     264        sharedPtr4 = sharedPtr3;
     265        EXPECT_EQ(pointer, sharedPtr4.get());
    181266
    182267        EXPECT_CALL(*pointer, objectDestroyed()).Times(1);

  • code/trunk/test/util/SingletonTest.cc

    r9114 r11071  
    2323        };
    2424
    25         TestSingleton* TestSingleton::singletonPtr_s = NULL;
     25        TestSingleton* TestSingleton::singletonPtr_s = nullptr;
    2626        const size_t TestSingleton::MAGIC_VALUE = 0xCAFEBABE;
    2727    }

  • code/trunk/test/util/SmallObjectAllocatorTest.cc

    r9114 r11071  
    4747        // create an integer
    4848        size_t* pointer = this->create(5);
    49         ASSERT_NE((void*)0, pointer);
     49        ASSERT_NE((void*)nullptr, pointer);
    5050        EXPECT_EQ(5u, *pointer);
    5151    }
    … …  
    5555        // create an integer
    5656        size_t* pointer = this->create(5);
    57         ASSERT_NE((void*)0, pointer);
     57        ASSERT_NE((void*)nullptr, pointer);
    5858        EXPECT_EQ(5u, *pointer);
    5959
    … …  
    228228        // create an object
    229229        SmallObject* pointer = this->create(5);
    230         ASSERT_NE((void*)0, pointer);
     230        ASSERT_NE((void*)nullptr, pointer);
    231231        EXPECT_EQ(5u, pointer->getValue());
    232232        EXPECT_EQ(5u, SmallObject::total_s);
    … …  
    239239        // create an object
    240240        SmallObject* pointer = this->create(5);
    241         ASSERT_NE((void*)0, pointer);
     241        ASSERT_NE((void*)nullptr, pointer);
    242242        EXPECT_EQ(5u, pointer->getValue());
    243243        EXPECT_EQ(5u, SmallObject::total_s);

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

    r9545 r11071  
    3030                MOCK_METHOD2(printLine, void(const std::string&, OutputLevel));
    3131
    32                 virtual void output(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines)
     32                virtual void output(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines) override
    3333                    { this->BaseWriter::output(level, context, lines); }
    3434        };

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

    r10712 r11071  
    33#include "util/output/ConsoleWriter.h"
    44#include "util/output/OutputManager.h"
    5 #include "util/SharedPtr.h"
    65
    76namespace orxonox
    … …  
    1312        {
    1413            public:
    15                 virtual void SetUp()
     14                virtual void SetUp() override
    1615                {
    1716                    // reset output manager
    18                     OutputManager::Testing::getInstancePointer() = new OutputManager();
     17                    OutputManager::Testing::getInstancePointer().reset(new OutputManager());
    1918                }
    2019
    21                 virtual void TearDown()
     20                virtual void TearDown() override
    2221                {
    2322                }
    … …  
    2726    TEST_F(ConsoleWriterTest, Disable)
    2827    {
    29         std::ostream stream(NULL);
     28        std::ostream stream(nullptr);
    3029        EXPECT_EQ(0U, OutputManager::getInstance().getListeners().size());
    3130        ConsoleWriter writer(stream);
    … …  
    3736    TEST_F(ConsoleWriterTest, Enable)
    3837    {
    39         std::ostream stream(NULL);
     38        std::ostream stream(nullptr);
    4039        ConsoleWriter writer(stream);
    4140        writer.disable();

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

    r10624 r11071  
    44#include "util/Convert.h"
    55#include "util/output/OutputManager.h"
    6 #include "util/SharedPtr.h"
    76
    87namespace orxonox
    … …  
    1312        {
    1413            public:
    15                 virtual void printLine(const std::string& line, OutputLevel level)
     14                virtual void printLine(const std::string& line, OutputLevel level) override
    1615                    { this->LogWriter::printLine(line, level); }
    1716        };
    … …  
    2120        {
    2221            public:
    23                 virtual void SetUp()
     22                virtual void SetUp() override
    2423                {
    2524                    // reset output manager
    26                     OutputManager::Testing::getInstancePointer() = new OutputManager();
     25                    OutputManager::Testing::getInstancePointer().reset(new OutputManager());
    2726                }
    2827
    29                 virtual void TearDown()
     28                virtual void TearDown() override
    3029                {
    3130                }
    … …  
    138137        std::string line = getLineWhichContains(path, "myothertestoutput");
    139138        EXPECT_FALSE(line.empty());
     139        ASSERT_TRUE(line.length() > 12);
     140
    140141        EXPECT_TRUE(isdigit(line[0]));
    141142        EXPECT_TRUE(isdigit(line[1]));
    … …  
    146147        EXPECT_TRUE(isdigit(line[6]));
    147148        EXPECT_TRUE(isdigit(line[7]));
    148         EXPECT_EQ(' ', line[8]);
     149        EXPECT_EQ(':', line[8]);
     150        EXPECT_TRUE(isdigit(line[9]));
     151        EXPECT_TRUE(isdigit(line[10]));
     152        EXPECT_TRUE(isdigit(line[11]));
     153        EXPECT_EQ(' ', line[12]);
    149154    }
    150155

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

    r10624 r11071  
    44#include "util/output/MemoryWriter.h"
    55#include "util/output/OutputManager.h"
    6 #include "util/SharedPtr.h"
    76
    87namespace orxonox
    … …  
    2019        {
    2120            public:
    22                 virtual void SetUp()
     21                virtual void SetUp() override
    2322                {
    2423                    // reset output manager
    25                     OutputManager::Testing::getInstancePointer() = new OutputManager();
     24                    OutputManager::Testing::getInstancePointer().reset(new OutputManager());
    2625                }
    2726
    28                 virtual void TearDown()
     27                virtual void TearDown() override
    2928                {
    3029                }

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

    r9545 r11071  
    33#include "util/output/OutputListener.h"
    44#include "util/output/OutputManager.h"
    5 #include "util/SharedPtr.h"
    65
    76namespace orxonox
    … …  
    342341            {
    343342                this->manager_ = new MockOutputManager();
    344                 OutputManager::Testing::getInstancePointer() = this->manager_;
     343                OutputManager::Testing::getInstancePointer().reset(this->manager_);
    345344            }
    346345
    347346            virtual void TearDown()
    348347            {
    349                 OutputManager::Testing::getInstancePointer() = new OutputManager();
     348                OutputManager::Testing::getInstancePointer().reset(new OutputManager());
    350349            }
    351350

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

    r10624 r11071  
    5454    TEST(OutputManagerTest, GetInstanceDoesNotCreateDefaultListeners)
    5555    {
    56         EXPECT_TRUE(NULL == OutputManager::getInstance().getMemoryWriter());
    57         EXPECT_TRUE(NULL == OutputManager::getInstance().getConsoleWriter());
    58         EXPECT_TRUE(NULL == OutputManager::getInstance().getLogWriter());
     56        EXPECT_TRUE(nullptr == OutputManager::getInstance().getMemoryWriter());
     57        EXPECT_TRUE(nullptr == OutputManager::getInstance().getConsoleWriter());
     58        EXPECT_TRUE(nullptr == OutputManager::getInstance().getLogWriter());
    5959    }
    6060
    … …  
    6262    TEST(OutputManagerTest, GetInstanceAndCreateListenersCreatesDefaultListeners)
    6363    {
    64         EXPECT_TRUE(NULL != OutputManager::getInstanceAndCreateListeners().getMemoryWriter());
    65         EXPECT_TRUE(NULL != OutputManager::getInstanceAndCreateListeners().getConsoleWriter());
    66         EXPECT_TRUE(NULL != OutputManager::getInstanceAndCreateListeners().getLogWriter());
     64        EXPECT_TRUE(nullptr != OutputManager::getInstanceAndCreateListeners().getMemoryWriter());
     65        EXPECT_TRUE(nullptr != OutputManager::getInstanceAndCreateListeners().getConsoleWriter());
     66        EXPECT_TRUE(nullptr != OutputManager::getInstanceAndCreateListeners().getLogWriter());
    6767    }
    6868

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

    r9547 r11071  
    88#include "util/output/OutputManager.h"
    99#include "util/output/MemoryWriter.h"
    10 #include "util/SharedPtr.h"
    1110
    1211namespace orxonox
    … …  
    8887            {
    8988                this->manager_ = new MockOutputManager();
    90                 OutputManager::Testing::getInstancePointer() = this->manager_;
     89                OutputManager::Testing::getInstancePointer().reset(this->manager_);
    9190            }
    9291
    9392            virtual void TearDown()
    9493            {
    95                 OutputManager::Testing::getInstancePointer() = new OutputManager();
     94                OutputManager::Testing::getInstancePointer().reset(new OutputManager());
    9695            }
    9796
Note: See TracChangeset for help on using the changeset viewer.