In tests, use ASSERT_NO_FATAL_FAILURE()

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 25 matching lines @@
   const size_t kModuleListStreamOffset =
       kDirectoryOffset + sizeof(MINIDUMP_DIRECTORY);
   const size_t kModulesOffset =
       kModuleListStreamOffset + sizeof(MINIDUMP_MODULE_LIST);
 
   ASSERT_GE(file_contents.size(), kModulesOffset);
 
   const MINIDUMP_HEADER* header =
       reinterpret_cast<const MINIDUMP_HEADER*>(&file_contents[0]);
 
-  VerifyMinidumpHeader(header, 1, 0);
-  if (testing::Test::HasFatalFailure()) {
-    return;
-  }
+  ASSERT_NO_FATAL_FAILURE(VerifyMinidumpHeader(header, 1, 0));
 
   const MINIDUMP_DIRECTORY* directory =
       reinterpret_cast<const MINIDUMP_DIRECTORY*>(
           &file_contents[kDirectoryOffset]);
 
   ASSERT_EQ(kMinidumpStreamTypeModuleList, directory->StreamType);
   ASSERT_GE(directory->Location.DataSize, sizeof(MINIDUMP_MODULE_LIST));
   ASSERT_EQ(kModuleListStreamOffset, directory->Location.Rva);
 
   *module_list = reinterpret_cast<const MINIDUMP_MODULE_LIST*>(
@@ skipping 11 matching lines @@
   minidump_file_writer.AddStream(&module_list_writer);
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   ASSERT_EQ(sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_MODULE_LIST),
             file_writer.string().size());
 
   const MINIDUMP_MODULE_LIST* module_list;
-  GetModuleListStream(file_writer.string(), &module_list);
-  if (Test::HasFatalFailure()) {
-    return;
-  }
+  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
 // 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.
 void ExpectCodeViewRecord(const MINIDUMP_LOCATION_DESCRIPTOR* codeview_record,
@@ skipping 174 matching lines @@
                 (module_name->Length + 1),
             file_contents.size());
   ASSERT_EQ(0u, module_name->Length % 2);
   string16 observed_module_name_utf16(
       reinterpret_cast<const char16*>(
           &file_contents[observed->ModuleNameRva + sizeof(MINIDUMP_STRING)]),
       module_name->Length / 2);
   string16 expected_module_name_utf16 = base::UTF8ToUTF16(expected_module_name);
   EXPECT_EQ(expected_module_name_utf16, observed_module_name_utf16);
 
-  ExpectCodeViewRecord(&observed->CvRecord,
-                       file_contents,
-                       expected_pdb_name,
-                       expected_pdb_uuid,
-                       expected_pdb_timestamp,
-                       expected_pdb_age);
-  if (testing::Test::HasFatalFailure()) {
-    return;
-  }
+  ASSERT_NO_FATAL_FAILURE(ExpectCodeViewRecord(&observed->CvRecord,
+                                               file_contents,
+                                               expected_pdb_name,
+                                               expected_pdb_uuid,
+                                               expected_pdb_timestamp,
+                                               expected_pdb_age));
 
-  ExpectMiscellaneousDebugRecord(&observed->MiscRecord,
-                                 file_contents,
-                                 expected_debug_name,
-                                 expected_debug_type,
-                                 expected_debug_utf16);
-  if (testing::Test::HasFatalFailure()) {
-    return;
-  }
+  ASSERT_NO_FATAL_FAILURE(ExpectMiscellaneousDebugRecord(&observed->MiscRecord,
+                                                         file_contents,
+                                                         expected_debug_name,
+                                                         expected_debug_type,
+                                                         expected_debug_utf16));
 }
 
 TEST(MinidumpModuleWriter, EmptyModule) {
   MinidumpFileWriter minidump_file_writer;
   MinidumpModuleListWriter module_list_writer;
 
   const char kModuleName[] = "test_executable";
 
   MinidumpModuleWriter module_writer;
   module_writer.SetName(kModuleName);
 
   module_list_writer.AddModule(&module_writer);
   minidump_file_writer.AddStream(&module_list_writer);
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   ASSERT_GT(file_writer.string().size(),
             sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_MODULE_LIST) + 1 * sizeof(MINIDUMP_MODULE));
 
   const MINIDUMP_MODULE_LIST* module_list;
-  GetModuleListStream(file_writer.string(), &module_list);
-  if (Test::HasFatalFailure()) {
-    return;
-  }
+  ASSERT_NO_FATAL_FAILURE(
+      GetModuleListStream(file_writer.string(), &module_list));
 
   EXPECT_EQ(1u, module_list->NumberOfModules);
 
   MINIDUMP_MODULE expected = {};
-  ExpectModule(&expected,
-               &module_list->Modules[0],
-               file_writer.string(),
-               kModuleName,
-               NULL,
-               NULL,
-               0,
-               0,
-               NULL,
-               0,
-               false);
-  if (Test::HasFatalFailure()) {
-    return;
-  }
+  ASSERT_NO_FATAL_FAILURE(ExpectModule(&expected,
+                                       &module_list->Modules[0],
+                                       file_writer.string(),
+                                       kModuleName,
+                                       NULL,
+                                       NULL,
+                                       0,
+                                       0,
+                                       NULL,
+                                       0,
+                                       false));
 }
 
 TEST(MinidumpModuleWriter, OneModule) {
   MinidumpFileWriter minidump_file_writer;
   MinidumpModuleListWriter module_list_writer;
 
   const char kModuleName[] = "statically_linked";
   const uint64_t kModuleBase = 0x10da69000;
   const uint32_t kModuleSize = 0x1000;
   const uint32_t kChecksum = 0x76543210;
@@ skipping 52 matching lines @@
   minidump_file_writer.AddStream(&module_list_writer);
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   ASSERT_GT(file_writer.string().size(),
             sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_MODULE_LIST) + 1 * sizeof(MINIDUMP_MODULE));
 
   const MINIDUMP_MODULE_LIST* module_list;
-  GetModuleListStream(file_writer.string(), &module_list);
-  if (Test::HasFatalFailure()) {
-    return;
-  }
+  ASSERT_NO_FATAL_FAILURE(
+      GetModuleListStream(file_writer.string(), &module_list));
 
   EXPECT_EQ(1u, module_list->NumberOfModules);
 
   MINIDUMP_MODULE expected = {};
   expected.BaseOfImage = kModuleBase;
   expected.SizeOfImage = kModuleSize;
   expected.CheckSum = kChecksum;
   expected.TimeDateStamp = kTimestamp;
   expected.VersionInfo.dwFileVersionMS = kFileVersionMS;
   expected.VersionInfo.dwFileVersionLS = kFileVersionLS;
   expected.VersionInfo.dwProductVersionMS = kProductVersionMS;
   expected.VersionInfo.dwProductVersionLS = kProductVersionLS;
   expected.VersionInfo.dwFileFlagsMask = kFileFlagsMask;
   expected.VersionInfo.dwFileFlags = kFileFlags;
   expected.VersionInfo.dwFileOS = kFileOS;
   expected.VersionInfo.dwFileType = kFileType;
   expected.VersionInfo.dwFileSubtype = kFileSubtype;
 
-  ExpectModule(&expected,
-               &module_list->Modules[0],
-               file_writer.string(),
-               kModuleName,
-               kPDBName,
-               &pdb_uuid,
-               0,
-               kPDBAge,
-               kDebugName,
-               kDebugType,
-               kDebugUTF16);
-  if (Test::HasFatalFailure()) {
-    return;
-  }
+  ASSERT_NO_FATAL_FAILURE(ExpectModule(&expected,
+                                       &module_list->Modules[0],
+                                       file_writer.string(),
+                                       kModuleName,
+                                       kPDBName,
+                                       &pdb_uuid,
+                                       0,
+                                       kPDBAge,
+                                       kDebugName,
+                                       kDebugType,
+                                       kDebugUTF16));
 }
 
 TEST(MinidumpModuleWriter, OneModule_CodeViewUsesPDB20_MiscUsesUTF16) {
   // MinidumpModuleWriter.OneModule tested with a PDB 7.0 link as the CodeView
   // record and an IMAGE_DEBUG_MISC record in UTF-8. This test exercises the
   // alternatives, a PDB 2.0 link as the CodeView record and an IMAGE_DEBUG_MISC
   // record with UTF-16 data.
   MinidumpFileWriter minidump_file_writer;
   MinidumpModuleListWriter module_list_writer;
 
@@ skipping 22 matching lines @@
   minidump_file_writer.AddStream(&module_list_writer);
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   ASSERT_GT(file_writer.string().size(),
             sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_MODULE_LIST) + 1 * sizeof(MINIDUMP_MODULE));
 
   const MINIDUMP_MODULE_LIST* module_list;
-  GetModuleListStream(file_writer.string(), &module_list);
-  if (Test::HasFatalFailure()) {
-    return;
-  }
+  ASSERT_NO_FATAL_FAILURE(
+      GetModuleListStream(file_writer.string(), &module_list));
 
   EXPECT_EQ(1u, module_list->NumberOfModules);
 
   MINIDUMP_MODULE expected = {};
 
-  ExpectModule(&expected,
-               &module_list->Modules[0],
-               file_writer.string(),
-               kModuleName,
-               kPDBName,
-               NULL,
-               kPDBTimestamp,
-               kPDBAge,
-               kDebugName,
-               kDebugType,
-               kDebugUTF16);
-  if (Test::HasFatalFailure()) {
-    return;
-  }
+  ASSERT_NO_FATAL_FAILURE(ExpectModule(&expected,
+                                       &module_list->Modules[0],
+                                       file_writer.string(),
+                                       kModuleName,
+                                       kPDBName,
+                                       NULL,
+                                       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
   // link as its CodeView record.
   MinidumpFileWriter minidump_file_writer;
   MinidumpModuleListWriter module_list_writer;
 
   const char kModuleName1[] = "main";
@@ skipping 52 matching lines @@
   minidump_file_writer.AddStream(&module_list_writer);
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   ASSERT_GT(file_writer.string().size(),
             sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_MODULE_LIST) + 1 * sizeof(MINIDUMP_MODULE));
 
   const MINIDUMP_MODULE_LIST* module_list;
-  GetModuleListStream(file_writer.string(), &module_list);
-  if (Test::HasFatalFailure()) {
-    return;
-  }
+  ASSERT_NO_FATAL_FAILURE(
+      GetModuleListStream(file_writer.string(), &module_list));
 
   EXPECT_EQ(3u, module_list->NumberOfModules);
 
   MINIDUMP_MODULE expected = {};
 
   {
     SCOPED_TRACE("module 0");
 
     expected.BaseOfImage = kModuleBase1;
     expected.SizeOfImage = kModuleSize1;
 
-    ExpectModule(&expected,
-                 &module_list->Modules[0],
-                 file_writer.string(),
-                 kModuleName1,
-                 kPDBName1,
-                 &pdb_uuid_1,
-                 0,
-                 kPDBAge1,
-                 NULL,
-                 0,
-                 false);
-    if (Test::HasFatalFailure()) {
-      return;
-    }
+    ASSERT_NO_FATAL_FAILURE(ExpectModule(&expected,
+                                         &module_list->Modules[0],
+                                         file_writer.string(),
+                                         kModuleName1,
+                                         kPDBName1,
+                                         &pdb_uuid_1,
+                                         0,
+                                         kPDBAge1,
+                                         NULL,
+                                         0,
+                                         false));
   }
 
   {
     SCOPED_TRACE("module 1");
 
     expected.BaseOfImage = kModuleBase2;
     expected.SizeOfImage = kModuleSize2;
 
-    ExpectModule(&expected,
-                 &module_list->Modules[1],
-                 file_writer.string(),
-                 kModuleName2,
-                 NULL,
-                 NULL,
-                 0,
-                 0,
-                 NULL,
-                 0,
-                 false);
-    if (Test::HasFatalFailure()) {
-      return;
-    }
+    ASSERT_NO_FATAL_FAILURE(ExpectModule(&expected,
+                                         &module_list->Modules[1],
+                                         file_writer.string(),
+                                         kModuleName2,
+                                         NULL,
+                                         NULL,
+                                         0,
+                                         0,
+                                         NULL,
+                                         0,
+                                         false));
   }
 
   {
     SCOPED_TRACE("module 2");
 
     expected.BaseOfImage = kModuleBase3;
     expected.SizeOfImage = kModuleSize3;
 
-    ExpectModule(&expected,
-                 &module_list->Modules[2],
-                 file_writer.string(),
-                 kModuleName3,
-                 kPDBName3,
-                 NULL,
-                 kPDBTimestamp3,
-                 kPDBAge3,
-                 NULL,
-                 0,
-                 false);
-    if (Test::HasFatalFailure()) {
-      return;
-    }
+    ASSERT_NO_FATAL_FAILURE(ExpectModule(&expected,
+                                         &module_list->Modules[2],
+                                         file_writer.string(),
+                                         kModuleName3,
+                                         kPDBName3,
+                                         NULL,
+                                         kPDBTimestamp3,
+                                         kPDBAge3,
+                                         NULL,
+                                         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