In tests, use ASSERT_NO_FATAL_FAILURE()

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 142 matching lines @@
   // 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);
-    ExpectSection(&expect_sections[index], actual_section);
-    if (testing::Test::HasFatalFailure()) {
-      return;
-    }
+    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);
     EXPECT_EQ(actual_section, actual_section_by_name);
 
     // Make sure that the section is accessible by the parent MachOImageReader’s
     // GetSectionByName.
@@ skipping 63 matching lines @@
         reinterpret_cast<const load_command*>(&commands_base[position]);
     ASSERT_LE(position + command->cmdsize, expect_image->sizeofcmds);
     if (command->cmd == kSegmentCommand) {
       ASSERT_GE(command->cmdsize, sizeof(SegmentCommand));
       const SegmentCommand* expect_segment =
           reinterpret_cast<const SegmentCommand*>(command);
       std::string segment_name =
           MachOImageSegmentReader::SegmentNameString(expect_segment->segname);
       const MachOImageSegmentReader* actual_segment =
           actual_image->GetSegmentByName(segment_name);
-      ExpectSegmentCommand(expect_segment,
-                           expect_image,
-                           actual_segment,
-                           actual_image,
-                           &section_index);
-      if (testing::Test::HasFatalFailure()) {
-        return;
-      }
+      ASSERT_NO_FATAL_FAILURE(ExpectSegmentCommand(expect_segment,
+                                                   expect_image,
+                                                   actual_segment,
+                                                   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,
@@ skipping 31 matching lines @@
     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));
+    EXPECT_EQ(section,
+              actual_image->GetSectionByName(
+                  section->segname, section->sectname, NULL));
   }
   EXPECT_FALSE(
       actual_image->GetSectionByName("NoSuchSegment", test_section, NULL));
   EXPECT_FALSE(
       actual_image->GetSectionByName(test_segment, test_section, NULL));
 
   // 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));
@@ skipping 48 matching lines @@
   }
 
   // For these, just don’t crash or anything.
   if (file_type == MH_DYLIB) {
     actual_image->DylibVersion();
   }
   actual_image->SourceVersion();
   UUID uuid;
   actual_image->UUID(&uuid);
 
-  ExpectSegmentCommands(expect_image, actual_image, test_section_index_bounds);
-  if (testing::Test::HasFatalFailure()) {
-    return;
-  }
+  ASSERT_NO_FATAL_FAILURE(ExpectSegmentCommands(
+      expect_image, actual_image, test_section_index_bounds));
 }
 
 // Verifies the symbol whose Nlist structure is |entry| and whose name is |name|
 // matches the value of a symbol by the same name looked up in |actual_image|.
 // MachOImageReader::LookUpExternalDefinedSymbol() is used for this purpose.
 // Only external defined symbols are considered, other types of symbols are
 // excluded because LookUpExternalDefinedSymbol() only deals with external
 // defined symbols.
 void ExpectSymbol(const Nlist* entry,
                   const char* name,
@@ skipping 86 matching lines @@
 
     const char* linkedit_base =
         reinterpret_cast<const char*>(linkedit->vmaddr + actual_image->Slide());
     const Nlist* nlist = reinterpret_cast<const Nlist*>(
         linkedit_base + symtab->symoff - linkedit->fileoff);
     const char* strtab = linkedit_base + symtab->stroff - linkedit->fileoff;
 
     for (uint32_t index = 0; index < symtab->nsyms; ++index) {
       const Nlist* entry = nlist + index;
       const char* name = strtab + entry->n_un.n_strx;
-      ExpectSymbol(entry, name, actual_image);
-      if (testing::Test::HasFatalFailure()) {
-        return;
-      }
+      ASSERT_NO_FATAL_FAILURE(ExpectSymbol(entry, name, actual_image));
     }
   }
 
   mach_vm_address_t ignore;
   EXPECT_FALSE(actual_image->LookUpExternalDefinedSymbol("", &ignore));
   EXPECT_FALSE(
       actual_image->LookUpExternalDefinedSymbol("NoSuchSymbolName", &ignore));
   EXPECT_FALSE(
       actual_image->LookUpExternalDefinedSymbol("_NoSuchSymbolName", &ignore));
 }
@@ skipping 10 matching lines @@
 
   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.
   intptr_t image_slide = _dyld_get_image_vmaddr_slide(0);
 
-  ExpectMachImage(mh_execute_header,
-                  mh_execute_header_address,
-                  image_slide,
-                  &image_reader,
-                  true);
-  if (Test::HasFatalFailure()) {
-    return;
-  }
+  ASSERT_NO_FATAL_FAILURE(ExpectMachImage(mh_execute_header,
+                                          mh_execute_header_address,
+                                          image_slide,
+                                          &image_reader,
+                                          true));
 
   // This symbol, __mh_execute_header, is known to exist in all MH_EXECUTE
   // Mach-O files.
   mach_vm_address_t symbol_address;
   ASSERT_TRUE(image_reader.LookUpExternalDefinedSymbol(_MH_EXECUTE_SYM,
                                                        &symbol_address));
   EXPECT_EQ(mh_execute_header_address, symbol_address);
 
-  ExpectSymbolTable(mh_execute_header, &image_reader);
-  if (Test::HasFatalFailure()) {
-    return;
-  }
+  ASSERT_NO_FATAL_FAILURE(ExpectSymbolTable(mh_execute_header, &image_reader));
 }
 
 TEST(MachOImageReader, Self_DyldImages) {
   ProcessReader process_reader;
   ASSERT_TRUE(process_reader.Initialize(mach_task_self()));
 
   uint32_t count = _dyld_image_count();
   ASSERT_GE(count, 1u);
 
   for (uint32_t index = 0; index < count; ++index) {
@@ skipping 13 matching lines @@
         image_reader.Initialize(&process_reader, image_address, image_name));
 
     uint32_t file_type = image_reader.FileType();
     if (index == 0) {
       EXPECT_EQ(static_cast<uint32_t>(MH_EXECUTE), file_type);
     } else {
       EXPECT_TRUE(file_type == MH_DYLIB || file_type == MH_BUNDLE);
     }
 
     intptr_t image_slide = _dyld_get_image_vmaddr_slide(index);
-    ExpectMachImage(
-        mach_header, image_address, image_slide, &image_reader, false);
-    if (Test::HasFatalFailure()) {
-      return;
-    }
+    ASSERT_NO_FATAL_FAILURE(ExpectMachImage(
+        mach_header, image_address, image_slide, &image_reader, false));
 
-    ExpectSymbolTable(mach_header, &image_reader);
-    if (Test::HasFatalFailure()) {
-      return;
-    }
+    ASSERT_NO_FATAL_FAILURE(ExpectSymbolTable(mach_header, &image_reader));
   }
 
   // Now that all of the modules have been verified, make sure that dyld itself
   // can be read properly too.
   const struct dyld_all_image_infos* dyld_image_infos =
       _dyld_get_all_image_infos();
   ASSERT_GE(dyld_image_infos->version, 1u);
   EXPECT_EQ(count, dyld_image_infos->infoArrayCount);
 
   if (dyld_image_infos->version >= 2) {
     SCOPED_TRACE("dyld");
 
     // dyld_all_image_infos::dyldImageLoadAddress is poorly-declared too.
     const MachHeader* mach_header = reinterpret_cast<const MachHeader*>(
         dyld_image_infos->dyldImageLoadAddress);
     mach_vm_address_t image_address =
         reinterpret_cast<mach_vm_address_t>(mach_header);
 
     MachOImageReader image_reader;
     ASSERT_TRUE(
         image_reader.Initialize(&process_reader, image_address, "dyld"));
 
     EXPECT_EQ(static_cast<uint32_t>(MH_DYLINKER), image_reader.FileType());
 
     // There’s no good API to get dyld’s slide, so don’t bother checking it.
-    ExpectMachImage(
-        mach_header, image_address, kSlideUnknown, &image_reader, false);
-    if (Test::HasFatalFailure()) {
-      return;
-    }
+    ASSERT_NO_FATAL_FAILURE(ExpectMachImage(
+        mach_header, image_address, kSlideUnknown, &image_reader, false));
 
-    ExpectSymbolTable(mach_header, &image_reader);
-    if (Test::HasFatalFailure()) {
-      return;
-    }
+    ASSERT_NO_FATAL_FAILURE(ExpectSymbolTable(mach_header, &image_reader));
   }
 
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
   // If dyld is new enough to record UUIDs, check the UUID of any module that
   // it says has one. Note that dyld doesn’t record UUIDs of anything that
   // loaded out of the shared cache, but it should at least have a UUID for the
   // main executable if it has one.
   if (dyld_image_infos->version >= 8 && dyld_image_infos->uuidArray) {
     for (uint32_t index = 0;
          index < dyld_image_infos->uuidArrayCount;
@@ skipping 23 matching lines @@
       image_reader.UUID(&actual_uuid);
       EXPECT_EQ(expected_uuid, actual_uuid);
     }
   }
 #endif
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad