Convert NULL to nullptr

minidump/minidump_module_writer_test.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 63 matching lines @@
                 sizeof(MINIDUMP_MODULE_LIST),
             file_writer.string().size());
 
   const MINIDUMP_MODULE_LIST* module_list;
   ASSERT_NO_FATAL_FAILURE(
       GetModuleListStream(file_writer.string(), &module_list));
 
   EXPECT_EQ(0u, module_list->NumberOfModules);
 }
 
-// If |expected_pdb_name| is non-NULL, |codeview_record| is used to locate a
+// If |expected_pdb_name| is not nullptr, |codeview_record| is used to locate a
 // CodeView record in |file_contents|, and its fields are compared against the
 // the |expected_pdb_*| values. If |expected_pdb_uuid| is supplied, the CodeView
 // record must be a PDB 7.0 link, otherwise, it must be a PDB 2.0 link. If
-// |expected_pdb_name| is NULL, |codeview_record| must not point to anything.
+// |expected_pdb_name| is nullptr, |codeview_record| must not point to anything.
 void ExpectCodeViewRecord(const MINIDUMP_LOCATION_DESCRIPTOR* codeview_record,
                           const std::string& file_contents,
                           const char* expected_pdb_name,
                           const UUID* expected_pdb_uuid,
                           time_t expected_pdb_timestamp,
                           uint32_t expected_pdb_age) {
   if (expected_pdb_name) {
     EXPECT_NE(0u, codeview_record->Rva);
     ASSERT_LE(codeview_record->Rva + codeview_record->DataSize,
               file_contents.size());
@@ skipping 42 matching lines @@
     observed_pdb_name.resize(observed_pdb_name.size() - 1);
 
     EXPECT_EQ(expected_pdb_name, observed_pdb_name);
   } else {
     // There should be no CodeView record.
     EXPECT_EQ(0u, codeview_record->DataSize);
     EXPECT_EQ(0u, codeview_record->Rva);
   }
 }
 
-// If |expected_debug_name| is non-NULL, |misc_record| is used to locate a
+// If |expected_debug_name| is not nullptr, |misc_record| is used to locate a
 // miscellanous debugging record in |file_contents|, and its fields are compared
-// against the the |expected_debug_*| values. If |expected_debug_name| is NULL,
-// |misc_record| must not point to anything.
+// against the the |expected_debug_*| values. If |expected_debug_name| is
+// nullptr, |misc_record| must not point to anything.
 void ExpectMiscellaneousDebugRecord(
     const MINIDUMP_LOCATION_DESCRIPTOR* misc_record,
     const std::string& file_contents,
     const char* expected_debug_name,
     uint32_t expected_debug_type,
     bool expected_debug_utf16) {
   if (expected_debug_name) {
     EXPECT_GE(misc_record->DataSize, sizeof(IMAGE_DEBUG_MISC));
     EXPECT_NE(0u, misc_record->Rva);
     ASSERT_LE(misc_record->Rva + misc_record->DataSize, file_contents.size());
@@ skipping 143 matching lines @@
   ASSERT_NO_FATAL_FAILURE(
       GetModuleListStream(file_writer.string(), &module_list));
 
   EXPECT_EQ(1u, module_list->NumberOfModules);
 
   MINIDUMP_MODULE expected = {};
   ASSERT_NO_FATAL_FAILURE(ExpectModule(&expected,
                                        &module_list->Modules[0],
                                        file_writer.string(),
                                        kModuleName,
-                                       NULL,
-                                       NULL,
+                                       nullptr,
+                                       nullptr,
                                        0,
                                        0,
-                                       NULL,
+                                       nullptr,
                                        0,
                                        false));
 }
 
 TEST(MinidumpModuleWriter, OneModule) {
   MinidumpFileWriter minidump_file_writer;
   MinidumpModuleListWriter module_list_writer;
 
   const char kModuleName[] = "statically_linked";
   const uint64_t kModuleBase = 0x10da69000;
@@ skipping 139 matching lines @@
 
   EXPECT_EQ(1u, module_list->NumberOfModules);
 
   MINIDUMP_MODULE expected = {};
 
   ASSERT_NO_FATAL_FAILURE(ExpectModule(&expected,
                                        &module_list->Modules[0],
                                        file_writer.string(),
                                        kModuleName,
                                        kPDBName,
-                                       NULL,
+                                       nullptr,
                                        kPDBTimestamp,
                                        kPDBAge,
                                        kDebugName,
                                        kDebugType,
                                        kDebugUTF16));
 }
 
 TEST(MinidumpModuleWriter, ThreeModules) {
   // As good exercise, this test uses three modules, one with a PDB 7.0 link as
   // its CodeView record, one with no CodeView record, and one with a PDB 2.0
@@ skipping 78 matching lines @@
     expected.SizeOfImage = kModuleSize0;
 
     ASSERT_NO_FATAL_FAILURE(ExpectModule(&expected,
                                          &module_list->Modules[0],
                                          file_writer.string(),
                                          kModuleName0,
                                          kPDBName0,
                                          &pdb_uuid_0,
                                          0,
                                          kPDBAge0,
-                                         NULL,
+                                         nullptr,
                                          0,
                                          false));
   }
 
   {
     SCOPED_TRACE("module 1");
 
     expected.BaseOfImage = kModuleBase1;
     expected.SizeOfImage = kModuleSize1;
 
     ASSERT_NO_FATAL_FAILURE(ExpectModule(&expected,
                                          &module_list->Modules[1],
                                          file_writer.string(),
                                          kModuleName1,
-                                         NULL,
-                                         NULL,
+                                         nullptr,
+                                         nullptr,
                                          0,
                                          0,
-                                         NULL,
+                                         nullptr,
                                          0,
                                          false));
   }
 
   {
     SCOPED_TRACE("module 2");
 
     expected.BaseOfImage = kModuleBase2;
     expected.SizeOfImage = kModuleSize2;
 
     ASSERT_NO_FATAL_FAILURE(ExpectModule(&expected,
                                          &module_list->Modules[2],
                                          file_writer.string(),
                                          kModuleName2,
                                          kPDBName2,
-                                         NULL,
+                                         nullptr,
                                          kPDBTimestamp2,
                                          kPDBAge2,
-                                         NULL,
+                                         nullptr,
                                          0,
                                          false));
   }
 }
 
 TEST(MinidumpSystemInfoWriterDeathTest, NoModuleName) {
   MinidumpFileWriter minidump_file_writer;
   MinidumpModuleListWriter module_list_writer;
   MinidumpModuleWriter module_writer;
   module_list_writer.AddModule(&module_writer);
   minidump_file_writer.AddStream(&module_list_writer);
 
   StringFileWriter file_writer;
   ASSERT_DEATH(minidump_file_writer.WriteEverything(&file_writer), "name_");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad