Style Change: NULL->nullptr

tests/DynamicHashTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTDynamicHash.h"
 #include "Test.h"
 
@@ skipping 82 matching lines @@
     ASSERT(hash.countCollisions(5) == 1);
     ASSERT(hash.countCollisions(9) == 1);
 
     // Second is one step away.
     hash.add(&b);
     ASSERT(hash.countCollisions(1) == 0);
     ASSERT(hash.countCollisions(5) == 1);
     ASSERT(hash.countCollisions(9) == 2);
 
     // We can find our data right?
-    ASSERT(hash.find(1) != NULL);
+    ASSERT(hash.find(1) != nullptr);
     ASSERT(hash.find(1)->value == 2.0);
-    ASSERT(hash.find(5) != NULL);
+    ASSERT(hash.find(5) != nullptr);
     ASSERT(hash.find(5)->value == 3.0);
 
     // These aren't in the hash.
-    ASSERT(hash.find(2) == NULL);
-    ASSERT(hash.find(9) == NULL);
+    ASSERT(hash.find(2) == nullptr);
+    ASSERT(hash.find(9) == nullptr);
 }
 
 DEF_TEST(DynamicHash_remove, reporter) {
     Hash hash;
 
     // These collide.
     Entry a = { 1, 2.0 };
     Entry b = { 5, 3.0 };
     Entry c = { 9, 4.0 };
 
     hash.add(&a);
     hash.add(&b);
     hash.remove(1);
     // a should be marked deleted, and b should still be findable.
 
-    ASSERT(hash.find(1) == NULL);
-    ASSERT(hash.find(5) != NULL);
+    ASSERT(hash.find(1) == nullptr);
+    ASSERT(hash.find(5) != nullptr);
     ASSERT(hash.find(5)->value == 3.0);
 
     // This will go in the same slot as 'a' did before.
     ASSERT(hash.countCollisions(9) == 0);
     hash.add(&c);
-    ASSERT(hash.find(9) != NULL);
+    ASSERT(hash.find(9) != nullptr);
     ASSERT(hash.find(9)->value == 4.0);
-    ASSERT(hash.find(5) != NULL);
+    ASSERT(hash.find(5) != nullptr);
     ASSERT(hash.find(5)->value == 3.0);
 }
 
 template<typename T> static void TestIter(skiatest::Reporter* reporter) {
     Hash hash;
 
     int count = 0;
     // this should fall out of loop immediately
     for (T iter(&hash); !iter.done(); ++iter) {
         ++count;
     }
     ASSERT(0 == count);
 
     // These collide.
     Entry a = { 1, 2.0 };
     Entry b = { 5, 3.0 };
     Entry c = { 9, 4.0 };
 
     hash.add(&a);
     hash.add(&b);
     hash.add(&c);
 
     // should see all 3 unique keys when iterating over hash
     count = 0;
     int keys[3] = {0, 0, 0};
     for (T iter(&hash); !iter.done(); ++iter) {
         int key = (*iter).key;
         keys[count] = key;
-        ASSERT(hash.find(key) != NULL);
+        ASSERT(hash.find(key) != nullptr);
         ++count;
     }
     ASSERT(3 == count);
     ASSERT(keys[0] != keys[1]);
     ASSERT(keys[0] != keys[2]);
     ASSERT(keys[1] != keys[2]);
 
     // should see 2 unique keys when iterating over hash that aren't 1
     hash.remove(1);
     count = 0;
     memset(keys, 0, sizeof(keys));
     for (T iter(&hash); !iter.done(); ++iter) {
         int key = (*iter).key;
         keys[count] = key;
         ASSERT(key != 1);
-        ASSERT(hash.find(key) != NULL);
+        ASSERT(hash.find(key) != nullptr);
         ++count;
     }
     ASSERT(2 == count);
     ASSERT(keys[0] != keys[1]);
 }
 
 DEF_TEST(DynamicHash_iterator, reporter) {
     TestIter<Hash::Iter>(reporter);
     TestIter<Hash::ConstIter>(reporter);
 }
@@ skipping 17 matching lines @@
         ASSERT(hash.capacity() == 4);
     }
     ASSERT(hash.count() == 0);
 
     // make sure things still work
     hash.add(&a);
     hash.add(&b);
     ASSERT(hash.count() == 2);
     ASSERT(hash.capacity() == 4);
 
-    ASSERT(hash.find(1) != NULL);
-    ASSERT(hash.find(2) != NULL);
+    ASSERT(hash.find(1) != nullptr);
+    ASSERT(hash.find(2) != nullptr);
 }
 
 DEF_TEST(DynamicHash_reset, reporter) {
     TestResetOrRewind(reporter, true);
 }
 
 DEF_TEST(DynamicHash_rewind, reporter) {
     TestResetOrRewind(reporter, false);
 }