Convert NULL to nullptr

util/mac/mach_o_image_reader_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 141 matching lines @@
   // sections that it claims to have, and set up a pointer to its first section
   // structure.
   ASSERT_EQ(sizeof(*expect_segment) + expect_segment->nsects * sizeof(Section),
             expect_segment->cmdsize);
   const Section* expect_sections =
       reinterpret_cast<const Section*>(&expect_segment[1]);
 
   for (size_t index = 0; index < actual_segment->nsects(); ++index) {
     const Section* expect_section = &expect_sections[index];
     const process_types::section* actual_section =
-        actual_segment->GetSectionAtIndex(index, NULL);
+        actual_segment->GetSectionAtIndex(index, nullptr);
     ASSERT_NO_FATAL_FAILURE(
         ExpectSection(&expect_sections[index], actual_section));
 
     // Make sure that the section is accessible by GetSectionByName as well.
     std::string section_name =
         MachOImageSegmentReader::SectionNameString(expect_section->sectname);
     const process_types::section* actual_section_by_name =
-        actual_segment->GetSectionByName(section_name, NULL);
+        actual_segment->GetSectionByName(section_name, nullptr);
     EXPECT_EQ(actual_section, actual_section_by_name);
 
     // Make sure that the section is accessible by the parent MachOImageReader’s
     // GetSectionByName.
     mach_vm_address_t actual_section_address;
     const process_types::section* actual_section_from_image_by_name =
         actual_image->GetSectionByName(
             segment_name, section_name, &actual_section_address);
     EXPECT_EQ(actual_section, actual_section_from_image_by_name);
 
@@ skipping 19 matching lines @@
     mach_vm_address_t actual_section_address_at_index;
     const process_types::section* actual_section_from_image_at_index =
         actual_image->GetSectionAtIndex(++(*section_index),
                                         &containing_segment,
                                         &actual_section_address_at_index);
     EXPECT_EQ(actual_section, actual_section_from_image_at_index);
     EXPECT_EQ(actual_segment, containing_segment);
     EXPECT_EQ(actual_section_address, actual_section_address_at_index);
   }
 
-  EXPECT_EQ(NULL, actual_segment->GetSectionByName("NoSuchSection", NULL));
+  EXPECT_EQ(nullptr,
+            actual_segment->GetSectionByName("NoSuchSection", nullptr));
 }
 
 // Walks through the load commands of |expect_image|, finding all of the
 // expected segment commands. For each expected segment command, calls
 // actual_image->GetSegmentByName() to obtain an actual segment command, and
 // calls ExpectSegmentCommand() to compare the expected and actual segments. A
 // series of by-name lookups is also performed on the segment to ensure that it
 // behaves correctly when attempting to look up segment and section names that
 // are not present. |test_section_indices| should be true to test
 // MachOImageReader::GetSectionAtIndex() using out-of-range section indices.
@@ skipping 30 matching lines @@
                                                    actual_image,
                                                    &section_index));
     }
     position += command->cmdsize;
   }
   EXPECT_EQ(expect_image->sizeofcmds, position);
 
   if (test_section_index_bounds) {
     // GetSectionAtIndex uses a 1-based index. Make sure that the range is
     // correct.
-    EXPECT_EQ(NULL, actual_image->GetSectionAtIndex(0, NULL, NULL));
-    EXPECT_EQ(NULL,
-              actual_image->GetSectionAtIndex(section_index + 1, NULL, NULL));
+    EXPECT_EQ(nullptr, actual_image->GetSectionAtIndex(0, nullptr, nullptr));
+    EXPECT_EQ(
+        nullptr,
+        actual_image->GetSectionAtIndex(section_index + 1, nullptr, nullptr));
   }
 
   // Make sure that by-name lookups for names that don’t exist work properly:
-  // they should return NULL.
+  // they should return nullptr.
   EXPECT_FALSE(actual_image->GetSegmentByName("NoSuchSegment"));
-  EXPECT_FALSE(
-      actual_image->GetSectionByName("NoSuchSegment", "NoSuchSection", NULL));
+  EXPECT_FALSE(actual_image->GetSectionByName(
+      "NoSuchSegment", "NoSuchSection", nullptr));
 
   // Make sure that there’s a __TEXT segment so that this can do a valid test of
   // a section that doesn’t exist within a segment that does.
   EXPECT_TRUE(actual_image->GetSegmentByName(SEG_TEXT));
-  EXPECT_FALSE(actual_image->GetSectionByName(SEG_TEXT, "NoSuchSection", NULL));
+  EXPECT_FALSE(
+      actual_image->GetSectionByName(SEG_TEXT, "NoSuchSection", nullptr));
 
   // Similarly, make sure that a section name that exists in one segment isn’t
   // accidentally found during a lookup for that section in a different segment.
   //
   // If the image has no sections (unexpected), then any section lookup should
   // fail, and these initial values of test_segment and test_section are fine
   // for the EXPECT_FALSE checks on GetSectionByName() below.
   std::string test_segment = SEG_DATA;
   std::string test_section = SECT_TEXT;
 
   const process_types::section* section =
-      actual_image->GetSectionAtIndex(1, NULL, NULL);
+      actual_image->GetSectionAtIndex(1, nullptr, nullptr);
   if (section) {
     // Use the name of the first section in the image as the section that
     // shouldn’t appear in a different segment. If the first section is in the
     // __TEXT segment (as it is normally), then a section by the same name
     // wouldn’t be expected in the __DATA segment. But if the first section is
     // in any other segment, then it wouldn’t be expected in the __TEXT segment.
     if (MachOImageSegmentReader::SegmentNameString(section->segname) ==
             SEG_TEXT) {
       test_segment = SEG_DATA;
     } else {
       test_segment = SEG_TEXT;
     }
     test_section =
         MachOImageSegmentReader::SectionNameString(section->sectname);
 
     // It should be possible to look up the first section by name.
     EXPECT_EQ(section,
               actual_image->GetSectionByName(
-                  section->segname, section->sectname, NULL));
+                  section->segname, section->sectname, nullptr));
   }
   EXPECT_FALSE(
-      actual_image->GetSectionByName("NoSuchSegment", test_section, NULL));
+      actual_image->GetSectionByName("NoSuchSegment", test_section, nullptr));
   EXPECT_FALSE(
-      actual_image->GetSectionByName(test_segment, test_section, NULL));
+      actual_image->GetSectionByName(test_segment, test_section, nullptr));
 
   // The __LINKEDIT segment normally does exist but doesn’t have any sections.
   EXPECT_FALSE(
-      actual_image->GetSectionByName(SEG_LINKEDIT, "NoSuchSection", NULL));
-  EXPECT_FALSE(actual_image->GetSectionByName(SEG_LINKEDIT, SECT_TEXT, NULL));
+      actual_image->GetSectionByName(SEG_LINKEDIT, "NoSuchSection", nullptr));
+  EXPECT_FALSE(
+      actual_image->GetSectionByName(SEG_LINKEDIT, SECT_TEXT, nullptr));
 }
 
 // In some cases, the expected slide value for an image is unknown, because no
 // reasonable API to return it is provided. When this happens, use kSlideUnknown
 // to avoid checking the actual slide value against anything.
 const mach_vm_size_t kSlideUnknown = std::numeric_limits<mach_vm_size_t>::max();
 
 // Verifies that |expect_image| is a vaild Mach-O header for the current system
 // by checking its |magic| and |cputype| fields. Then, verifies that the
 // information in |actual_image| matches that in |expect_image|. The |filetype|
@@ skipping 109 matching lines @@
 // values in |actual_image|. ExpectSymbol() is used to verify the actual symbol.
 void ExpectSymbolTable(const MachHeader* expect_image,
                        const MachOImageReader* actual_image) {
   // This intentionally consults only LC_SYMTAB and not LC_DYSYMTAB so that it
   // can look at the larger set of all symbols. The actual implementation being
   // tested is free to consult LC_DYSYMTAB, but that’s considered an
   // optimization. It’s not necessary for the test, and it’s better for the test
   // to expose bugs in that optimization rather than duplicate them.
   const char* commands_base = reinterpret_cast<const char*>(&expect_image[1]);
   uint32_t position = 0;
-  const symtab_command* symtab = NULL;
-  const SegmentCommand* linkedit = NULL;
+  const symtab_command* symtab = nullptr;
+  const SegmentCommand* linkedit = nullptr;
   for (uint32_t index = 0; index < expect_image->ncmds; ++index) {
     ASSERT_LT(position, expect_image->sizeofcmds);
     const load_command* command =
         reinterpret_cast<const load_command*>(&commands_base[position]);
     ASSERT_LE(position + command->cmdsize, expect_image->sizeofcmds);
     if (command->cmd == LC_SYMTAB) {
       ASSERT_FALSE(symtab);
       ASSERT_EQ(sizeof(symtab_command), command->cmdsize);
       symtab = reinterpret_cast<const symtab_command*>(command);
     } else if (command->cmd == kSegmentCommand) {
@@ skipping 33 matching lines @@
   EXPECT_FALSE(
       actual_image->LookUpExternalDefinedSymbol("_NoSuchSymbolName", &ignore));
 }
 
 TEST(MachOImageReader, Self_MainExecutable) {
   ProcessReader process_reader;
   ASSERT_TRUE(process_reader.Initialize(mach_task_self()));
 
   const MachHeader* mh_execute_header =
       reinterpret_cast<MachHeader*>(dlsym(RTLD_MAIN_ONLY, MH_EXECUTE_SYM));
-  ASSERT_NE(static_cast<void*>(NULL), mh_execute_header);
+  ASSERT_NE(nullptr, mh_execute_header);
   mach_vm_address_t mh_execute_header_address =
       reinterpret_cast<mach_vm_address_t>(mh_execute_header);
 
   MachOImageReader image_reader;
   ASSERT_TRUE(image_reader.Initialize(
       &process_reader, mh_execute_header_address, "executable"));
 
   EXPECT_EQ(static_cast<uint32_t>(MH_EXECUTE), image_reader.FileType());
 
   // The main executable has image index 0.
@@ skipping 115 matching lines @@
       image_reader.UUID(&actual_uuid);
       EXPECT_EQ(expected_uuid, actual_uuid);
     }
   }
 #endif
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad