"NULL !=" = NULL

tests/LListTest.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkRandom.h"
 #include "SkTInternalLList.h"
 #include "SkTLList.h"
@@ skipping 55 matching lines @@
     list.addToHead(&elements[2]);
     list.addToHead(&elements[3]);
 
     check_list(list, reporter, false, 4, true, true, true, true, elements);
 
     // test out iterators
     typedef SkTInternalLList<ListElement>::Iter Iter;
     Iter iter;
 
     ListElement* cur = iter.init(list, Iter::kHead_IterStart);
-    for (int i = 0; NULL != cur; ++i, cur = iter.next()) {
+    for (int i = 0; cur; ++i, cur = iter.next()) {
         REPORTER_ASSERT(reporter, cur->fID == 3-i);
     }
 
     cur = iter.init(list, Iter::kTail_IterStart);
-    for (int i = 0; NULL != cur; ++i, cur = iter.prev()) {
+    for (int i = 0; cur; ++i, cur = iter.prev()) {
         REPORTER_ASSERT(reporter, cur->fID == i);
     }
 
     // remove middle, frontmost then backmost
     list.remove(&elements[1]);
     list.remove(&elements[3]);
     list.remove(&elements[0]);
 
     check_list(list, reporter, false, 1, false, false, true, false, elements);
 
@@ skipping 15 matching lines @@
     list.addBefore(&elements[0], &elements[1]);
     check_list(list, reporter, false, 2, true, true, false, false, elements);
 
     list.addAfter(&elements[3], &elements[1]);
     check_list(list, reporter, false, 3, true, true, false, true, elements);
 
     list.addBefore(&elements[2], &elements[3]);
     check_list(list, reporter, false, 4, true, true, true, true, elements);
 
     cur = iter.init(list, Iter::kHead_IterStart);
-    for (int i = 0; NULL != cur; ++i, cur = iter.next()) {
+    for (int i = 0; cur; ++i, cur = iter.next()) {
         REPORTER_ASSERT(reporter, cur->fID == i);
     }
 }
 
 static void TestTLList(skiatest::Reporter* reporter) {
     typedef SkTLList<ListElement> ElList;
     typedef ElList::Iter Iter;
     SkRandom random;
 
     for (int i = 1; i <= 16; i *= 2) {
@@ skipping 93 matching lines @@
                         Iter iter = list1.headIter();
                         // remember the elements before/after the insertion point.
                         while (n--) {
                             iter.next();
                         }
                         Iter prev(iter);
                         Iter next(iter);
                         next.next();
                         prev.prev();
 
-                        SkASSERT(NULL != iter.get());
+                        SkASSERT(iter.get());
                         // insert either before or after the iterator, then check that the
                         // surrounding sequence is correct.
                         if (2 == insertionMethod) {
                             SkNEW_INSERT_IN_LLIST_BEFORE(&list1, iter, ListElement, (id));
                             Iter newItem(iter);
                             newItem.prev();
                             REPORTER_ASSERT(reporter, newItem.get()->fID == id);
 
-                            if (NULL != next.get()) {
+                            if (next.get()) {
                                 REPORTER_ASSERT(reporter, next.prev()->fID == iter.get()->fID);
                             }
-                            if (NULL != prev.get()) {
+                            if (prev.get()) {
                                 REPORTER_ASSERT(reporter, prev.next()->fID == id);
                             }
                         } else {
                             SkNEW_INSERT_IN_LLIST_AFTER(&list1, iter, ListElement, (id));
                             Iter newItem(iter);
                             newItem.next();
                             REPORTER_ASSERT(reporter, newItem.get()->fID == id);
 
-                            if (NULL != next.get()) {
+                            if (next.get()) {
                                 REPORTER_ASSERT(reporter, next.prev()->fID == id);
                             }
-                            if (NULL != prev.get()) {
+                            if (prev.get()) {
                                 REPORTER_ASSERT(reporter, prev.next()->fID == iter.get()->fID);
                             }
                         }
                     }
                 }
                 ++count;
             } else {
                 // walk to a random place either forward or backwards and remove.
                 int n = random.nextULessThan(list1.count());
                 Iter::IterStart start;
                 ListElement* (Iter::*incrFunc)();
 
                 if (random.nextBool()) {
                     start = Iter::kHead_IterStart;
                     incrFunc = &Iter::next;
                 } else {
                     start = Iter::kTail_IterStart;
                     incrFunc = &Iter::prev;
                 }
 
                 // find the element
                 Iter iter(list1, start);
                 while (n--) {
-                    REPORTER_ASSERT(reporter, NULL != iter.get());
+                    REPORTER_ASSERT(reporter, iter.get());
                     (iter.*incrFunc)();
                 }
-                REPORTER_ASSERT(reporter, NULL != iter.get());
+                REPORTER_ASSERT(reporter, iter.get());
 
                 // remember the prev and next elements from the element to be removed
                 Iter prev = iter;
                 Iter next = iter;
                 prev.prev();
                 next.next();
                 list1.remove(iter.get());
 
                 // make sure the remembered next/prev iters still work
                 Iter pn = prev; pn.next();
@@ skipping 14 matching lines @@
 #if SK_ENABLE_INST_COUNT
         SkASSERT(0 == ListElement::InstanceCount());
 #endif
     }
 }
 
 DEF_TEST(LList, reporter) {
     TestTInternalLList(reporter);
     TestTLList(reporter);
 }