Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Nov 4, 2015, 10:25:42 PM (9 years ago)
Author:
landauf
Message:

replace 'NULL' by 'nullptr'

Location:
code/branches/cpp11_v2/test/core
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • code/branches/cpp11_v2/test/core/class/IdentifiableTest.cc

    r10624 r10765  
    3737    {
    3838        IdentifiableClass* test = new IdentifiableClass();
    39         ASSERT_TRUE(test != NULL);
     39        ASSERT_TRUE(test != nullptr);
    4040        delete test;
    4141    }

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

    r10624 r10765  
    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();

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

    r10624 r10765  
    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();

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

    r10624 r10765  
    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();

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

    r10624 r10765  
    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();

  • code/branches/cpp11_v2/test/core/class/IdentifierTest.cc

    r10624 r10765  
    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/branches/cpp11_v2/test/core/class/OrxonoxClassTest.cc

    r10624 r10765  
    1919                {
    2020                    new IdentifierManager();
    21                     Context::setRootContext(new Context(NULL));
     21                    Context::setRootContext(new Context(nullptr));
    2222                }
    2323
    … …  
    3333    {
    3434        TestClass* test = new TestClass();
    35         ASSERT_TRUE(test != NULL);
     35        ASSERT_TRUE(test != nullptr);
    3636        delete test;
    3737    }

  • code/branches/cpp11_v2/test/core/class/OrxonoxInterfaceTest.cc

    r10624 r10765  
    3434                {
    3535                    new IdentifierManager();
    36                     Context::setRootContext(new Context(NULL));
     36                    Context::setRootContext(new Context(nullptr));
    3737                }
    3838
    … …  
    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/branches/cpp11_v2/test/core/class/SubclassIdentifierTest.cc

    r10624 r10765  
    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
    … …  
    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();
    … …  
    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/branches/cpp11_v2/test/core/class/SuperTest.cc

    r10624 r10765  
    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);
    … …  
    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);
    … …  
    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();
    … …  
    132132        EXPECT_EQ(XMLPort::NOP, test.modeSubclass_);
    133133
    134         Element* element = NULL;
     134        Element* element = nullptr;
    135135        test.XMLPort(*element, XMLPort::SaveObject);
    136136

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

    r10624 r10765  
    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();

  • code/branches/cpp11_v2/test/core/object/ClassFactoryTest.cc

    r10624 r10765  
    1818                    new IdentifierManager();
    1919                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    20                     Context::setRootContext(new Context(NULL));
     20                    Context::setRootContext(new Context(nullptr));
    2121                }
    2222
    … …  
    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/branches/cpp11_v2/test/core/object/ContextTest.cc

    r10624 r10765  
    1212        {
    1313            public:
    14                 SubclassContext() : Context(NULL) { RegisterObject(SubclassContext); }
     14                SubclassContext() : Context(nullptr) { RegisterObject(SubclassContext); }
    1515        };
    1616
    … …  
    2525                    new IdentifierManager();
    2626                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    27                     Context::setRootContext(new Context(NULL));
     27                    Context::setRootContext(new Context(nullptr));
    2828                }
    2929
    … …  
    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/branches/cpp11_v2/test/core/object/DestroyableTest.cc

    r9603 r10765  
    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/branches/cpp11_v2/test/core/object/IteratorTest.cc

    r10736 r10765  
    3636                    new IdentifierManager();
    3737                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    38                     Context::setRootContext(new Context(NULL));
     38                    Context::setRootContext(new Context(nullptr));
    3939                }
    4040
    … …  
    120120            ++i;
    121121            if (i == 1u) EXPECT_EQ(&testClass, *it);
    122             if (i == 2u) EXPECT_EQ(NULL, *it);
     122            if (i == 2u) EXPECT_EQ(nullptr, *it);
    123123        }
    124124        EXPECT_EQ(2u, i);

  • code/branches/cpp11_v2/test/core/object/ListableTest.cc

    r10624 r10765  
    4141                    new IdentifierManager();
    4242                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    43                     Context::setRootContext(new Context(NULL));
     43                    Context::setRootContext(new Context(nullptr));
    4444                }
    4545
    … …  
    5656    {
    5757        ListableClassTest* test = new ListableClassTest();
    58         ASSERT_TRUE(test != NULL);
     58        ASSERT_TRUE(test != nullptr);
    5959        delete test;
    6060    }
    … …  
    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/branches/cpp11_v2/test/core/object/ObjectListBaseTest.cc

    r9661 r10765  
    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/branches/cpp11_v2/test/core/object/ObjectListIteratorTest.cc

    r10736 r10765  
    3636                    new IdentifierManager();
    3737                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    38                     Context::setRootContext(new Context(NULL));
     38                    Context::setRootContext(new Context(nullptr));
    3939                }
    4040

  • code/branches/cpp11_v2/test/core/object/ObjectListTest.cc

    r10736 r10765  
    2828                    new IdentifierManager();
    2929                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    30                     Context::setRootContext(new Context(NULL));
     30                    Context::setRootContext(new Context(nullptr));
    3131                }
    3232

  • code/branches/cpp11_v2/test/core/object/StrongPtrTest.cc

    r10744 r10765  
    111111    void isNull(const StrongPtr<DestroyableTest> strongPtr)
    112112    {
    113         EXPECT_TRUE(strongPtr == NULL);
     113        EXPECT_TRUE(strongPtr == nullptr);
    114114        EXPECT_TRUE(strongPtr == 0);
    115115        EXPECT_TRUE(!strongPtr);
    116         EXPECT_FALSE(strongPtr != NULL);
     116        EXPECT_FALSE(strongPtr != nullptr);
    117117        EXPECT_FALSE(strongPtr != 0);
    118118        EXPECT_FALSE(strongPtr);
    … …  
    126126        }
    127127        {
    128             StrongPtr<DestroyableTest> strongPtr = NULL;
     128            StrongPtr<DestroyableTest> strongPtr = nullptr;
    129129            isNull(strongPtr);
    130130        }
    131131        {
    132132            StrongPtr<DestroyableTest> strongPtr;
    133             strongPtr = NULL;
     133            strongPtr = nullptr;
    134134            isNull(strongPtr);
    135135        }
    … …  
    150150        DestroyableTest* test = new DestroyableTest(destroyed);
    151151        StrongPtr<DestroyableTest> strongPtr = test;
    152         EXPECT_FALSE(strongPtr == NULL);
     152        EXPECT_FALSE(strongPtr == nullptr);
    153153        EXPECT_FALSE(strongPtr == 0);
    154154        EXPECT_FALSE(!strongPtr);
    155         EXPECT_TRUE(strongPtr != NULL);
     155        EXPECT_TRUE(strongPtr != nullptr);
    156156        EXPECT_TRUE(strongPtr != 0);
    157157        EXPECT_TRUE(strongPtr);
    … …  
    166166        // default
    167167        StrongPtr<DestroyableTest> strongPtr1;
    168         EXPECT_EQ(NULL, strongPtr1.get());
     168        EXPECT_EQ(nullptr, strongPtr1.get());
    169169
    170170        // pointer
    … …  
    277277        EXPECT_EQ(1u, test->getReferenceCount());
    278278        strongPtr.reset();
    279         EXPECT_EQ(NULL, strongPtr.get());
     279        EXPECT_EQ(nullptr, strongPtr.get());
    280280        EXPECT_EQ(0u, test->getReferenceCount());
    281281

  • code/branches/cpp11_v2/test/core/object/WeakPtrTest.cc

    r10744 r10765  
    3636        EXPECT_EQ(test, weakPtr.get());
    3737        test->destroy();
    38         EXPECT_EQ(NULL, weakPtr.get());
     38        EXPECT_EQ(nullptr, weakPtr.get());
    3939    }
    4040
    … …  
    4949        EXPECT_EQ(test, weakPtr3.get());
    5050        test->destroy();
    51         EXPECT_EQ(NULL, weakPtr1.get());
    52         EXPECT_EQ(NULL, weakPtr2.get());
    53         EXPECT_EQ(NULL, weakPtr3.get());
     51        EXPECT_EQ(nullptr, weakPtr1.get());
     52        EXPECT_EQ(nullptr, weakPtr2.get());
     53        EXPECT_EQ(nullptr, weakPtr3.get());
    5454    }
    5555
    … …  
    6666    void isNull(const WeakPtr<DestroyableTest> weakPtr)
    6767    {
    68         EXPECT_TRUE(weakPtr == NULL);
     68        EXPECT_TRUE(weakPtr == nullptr);
    6969        EXPECT_TRUE(weakPtr == 0);
    7070        EXPECT_TRUE(!weakPtr);
    71         EXPECT_FALSE(weakPtr != NULL);
     71        EXPECT_FALSE(weakPtr != nullptr);
    7272        EXPECT_FALSE(weakPtr != 0);
    7373        EXPECT_FALSE(weakPtr);
    … …  
    8181        }
    8282        {
    83             WeakPtr<DestroyableTest> weakPtr = NULL;
     83            WeakPtr<DestroyableTest> weakPtr = nullptr;
    8484            isNull(weakPtr);
    8585        }
    8686        {
    8787            WeakPtr<DestroyableTest> weakPtr;
    88             weakPtr = NULL;
     88            weakPtr = nullptr;
    8989            isNull(weakPtr);
    9090        }
    … …  
    104104        DestroyableTest* test = new DestroyableTest();
    105105        WeakPtr<DestroyableTest> weakPtr = test;
    106         EXPECT_FALSE(weakPtr == NULL);
     106        EXPECT_FALSE(weakPtr == nullptr);
    107107        EXPECT_FALSE(weakPtr == 0);
    108108        EXPECT_FALSE(!weakPtr);
    109         EXPECT_TRUE(weakPtr != NULL);
     109        EXPECT_TRUE(weakPtr != nullptr);
    110110        EXPECT_TRUE(weakPtr != 0);
    111111        EXPECT_TRUE(weakPtr);
    … …  
    119119        // default
    120120        WeakPtr<DestroyableTest> weakPtr1;
    121         EXPECT_EQ(NULL, weakPtr1.get());
     121        EXPECT_EQ(nullptr, weakPtr1.get());
    122122
    123123        // pointer
    … …  
    191191        test->destroy();
    192192
    193         EXPECT_EQ(NULL, vector[0].get());
    194         EXPECT_EQ(NULL, vector[1].get());
    195         EXPECT_EQ(NULL, vector[2].get());
     193        EXPECT_EQ(nullptr, vector[0].get());
     194        EXPECT_EQ(nullptr, vector[1].get());
     195        EXPECT_EQ(nullptr, vector[2].get());
    196196    }
    197197
    … …  
    202202        EXPECT_EQ(test, weakPtr.get());
    203203        weakPtr.reset();
    204         EXPECT_EQ(NULL, weakPtr.get());
     204        EXPECT_EQ(nullptr, weakPtr.get());
    205205
    206206        test->destroy();

  • code/branches/cpp11_v2/test/core/singleton/ScopeTest.cc

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