Refactor NULL with nullptr in test

test/allocator_unittest.cc

@@ -276,9 +276,9 @@ static void TestAtomicOps() {
 static void TestCalloc(size_t n, size_t s, bool ok) {
   char* p = reinterpret_cast<char*>(calloc(n, s));
   if (!ok) {
-    EXPECT_EQ(NULL, p) << "calloc(n, s) should not succeed";
+    EXPECT_EQ(nullptr, p) << "calloc(n, s) should not succeed";
   } else {
-    EXPECT_NE(reinterpret_cast<void*>(NULL), p) <<
+    EXPECT_NE(static_cast<void*>(nullptr), p) <<
         "calloc(n, s) should succeed";
     for (size_t i = 0; i < n*s; i++) {
       EXPECT_EQ('\0', p[i]);
@@ -301,7 +301,7 @@ static void TestOneNewWithoutExceptions(void* (*func)(size_t),
   // success test
   try {
     void* ptr = (*func)(kNotTooBig);
-    EXPECT_NE(reinterpret_cast<void*>(NULL), ptr) <<
+    EXPECT_NE(static_cast<void*>(nullptr), ptr) <<
         "allocation should not have failed.";
   } catch(...) {
     EXPECT_EQ(0, 1) << "allocation threw unexpected exception.";
@@ -310,7 +310,7 @@ static void TestOneNewWithoutExceptions(void* (*func)(size_t),
   // failure test
   try {
     void* rv = (*func)(kTooBig);
-    EXPECT_EQ(NULL, rv);
+    EXPECT_EQ(nullptr, rv);
     EXPECT_FALSE(should_throw) << "allocation should have thrown.";
   } catch(...) {
     EXPECT_TRUE(should_throw) << "allocation threw unexpected exception.";
@@ -422,7 +422,7 @@ TEST(Allocators, Realloc2) {
       EXPECT_TRUE(Valid(dst, min(src_size, dst_size)));
       Fill(dst, dst_size);
       EXPECT_TRUE(Valid(dst, dst_size));
-      if (dst != NULL) free(dst);
+      if (dst != nullptr) free(dst);
     }
   }
 
@@ -449,12 +449,12 @@ TEST(Allocators, Realloc2) {
 }
 
 TEST(Allocators, ReallocZero) {
-  // Test that realloc to zero does not return NULL.
+  // Test that realloc to zero does not return nullptr.
   for (int size = 0; size >= 0; size = NextSize(size)) {
     char* ptr = reinterpret_cast<char*>(malloc(size));
-    EXPECT_NE(static_cast<char*>(NULL), ptr);
+    EXPECT_NE(static_cast<char*>(nullptr), ptr);
     ptr = reinterpret_cast<char*>(realloc(ptr, 0));
-    EXPECT_NE(static_cast<char*>(NULL), ptr);
+    EXPECT_NE(static_cast<char*>(nullptr), ptr);
     if (ptr)
       free(ptr);
   }
@@ -466,15 +466,15 @@ TEST(Allocators, Recalloc) {
   for (int src_size = 0; src_size >= 0; src_size = NextSize(src_size)) {
     for (int dst_size = 0; dst_size >= 0; dst_size = NextSize(dst_size)) {
       unsigned char* src =
-          reinterpret_cast<unsigned char*>(_recalloc(NULL, 1, src_size));
+          reinterpret_cast<unsigned char*>(_recalloc(nullptr, 1, src_size));
       EXPECT_TRUE(IsZeroed(src, src_size));
       Fill(src, src_size);
       unsigned char* dst =
           reinterpret_cast<unsigned char*>(_recalloc(src, 1, dst_size));
       EXPECT_TRUE(Valid(dst, min(src_size, dst_size)));
       Fill(dst, dst_size);
       EXPECT_TRUE(Valid(dst, dst_size));
-      if (dst != NULL)
+      if (dst != nullptr)
         free(dst);
     }
   }

test/at_exit_unittest.cc

@@ -29,7 +29,7 @@ void ExpectCounter1IsZero(void* unused) {
 }
 
 void ExpectParamIsNull(void* param) {
-  EXPECT_EQ(static_cast<void*>(NULL), param);
+  EXPECT_EQ(static_cast<void*>(nullptr), param);
 }
 
 void ExpectParamIsCounter(void* param) {
@@ -47,9 +47,9 @@ class AtExitTest : public testing::Test {
 
 TEST_F(AtExitTest, Basic) {
   ZeroTestCounters();
-  butil::AtExitManager::RegisterCallback(&IncrementTestCounter1, NULL);
-  butil::AtExitManager::RegisterCallback(&IncrementTestCounter2, NULL);
-  butil::AtExitManager::RegisterCallback(&IncrementTestCounter1, NULL);
+  butil::AtExitManager::RegisterCallback(&IncrementTestCounter1, nullptr);
+  butil::AtExitManager::RegisterCallback(&IncrementTestCounter2, nullptr);
+  butil::AtExitManager::RegisterCallback(&IncrementTestCounter1, nullptr);
 
   EXPECT_EQ(0, g_test_counter_1);
   EXPECT_EQ(0, g_test_counter_2);
@@ -60,9 +60,9 @@ TEST_F(AtExitTest, Basic) {
 
 TEST_F(AtExitTest, LIFOOrder) {
   ZeroTestCounters();
-  butil::AtExitManager::RegisterCallback(&IncrementTestCounter1, NULL);
-  butil::AtExitManager::RegisterCallback(&ExpectCounter1IsZero, NULL);
-  butil::AtExitManager::RegisterCallback(&IncrementTestCounter2, NULL);
+  butil::AtExitManager::RegisterCallback(&IncrementTestCounter1, nullptr);
+  butil::AtExitManager::RegisterCallback(&ExpectCounter1IsZero, nullptr);
+  butil::AtExitManager::RegisterCallback(&IncrementTestCounter2, nullptr);
 
   EXPECT_EQ(0, g_test_counter_1);
   EXPECT_EQ(0, g_test_counter_2);
@@ -72,7 +72,7 @@ TEST_F(AtExitTest, LIFOOrder) {
 }
 
 TEST_F(AtExitTest, Param) {
-  butil::AtExitManager::RegisterCallback(&ExpectParamIsNull, NULL);
+  butil::AtExitManager::RegisterCallback(&ExpectParamIsNull, nullptr);
   butil::AtExitManager::RegisterCallback(&ExpectParamIsCounter,
                                         &g_test_counter_1);
   butil::AtExitManager::ProcessCallbacksNow();

test/baidu_thread_local_unittest.cpp

@@ -22,7 +22,7 @@
 
 namespace {
 
-BAIDU_THREAD_LOCAL int * dummy = NULL;
+BAIDU_THREAD_LOCAL int * dummy = nullptr;
 const size_t NTHREAD = 8;
 static bool processed[NTHREAD+1];
 static bool deleted[NTHREAD+1];
@@ -70,15 +70,15 @@ void* foo(void* arg) {
     x = arg;
     usleep(10000);
     printf("x=%p\n", x);
-    return NULL;
+    return nullptr;
 }
 
 TEST_F(BaiduThreadLocalTest, thread_local_keyword) {
     pthread_t th[2];
-    pthread_create(&th[0], NULL, foo, (void*)1);
-    pthread_create(&th[1], NULL, foo, (void*)2);
-    pthread_join(th[0], NULL);
-    pthread_join(th[1], NULL);
+    pthread_create(&th[0], nullptr, foo, (void*)1);
+    pthread_create(&th[1], nullptr, foo, (void*)2);
+    pthread_join(th[0], nullptr);
+    pthread_join(th[1], nullptr);
 }
 
 void* yell(void*) {
@@ -89,7 +89,7 @@ void* yell(void*) {
     EXPECT_EQ(p, butil::get_thread_local<YellObj>());
     EXPECT_EQ(2, YellObj::nc);
     EXPECT_EQ(0, YellObj::nd);
-    return NULL;
+    return nullptr;
 }
 
 TEST_F(BaiduThreadLocalTest, get_thread_local) {
@@ -103,8 +103,8 @@ TEST_F(BaiduThreadLocalTest, get_thread_local) {
     ASSERT_EQ(1, YellObj::nc);
     ASSERT_EQ(0, YellObj::nd);
     pthread_t th;
-    ASSERT_EQ(0, pthread_create(&th, NULL, yell, NULL));
-    pthread_join(th, NULL);
+    ASSERT_EQ(0, pthread_create(&th, nullptr, yell, nullptr));
+    pthread_join(th, nullptr);
     EXPECT_EQ(2, YellObj::nc);
     EXPECT_EQ(1, YellObj::nd);
 }
@@ -113,7 +113,7 @@ void delete_dummy(void* arg) {
     *(bool*)arg = true;
     if (dummy) {
         delete dummy;
-        dummy = NULL;
+        dummy = nullptr;
     } else {
         printf("dummy is NULL\n");
     }
@@ -122,15 +122,15 @@ void delete_dummy(void* arg) {
 void* proc_dummy(void* arg) {
     bool *p = (bool*)arg;
     *p = true;
-    EXPECT_TRUE(dummy == NULL);
+    EXPECT_TRUE(dummy == nullptr);
     dummy = new int(p - processed);
     butil::thread_atexit(delete_dummy, deleted + (p - processed));
-    return NULL;
+    return nullptr;
 }
 
 TEST_F(BaiduThreadLocalTest, sanity) {
     errno = 0;
-    ASSERT_EQ(-1, butil::thread_atexit(NULL));
+    ASSERT_EQ(-1, butil::thread_atexit(nullptr));
     ASSERT_EQ(EINVAL, errno);
 
     processed[NTHREAD] = false;
@@ -141,18 +141,18 @@ TEST_F(BaiduThreadLocalTest, sanity) {
     for (size_t i = 0; i < NTHREAD; ++i) {
         processed[i] = false;
         deleted[i] = false;
-        ASSERT_EQ(0, pthread_create(&th[i], NULL, proc_dummy, processed + i));
+        ASSERT_EQ(0, pthread_create(&th[i], nullptr, proc_dummy, processed + i));
     }
     for (size_t i = 0; i < NTHREAD; ++i) {
-        ASSERT_EQ(0, pthread_join(th[i], NULL));
+        ASSERT_EQ(0, pthread_join(th[i], nullptr));
         ASSERT_TRUE(processed[i]);
         ASSERT_TRUE(deleted[i]);
     }
 }
 
-static std::ostringstream* oss = NULL;
+static std::ostringstream* oss = nullptr;
 inline std::ostringstream& get_oss() {
-    if (oss == NULL) {
+    if (oss == nullptr) {
         oss = new std::ostringstream;
     }
     return *oss;
@@ -181,8 +181,8 @@ static void check_result() {
 }
 
 TEST_F(BaiduThreadLocalTest, call_order_and_cancel) {
-    butil::thread_atexit_cancel(NULL);
-    butil::thread_atexit_cancel(NULL, NULL);
+    butil::thread_atexit_cancel(nullptr);
+    butil::thread_atexit_cancel(nullptr, nullptr);
 
     ASSERT_EQ(0, butil::thread_atexit(check_result));
 
@@ -192,12 +192,12 @@ TEST_F(BaiduThreadLocalTest, call_order_and_cancel) {
     ASSERT_EQ(0, butil::thread_atexit(fun3, (void*)1));
     ASSERT_EQ(0, butil::thread_atexit(fun3, (void*)1));
     ASSERT_EQ(0, butil::thread_atexit(fun3, (void*)2));
-    ASSERT_EQ(0, butil::thread_atexit(fun4, NULL));
+    ASSERT_EQ(0, butil::thread_atexit(fun4, nullptr));
 
-    butil::thread_atexit_cancel(NULL);
-    butil::thread_atexit_cancel(NULL, NULL);
+    butil::thread_atexit_cancel(nullptr);
+    butil::thread_atexit_cancel(nullptr, nullptr);
     butil::thread_atexit_cancel(fun1);
-    butil::thread_atexit_cancel(fun3, NULL);
+    butil::thread_atexit_cancel(fun3, nullptr);
     butil::thread_atexit_cancel(fun3, (void*)1);
 }
 

test/baidu_time_unittest.cpp

@@ -89,7 +89,7 @@ TEST(BaiduTimeTest, cost_of_timer) {
 
     t1.start();
     for (size_t i = 0; i < N; ++i) {
-        time(NULL);
+        time(nullptr);
     }
     t1.stop();
     printf("time(NULL) takes %" PRId64 "ns\n", t1.n_elapsed() / N);

test/bounded_queue_unittest.cc

@@ -29,8 +29,8 @@ TEST(BoundedQueueTest, sanity) {
     butil::BoundedQueue<int> q(storage, sizeof(storage), butil::NOT_OWN_STORAGE);
     ASSERT_EQ(0ul, q.size());
     ASSERT_TRUE(q.empty());
-    ASSERT_TRUE(NULL == q.top());
-    ASSERT_TRUE(NULL == q.bottom());
+    ASSERT_TRUE(nullptr == q.top());
+    ASSERT_TRUE(nullptr == q.bottom());
     for (int i = 1; i <= N; ++i) {
         if (i % 2 == 0) {
             ASSERT_TRUE(q.push(i));

test/brpc_block_pool_unittest.cpp

@@ -60,30 +60,30 @@ TEST_F(BlockPoolTest, single_thread) {
     void* buf[num];
     for (size_t i = 0; i < num; ++i) {
         buf[i] = AllocBlock(GetBlockSize(0));
-        EXPECT_TRUE(buf[i] != NULL);
+        EXPECT_TRUE(buf[i] != nullptr);
         EXPECT_EQ(0, GetBlockType(buf[i]));
     }
     for (size_t i = 0; i < num; ++i) {
         DeallocBlock(buf[i]);
-        buf[i] = NULL;
+        buf[i] = nullptr;
     }
     for (size_t i = 0; i < num; ++i) {
         buf[i] = AllocBlock(GetBlockSize(0) + 1);
-        EXPECT_TRUE(buf[i] != NULL);
+        EXPECT_TRUE(buf[i] != nullptr);
         EXPECT_EQ(1, GetBlockType(buf[i]));
     }
     for (int i = num - 1; i >= 0; --i) {
         DeallocBlock(buf[i]);
-        buf[i] = NULL;
+        buf[i] = nullptr;
     }
     for (size_t i = 0; i < num; ++i) {
         buf[i] = AllocBlock(GetBlockSize(2));
-        EXPECT_TRUE(buf[i] != NULL);
+        EXPECT_TRUE(buf[i] != nullptr);
         EXPECT_EQ(2, GetBlockType(buf[i]));
     }
     for (int i = num - 1; i >= 0; --i) {
         DeallocBlock(buf[i]);
-        buf[i] = NULL;
+        buf[i] = nullptr;
     }
 
     DestroyBlockPool();
@@ -95,12 +95,12 @@ static void* AllocAndDealloc(void* arg) {
     int iterations = 1000;
     while (iterations > 0) {
         void* buf = AllocBlock(len);
-        EXPECT_TRUE(buf != NULL);
+        EXPECT_TRUE(buf != nullptr);
         EXPECT_EQ(i % 3, GetBlockType(buf));
         DeallocBlock(buf);
         --iterations;
     }
-    return NULL;
+    return nullptr;
 }
 
 TEST_F(BlockPoolTest, multiple_thread) {
@@ -137,7 +137,7 @@ TEST_F(BlockPoolTest, extend) {
     void* buf[num];
     for (size_t i = 0; i < num; ++i) {
         buf[i] = AllocBlock(65537);
-        EXPECT_TRUE(buf[i] != NULL);
+        EXPECT_TRUE(buf[i] != nullptr);
     }
     EXPECT_EQ(16, GetRegionNum());
     for (size_t i = 0; i < num; ++i) {
@@ -160,7 +160,7 @@ TEST_F(BlockPoolTest, memory_not_enough) {
     void* buf[num];
     for (size_t i = 0; i < num; ++i) {
         buf[i] = AllocBlock(65537);
-        EXPECT_TRUE(buf[i] != NULL);
+        EXPECT_TRUE(buf[i] != nullptr);
     }
     EXPECT_EQ(2, GetRegionNum());
     void* tmp = AllocBlock(65536);
@@ -182,15 +182,15 @@ TEST_F(BlockPoolTest, invalid_use) {
     EXPECT_TRUE(InitBlockPool(DummyCallback));
 
     void* buf = AllocBlock(0);
-    EXPECT_EQ(NULL, buf);
+    EXPECT_EQ(nullptr, buf);
     EXPECT_EQ(EINVAL, errno);
 
     buf = AllocBlock(GetBlockSize(2) + 1);
-    EXPECT_EQ(NULL, buf);
+    EXPECT_EQ(nullptr, buf);
     EXPECT_EQ(EINVAL, errno);
 
     errno = 0;
-    DeallocBlock(NULL);
+    DeallocBlock(nullptr);
     EXPECT_EQ(EINVAL, errno);
 
     DestroyBlockPool();