Replace NULL with nullptr in all C++ files.

webrtc/p2p/base/stun_unittest.cc

 /*
  *  Copyright 2004 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 596 matching lines @@
 // Read the RFC5389 fields from the RFC5769 sample STUN request.
 TEST_F(StunTest, ReadRfc5769RequestMessage) {
   StunMessage msg;
   size_t size = ReadStunMessage(&msg, kRfc5769SampleRequest);
   CheckStunHeader(msg, STUN_BINDING_REQUEST, size);
   CheckStunTransactionID(msg, kRfc5769SampleMsgTransactionId,
                          kStunTransactionIdLength);
 
   const StunByteStringAttribute* software =
       msg.GetByteString(STUN_ATTR_SOFTWARE);
-  ASSERT_TRUE(software != NULL);
+  ASSERT_TRUE(software != nullptr);
   EXPECT_EQ(kRfc5769SampleMsgClientSoftware, software->GetString());
 
   const StunByteStringAttribute* username =
       msg.GetByteString(STUN_ATTR_USERNAME);
-  ASSERT_TRUE(username != NULL);
+  ASSERT_TRUE(username != nullptr);
   EXPECT_EQ(kRfc5769SampleMsgUsername, username->GetString());
 
   // Actual M-I value checked in a later test.
-  ASSERT_TRUE(msg.GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) != NULL);
+  ASSERT_TRUE(msg.GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) != nullptr);
 
   // Fingerprint checked in a later test, but double-check the value here.
   const StunUInt32Attribute* fingerprint =
       msg.GetUInt32(STUN_ATTR_FINGERPRINT);
-  ASSERT_TRUE(fingerprint != NULL);
+  ASSERT_TRUE(fingerprint != nullptr);
   EXPECT_EQ(0xe57a3bcf, fingerprint->value());
 }
 
 // Read the RFC5389 fields from the RFC5769 sample STUN response.
 TEST_F(StunTest, ReadRfc5769ResponseMessage) {
   StunMessage msg;
   size_t size = ReadStunMessage(&msg, kRfc5769SampleResponse);
   CheckStunHeader(msg, STUN_BINDING_RESPONSE, size);
   CheckStunTransactionID(msg, kRfc5769SampleMsgTransactionId,
                          kStunTransactionIdLength);
 
   const StunByteStringAttribute* software =
       msg.GetByteString(STUN_ATTR_SOFTWARE);
-  ASSERT_TRUE(software != NULL);
+  ASSERT_TRUE(software != nullptr);
   EXPECT_EQ(kRfc5769SampleMsgServerSoftware, software->GetString());
 
   const StunAddressAttribute* mapped_address =
       msg.GetAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
-  ASSERT_TRUE(mapped_address != NULL);
+  ASSERT_TRUE(mapped_address != nullptr);
   EXPECT_EQ(kRfc5769SampleMsgMappedAddress, mapped_address->GetAddress());
 
   // Actual M-I and fingerprint checked in later tests.
-  ASSERT_TRUE(msg.GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) != NULL);
-  ASSERT_TRUE(msg.GetUInt32(STUN_ATTR_FINGERPRINT) != NULL);
+  ASSERT_TRUE(msg.GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) != nullptr);
+  ASSERT_TRUE(msg.GetUInt32(STUN_ATTR_FINGERPRINT) != nullptr);
 }
 
 // Read the RFC5389 fields from the RFC5769 sample STUN response for IPv6.
 TEST_F(StunTest, ReadRfc5769ResponseMessageIPv6) {
   StunMessage msg;
   size_t size = ReadStunMessage(&msg, kRfc5769SampleResponseIPv6);
   CheckStunHeader(msg, STUN_BINDING_RESPONSE, size);
   CheckStunTransactionID(msg, kRfc5769SampleMsgTransactionId,
                          kStunTransactionIdLength);
 
   const StunByteStringAttribute* software =
       msg.GetByteString(STUN_ATTR_SOFTWARE);
-  ASSERT_TRUE(software != NULL);
+  ASSERT_TRUE(software != nullptr);
   EXPECT_EQ(kRfc5769SampleMsgServerSoftware, software->GetString());
 
   const StunAddressAttribute* mapped_address =
       msg.GetAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
-  ASSERT_TRUE(mapped_address != NULL);
+  ASSERT_TRUE(mapped_address != nullptr);
   EXPECT_EQ(kRfc5769SampleMsgIPv6MappedAddress, mapped_address->GetAddress());
 
   // Actual M-I and fingerprint checked in later tests.
-  ASSERT_TRUE(msg.GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) != NULL);
-  ASSERT_TRUE(msg.GetUInt32(STUN_ATTR_FINGERPRINT) != NULL);
+  ASSERT_TRUE(msg.GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) != nullptr);
+  ASSERT_TRUE(msg.GetUInt32(STUN_ATTR_FINGERPRINT) != nullptr);
 }
 
 // Read the RFC5389 fields from the RFC5769 sample STUN response with auth.
 TEST_F(StunTest, ReadRfc5769RequestMessageLongTermAuth) {
   StunMessage msg;
   size_t size = ReadStunMessage(&msg, kRfc5769SampleRequestLongTermAuth);
   CheckStunHeader(msg, STUN_BINDING_REQUEST, size);
   CheckStunTransactionID(msg, kRfc5769SampleMsgWithAuthTransactionId,
                          kStunTransactionIdLength);
 
   const StunByteStringAttribute* username =
       msg.GetByteString(STUN_ATTR_USERNAME);
-  ASSERT_TRUE(username != NULL);
+  ASSERT_TRUE(username != nullptr);
   EXPECT_EQ(kRfc5769SampleMsgWithAuthUsername, username->GetString());
 
   const StunByteStringAttribute* nonce =
       msg.GetByteString(STUN_ATTR_NONCE);
-  ASSERT_TRUE(nonce != NULL);
+  ASSERT_TRUE(nonce != nullptr);
   EXPECT_EQ(kRfc5769SampleMsgWithAuthNonce, nonce->GetString());
 
   const StunByteStringAttribute* realm =
       msg.GetByteString(STUN_ATTR_REALM);
-  ASSERT_TRUE(realm != NULL);
+  ASSERT_TRUE(realm != nullptr);
   EXPECT_EQ(kRfc5769SampleMsgWithAuthRealm, realm->GetString());
 
   // No fingerprint, actual M-I checked in later tests.
-  ASSERT_TRUE(msg.GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) != NULL);
-  ASSERT_TRUE(msg.GetUInt32(STUN_ATTR_FINGERPRINT) == NULL);
+  ASSERT_TRUE(msg.GetByteString(STUN_ATTR_MESSAGE_INTEGRITY) != nullptr);
+  ASSERT_TRUE(msg.GetUInt32(STUN_ATTR_FINGERPRINT) == nullptr);
 }
 
 // The RFC3489 packet in this test is the same as
 // kStunMessageWithIPv4MappedAddress, but with a different value where the
 // magic cookie was.
 TEST_F(StunTest, ReadLegacyMessage) {
   unsigned char rfc3489_packet[sizeof(kStunMessageWithIPv4MappedAddress)];
   memcpy(rfc3489_packet, kStunMessageWithIPv4MappedAddress,
       sizeof(kStunMessageWithIPv4MappedAddress));
   // Overwrite the magic cookie here.
@@ skipping 20 matching lines @@
   CheckStunHeader(msg, STUN_BINDING_RESPONSE, size);
   CheckStunTransactionID(msg, kTestTransactionId2, kStunTransactionIdLength);
 
   const StunAddressAttribute* addr =
       msg.GetAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
   CheckStunAddressAttribute(addr, STUN_ADDRESS_IPV6,
                             kTestMessagePort1, test_address);
 
   // Owner with a different transaction ID.
   msg2.SetTransactionID("ABCDABCDABCD");
-  StunXorAddressAttribute addr2(STUN_ATTR_XOR_MAPPED_ADDRESS, 20, NULL);
+  StunXorAddressAttribute addr2(STUN_ATTR_XOR_MAPPED_ADDRESS, 20, nullptr);
   addr2.SetIP(addr->ipaddr());
   addr2.SetPort(addr->port());
   addr2.SetOwner(&msg2);
   // The internal IP address shouldn't change.
   ASSERT_EQ(addr2.ipaddr(), addr->ipaddr());
 
   rtc::ByteBufferWriter correct_buf;
   rtc::ByteBufferWriter wrong_buf;
   EXPECT_TRUE(addr->Write(&correct_buf));
   EXPECT_TRUE(addr2.Write(&wrong_buf));
   // But when written out, the buffers should look different.
   ASSERT_NE(0,
             memcmp(correct_buf.Data(), wrong_buf.Data(), wrong_buf.Length()));
   // And when reading a known good value, the address should be wrong.
   rtc::ByteBufferReader read_buf(correct_buf);
   addr2.Read(&read_buf);
   ASSERT_NE(addr->ipaddr(), addr2.ipaddr());
   addr2.SetIP(addr->ipaddr());
   addr2.SetPort(addr->port());
   // Try writing with no owner at all, should fail and write nothing.
-  addr2.SetOwner(NULL);
+  addr2.SetOwner(nullptr);
   ASSERT_EQ(addr2.ipaddr(), addr->ipaddr());
   wrong_buf.Clear();
   EXPECT_FALSE(addr2.Write(&wrong_buf));
   ASSERT_EQ(0U, wrong_buf.Length());
 }
 
 TEST_F(StunTest, SetIPv4XorAddressAttributeOwner) {
   // Unlike the IPv6XorAddressAttributeOwner test, IPv4 XOR address attributes
   // should _not_ be affected by a change in owner. IPv4 XOR address uses the
   // magic cookie value which is fixed.
   StunMessage msg;
   StunMessage msg2;
   size_t size = ReadStunMessage(&msg, kStunMessageWithIPv4XorMappedAddress);
 
   rtc::IPAddress test_address(kIPv4TestAddress1);
 
   CheckStunHeader(msg, STUN_BINDING_RESPONSE, size);
   CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
 
   const StunAddressAttribute* addr =
       msg.GetAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
   CheckStunAddressAttribute(addr, STUN_ADDRESS_IPV4,
                             kTestMessagePort3, test_address);
 
   // Owner with a different transaction ID.
   msg2.SetTransactionID("ABCDABCDABCD");
-  StunXorAddressAttribute addr2(STUN_ATTR_XOR_MAPPED_ADDRESS, 20, NULL);
+  StunXorAddressAttribute addr2(STUN_ATTR_XOR_MAPPED_ADDRESS, 20, nullptr);
   addr2.SetIP(addr->ipaddr());
   addr2.SetPort(addr->port());
   addr2.SetOwner(&msg2);
   // The internal IP address shouldn't change.
   ASSERT_EQ(addr2.ipaddr(), addr->ipaddr());
 
   rtc::ByteBufferWriter correct_buf;
   rtc::ByteBufferWriter wrong_buf;
   EXPECT_TRUE(addr->Write(&correct_buf));
   EXPECT_TRUE(addr2.Write(&wrong_buf));
   // The same address data should be written.
   ASSERT_EQ(0,
             memcmp(correct_buf.Data(), wrong_buf.Data(), wrong_buf.Length()));
   // And an attribute should be able to un-XOR an address belonging to a message
   // with a different transaction ID.
   rtc::ByteBufferReader read_buf(correct_buf);
   EXPECT_TRUE(addr2.Read(&read_buf));
   ASSERT_EQ(addr->ipaddr(), addr2.ipaddr());
 
   // However, no owner is still an error, should fail and write nothing.
-  addr2.SetOwner(NULL);
+  addr2.SetOwner(nullptr);
   ASSERT_EQ(addr2.ipaddr(), addr->ipaddr());
   wrong_buf.Clear();
   EXPECT_FALSE(addr2.Write(&wrong_buf));
 }
 
 TEST_F(StunTest, CreateIPv6AddressAttribute) {
   rtc::IPAddress test_ip(kIPv6TestAddress2);
 
   StunAddressAttribute* addr =
       StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
@@ skipping 165 matching lines @@
 }
 
 TEST_F(StunTest, ReadByteStringAttribute) {
   StunMessage msg;
   size_t size = ReadStunMessage(&msg, kStunMessageWithByteStringAttribute);
 
   CheckStunHeader(msg, STUN_BINDING_REQUEST, size);
   CheckStunTransactionID(msg, kTestTransactionId2, kStunTransactionIdLength);
   const StunByteStringAttribute* username =
       msg.GetByteString(STUN_ATTR_USERNAME);
-  ASSERT_TRUE(username != NULL);
+  ASSERT_TRUE(username != nullptr);
   EXPECT_EQ(kTestUserName1, username->GetString());
 }
 
 TEST_F(StunTest, ReadPaddedByteStringAttribute) {
   StunMessage msg;
   size_t size = ReadStunMessage(&msg,
                                 kStunMessageWithPaddedByteStringAttribute);
   ASSERT_NE(0U, size);
   CheckStunHeader(msg, STUN_BINDING_REQUEST, size);
   CheckStunTransactionID(msg, kTestTransactionId2, kStunTransactionIdLength);
   const StunByteStringAttribute* username =
       msg.GetByteString(STUN_ATTR_USERNAME);
-  ASSERT_TRUE(username != NULL);
+  ASSERT_TRUE(username != nullptr);
   EXPECT_EQ(kTestUserName2, username->GetString());
 }
 
 TEST_F(StunTest, ReadErrorCodeAttribute) {
   StunMessage msg;
   size_t size = ReadStunMessage(&msg, kStunMessageWithErrorAttribute);
 
   CheckStunHeader(msg, STUN_BINDING_ERROR_RESPONSE, size);
   CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
   const StunErrorCodeAttribute* errorcode = msg.GetErrorCode();
-  ASSERT_TRUE(errorcode != NULL);
+  ASSERT_TRUE(errorcode != nullptr);
   EXPECT_EQ(kTestErrorClass, errorcode->eclass());
   EXPECT_EQ(kTestErrorNumber, errorcode->number());
   EXPECT_EQ(kTestErrorReason, errorcode->reason());
   EXPECT_EQ(kTestErrorCode, errorcode->code());
 }
 
 TEST_F(StunTest, ReadMessageWithAUInt16ListAttribute) {
   StunMessage msg;
   size_t size = ReadStunMessage(&msg, kStunMessageWithUInt16ListAttribute);
   CheckStunHeader(msg, STUN_BINDING_REQUEST, size);
   const StunUInt16ListAttribute* types = msg.GetUnknownAttributes();
-  ASSERT_TRUE(types != NULL);
+  ASSERT_TRUE(types != nullptr);
   EXPECT_EQ(3U, types->Size());
   EXPECT_EQ(0x1U, types->GetType(0));
   EXPECT_EQ(0x1000U, types->GetType(1));
   EXPECT_EQ(0xAB0CU, types->GetType(2));
 }
 
 TEST_F(StunTest, ReadMessageWithAnUnknownAttribute) {
   StunMessage msg;
   size_t size = ReadStunMessage(&msg, kStunMessageWithUnknownAttribute);
   CheckStunHeader(msg, STUN_BINDING_REQUEST, size);
 
   // Parsing should have succeeded and there should be a USERNAME attribute
   const StunByteStringAttribute* username =
       msg.GetByteString(STUN_ATTR_USERNAME);
-  ASSERT_TRUE(username != NULL);
+  ASSERT_TRUE(username != nullptr);
   EXPECT_EQ(kTestUserName2, username->GetString());
 }
 
 TEST_F(StunTest, ReadMessageWithOriginAttribute) {
   StunMessage msg;
   size_t size = ReadStunMessage(&msg, kStunMessageWithOriginAttribute);
   CheckStunHeader(msg, STUN_BINDING_REQUEST, size);
   const StunByteStringAttribute* origin =
       msg.GetByteString(STUN_ATTR_ORIGIN);
-  ASSERT_TRUE(origin != NULL);
+  ASSERT_TRUE(origin != nullptr);
   EXPECT_EQ(kTestOrigin, origin->GetString());
 }
 
 TEST_F(StunTest, WriteMessageWithAnErrorCodeAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithErrorAttribute);
 
   msg.SetType(STUN_BINDING_ERROR_RESPONSE);
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId1),
@@ skipping 303 matching lines @@
   EXPECT_EQ("0123456789ab", msg.transaction_id());
 
   msg2.SetType(STUN_BINDING_REQUEST);
   msg2.SetTransactionID("0123456789ab");
 
   in_addr legacy_in_addr;
   legacy_in_addr.s_addr = htonl(17U);
   rtc::IPAddress legacy_ip(legacy_in_addr);
 
   const StunAddressAttribute* addr = msg.GetAddress(STUN_ATTR_MAPPED_ADDRESS);
-  ASSERT_TRUE(addr != NULL);
+  ASSERT_TRUE(addr != nullptr);
   EXPECT_EQ(1, addr->family());
   EXPECT_EQ(13, addr->port());
   EXPECT_EQ(legacy_ip, addr->ipaddr());
 
   StunAddressAttribute* addr2 =
       StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
   addr2->SetPort(13);
   addr2->SetIP(legacy_ip);
   msg2.AddAttribute(addr2);
 
   const StunByteStringAttribute* bytes = msg.GetByteString(STUN_ATTR_USERNAME);
-  ASSERT_TRUE(bytes != NULL);
+  ASSERT_TRUE(bytes != nullptr);
   EXPECT_EQ(12U, bytes->length());
   EXPECT_EQ("abcdefghijkl", bytes->GetString());
 
   StunByteStringAttribute* bytes2 =
   StunAttribute::CreateByteString(STUN_ATTR_USERNAME);
   bytes2->CopyBytes("abcdefghijkl");
   msg2.AddAttribute(bytes2);
 
   const StunUInt32Attribute* uval = msg.GetUInt32(STUN_ATTR_LIFETIME);
-  ASSERT_TRUE(uval != NULL);
+  ASSERT_TRUE(uval != nullptr);
   EXPECT_EQ(11U, uval->value());
 
   StunUInt32Attribute* uval2 = StunAttribute::CreateUInt32(STUN_ATTR_LIFETIME);
   uval2->SetValue(11);
   msg2.AddAttribute(uval2);
 
   bytes = msg.GetByteString(STUN_ATTR_MAGIC_COOKIE);
-  ASSERT_TRUE(bytes != NULL);
+  ASSERT_TRUE(bytes != nullptr);
   EXPECT_EQ(4U, bytes->length());
   EXPECT_EQ(0,
             memcmp(bytes->bytes(),
                    TURN_MAGIC_COOKIE_VALUE,
                    sizeof(TURN_MAGIC_COOKIE_VALUE)));
 
   bytes2 = StunAttribute::CreateByteString(STUN_ATTR_MAGIC_COOKIE);
   bytes2->CopyBytes(reinterpret_cast<const char*>(TURN_MAGIC_COOKIE_VALUE),
                     sizeof(TURN_MAGIC_COOKIE_VALUE));
   msg2.AddAttribute(bytes2);
 
   uval = msg.GetUInt32(STUN_ATTR_BANDWIDTH);
-  ASSERT_TRUE(uval != NULL);
+  ASSERT_TRUE(uval != nullptr);
   EXPECT_EQ(6U, uval->value());
 
   uval2 = StunAttribute::CreateUInt32(STUN_ATTR_BANDWIDTH);
   uval2->SetValue(6);
   msg2.AddAttribute(uval2);
 
   addr = msg.GetAddress(STUN_ATTR_DESTINATION_ADDRESS);
-  ASSERT_TRUE(addr != NULL);
+  ASSERT_TRUE(addr != nullptr);
   EXPECT_EQ(1, addr->family());
   EXPECT_EQ(13, addr->port());
   EXPECT_EQ(legacy_ip, addr->ipaddr());
 
   addr2 = StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
   addr2->SetPort(13);
   addr2->SetIP(legacy_ip);
   msg2.AddAttribute(addr2);
 
   addr = msg.GetAddress(STUN_ATTR_SOURCE_ADDRESS2);
-  ASSERT_TRUE(addr != NULL);
+  ASSERT_TRUE(addr != nullptr);
   EXPECT_EQ(1, addr->family());
   EXPECT_EQ(13, addr->port());
   EXPECT_EQ(legacy_ip, addr->ipaddr());
 
   addr2 = StunAttribute::CreateAddress(STUN_ATTR_SOURCE_ADDRESS2);
   addr2->SetPort(13);
   addr2->SetIP(legacy_ip);
   msg2.AddAttribute(addr2);
 
   bytes = msg.GetByteString(STUN_ATTR_DATA);
-  ASSERT_TRUE(bytes != NULL);
+  ASSERT_TRUE(bytes != nullptr);
   EXPECT_EQ(7U, bytes->length());
   EXPECT_EQ("abcdefg", bytes->GetString());
 
   bytes2 = StunAttribute::CreateByteString(STUN_ATTR_DATA);
   bytes2->CopyBytes("abcdefg");
   msg2.AddAttribute(bytes2);
 
   rtc::ByteBufferWriter out;
   EXPECT_TRUE(msg.Write(&out));
   EXPECT_EQ(size, out.Length());
   size_t len1 = out.Length();
   rtc::ByteBufferReader read_buf(out);
   std::string outstring;
   read_buf.ReadString(&outstring, len1);
   EXPECT_EQ(0, memcmp(outstring.c_str(), input, len1));
 
   rtc::ByteBufferWriter out2;
   EXPECT_TRUE(msg2.Write(&out2));
   EXPECT_EQ(size, out2.Length());
   size_t len2 = out2.Length();
   rtc::ByteBufferReader read_buf2(out2);
   std::string outstring2;
   read_buf2.ReadString(&outstring2, len2);
   EXPECT_EQ(0, memcmp(outstring2.c_str(), input, len2));
 }
 
 }  // namespace cricket