Replace NULL with nullptr or null in webrtc/base/.

webrtc/base/virtualsocket_unittest.cc

 /*
  *  Copyright 2006 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 119 matching lines @@
   bool done;
   size_t count;
   size_t sec_count;
   double sum;
   double sum_sq;
   uint32_t samples;
 };
 
 class VirtualSocketServerTest : public testing::Test {
  public:
-  VirtualSocketServerTest() : ss_(new VirtualSocketServer(NULL)),
-                              kIPv4AnyAddress(IPAddress(INADDR_ANY), 0),
-                              kIPv6AnyAddress(IPAddress(in6addr_any), 0) {
-  }
+  VirtualSocketServerTest()
+      : ss_(new VirtualSocketServer(nullptr)),
+        kIPv4AnyAddress(IPAddress(INADDR_ANY), 0),
+        kIPv6AnyAddress(IPAddress(in6addr_any), 0) {}
 
   void CheckPortIncrementalization(const SocketAddress& post,
                                    const SocketAddress& pre) {
     EXPECT_EQ(post.port(), pre.port() + 1);
     IPAddress post_ip = post.ipaddr();
     IPAddress pre_ip = pre.ipaddr();
     EXPECT_EQ(pre_ip.family(), post_ip.family());
     if (post_ip.family() == AF_INET) {
       in_addr pre_ipv4 = pre_ip.ipv4_address();
       in_addr post_ipv4 = post_ip.ipv4_address();
@@ skipping 102 matching lines @@
                                                  SOCK_STREAM);
     sink.Monitor(server);
     EXPECT_NE(0, server->Listen(5));  // Bind required
     EXPECT_EQ(0, server->Bind(initial_addr));
     EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
     EXPECT_EQ(0, server->Listen(5));
     EXPECT_EQ(server->GetState(), AsyncSocket::CS_CONNECTING);
 
     // No pending server connections
     EXPECT_FALSE(sink.Check(server, testing::SSE_READ));
-    EXPECT_TRUE(NULL == server->Accept(&accept_addr));
+    EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
     EXPECT_EQ(AF_UNSPEC, accept_addr.family());
 
     // Attempt connect to listening socket
     EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
     EXPECT_NE(client->GetLocalAddress(), kEmptyAddr);  // Implicit Bind
     EXPECT_NE(AF_UNSPEC, client->GetLocalAddress().family());  // Implicit Bind
     EXPECT_NE(client->GetLocalAddress(), server->GetLocalAddress());
 
     // Client is connecting
     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
     EXPECT_FALSE(sink.Check(client, testing::SSE_OPEN));
     EXPECT_FALSE(sink.Check(client, testing::SSE_CLOSE));
 
     ss_->ProcessMessagesUntilIdle();
 
     // Client still connecting
     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
     EXPECT_FALSE(sink.Check(client, testing::SSE_OPEN));
     EXPECT_FALSE(sink.Check(client, testing::SSE_CLOSE));
 
     // Server has pending connection
     EXPECT_TRUE(sink.Check(server, testing::SSE_READ));
     Socket* accepted = server->Accept(&accept_addr);
-    EXPECT_TRUE(NULL != accepted);
+    EXPECT_TRUE(nullptr != accepted);
     EXPECT_NE(accept_addr, kEmptyAddr);
     EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
 
     EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CONNECTED);
     EXPECT_EQ(accepted->GetLocalAddress(), server->GetLocalAddress());
     EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
 
     ss_->ProcessMessagesUntilIdle();
 
     // Client has connected
@@ skipping 22 matching lines @@
     sink.Monitor(server);
     EXPECT_EQ(0, server->Bind(initial_addr));
     EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
     // Attempt connect to non-listening socket
     EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
 
     ss_->ProcessMessagesUntilIdle();
 
     // No pending server connections
     EXPECT_FALSE(sink.Check(server, testing::SSE_READ));
-    EXPECT_TRUE(NULL == server->Accept(&accept_addr));
+    EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
     EXPECT_EQ(accept_addr, nil_addr);
 
     // Connection failed
     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
     EXPECT_FALSE(sink.Check(client, testing::SSE_OPEN));
     EXPECT_TRUE(sink.Check(client, testing::SSE_ERROR));
     EXPECT_EQ(client->GetRemoteAddress(), nil_addr);
   }
 
   void CloseDuringConnectTest(const SocketAddress& initial_addr) {
@@ skipping 58 matching lines @@
     EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
 
     EXPECT_EQ(0, server->Listen(5));
     EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
 
     ss_->ProcessMessagesUntilIdle();
 
     // Server accepts connection
     EXPECT_TRUE(sink.Check(server.get(), testing::SSE_READ));
     std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
-    ASSERT_TRUE(NULL != accepted.get());
+    ASSERT_TRUE(nullptr != accepted.get());
     sink.Monitor(accepted.get());
 
     // Client closes before connection complets
     EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CONNECTED);
 
     // Connected message has not been processed yet.
     EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING);
     client->Close();
 
     ss_->ProcessMessagesUntilIdle();
@@ skipping 256 matching lines @@
     ASSERT_TRUE(receiver.count >= 5 * 3 * bandwidth / 4);
     ASSERT_TRUE(receiver.count <= 6 * bandwidth);  // queue could drain for 1s
 
     ss_->set_bandwidth(0);
   }
 
   // It is important that initial_addr's port has to be 0 such that the
   // incremental port behavior could ensure the 2 Binds result in different
   // address.
   void DelayTest(const SocketAddress& initial_addr) {
-    time_t seed = ::time(NULL);
+    time_t seed = ::time(nullptr);
     LOG(LS_VERBOSE) << "seed = " << seed;
     srand(static_cast<unsigned int>(seed));
 
     const uint32_t mean = 2000;
     const uint32_t stddev = 500;
 
     ss_->set_delay_mean(mean);
     ss_->set_delay_stddev(stddev);
     ss_->UpdateDelayDistribution();
 
@@ skipping 59 matching lines @@
                                                  SOCK_STREAM);
     sink.Monitor(server);
     server->Bind(server_addr);
     server->Listen(5);
 
     if (shouldSucceed) {
       EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
       ss_->ProcessMessagesUntilIdle();
       EXPECT_TRUE(sink.Check(server, testing::SSE_READ));
       Socket* accepted = server->Accept(&accept_address);
-      EXPECT_TRUE(NULL != accepted);
+      EXPECT_TRUE(nullptr != accepted);
       EXPECT_NE(kEmptyAddr, accept_address);
       ss_->ProcessMessagesUntilIdle();
       EXPECT_TRUE(sink.Check(client, testing::SSE_OPEN));
       EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
     } else {
       // Check that the connection failed.
       EXPECT_EQ(-1, client->Connect(server->GetLocalAddress()));
       ss_->ProcessMessagesUntilIdle();
 
       EXPECT_FALSE(sink.Check(server, testing::SSE_READ));
-      EXPECT_TRUE(NULL == server->Accept(&accept_address));
+      EXPECT_TRUE(nullptr == server->Accept(&accept_address));
       EXPECT_EQ(accept_address, kEmptyAddr);
       EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
       EXPECT_FALSE(sink.Check(client, testing::SSE_OPEN));
       EXPECT_EQ(client->GetRemoteAddress(), kEmptyAddr);
     }
   }
 
   // Test cross-family datagram sending between a client bound to client_addr
   // and a server bound to server_addr. shouldSucceed indicates if sending is
   // expected to succeed or not.
@@ skipping 20 matching lines @@
     } else {
       EXPECT_EQ(-1, client2->SendTo("foo", 3, bound_server_addr));
       EXPECT_TRUE(client1->CheckNoPacket());
     }
   }
 
  protected:
   virtual void SetUp() {
     Thread::Current()->set_socketserver(ss_);
   }
-  virtual void TearDown() {
-    Thread::Current()->set_socketserver(NULL);
-  }
+  virtual void TearDown() { Thread::Current()->set_socketserver(nullptr); }
 
   VirtualSocketServer* ss_;
   const SocketAddress kIPv4AnyAddress;
   const SocketAddress kIPv6AnyAddress;
 };
 
 TEST_F(VirtualSocketServerTest, basic_v4) {
   SocketAddress ipv4_test_addr(IPAddress(INADDR_ANY), 5000);
   BasicTest(ipv4_test_addr);
 }
@@ skipping 255 matching lines @@
   for (size_t midx = 0; midx < arraysize(kTestMean); ++midx) {
     for (size_t didx = 0; didx < arraysize(kTestDev); ++didx) {
       for (size_t sidx = 0; sidx < arraysize(kTestSamples); ++sidx) {
         ASSERT_LT(0u, kTestSamples[sidx]);
         const uint32_t kStdDev =
             static_cast<uint32_t>(kTestDev[didx] * kTestMean[midx]);
         VirtualSocketServer::Function* f =
             VirtualSocketServer::CreateDistribution(kTestMean[midx],
                                                     kStdDev,
                                                     kTestSamples[sidx]);
-        ASSERT_TRUE(NULL != f);
+        ASSERT_TRUE(nullptr != f);
         ASSERT_EQ(kTestSamples[sidx], f->size());
         double sum = 0;
         for (uint32_t i = 0; i < f->size(); ++i) {
           sum += (*f)[i].second;
         }
         const double mean = sum / f->size();
         double sum_sq_dev = 0;
         for (uint32_t i = 0; i < f->size(); ++i) {
           double dev = (*f)[i].second - mean;
           sum_sq_dev += dev * dev;
         }
         const double stddev = sqrt(sum_sq_dev / f->size());
         EXPECT_NEAR(kTestMean[midx], mean, 0.1 * kTestMean[midx])
           << "M=" << kTestMean[midx]
           << " SD=" << kStdDev
           << " N=" << kTestSamples[sidx];
         EXPECT_NEAR(kStdDev, stddev, 0.1 * kStdDev)
           << "M=" << kTestMean[midx]
           << " SD=" << kStdDev
           << " N=" << kTestSamples[sidx];
         delete f;
       }
     }
   }
 }