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/object
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • 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();
Note: See TracChangeset for help on using the changeset viewer.