In tests, use ASSERT_NO_FATAL_FAILURE()

util/mac/process_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 352 matching lines @@
 TEST(ProcessReader, SelfSeveralThreads) {
   // Set up the ProcessReader here, before any other threads are running. This
   // tests that the threads it returns are lazily initialized as a snapshot of
   // the threads at the time of the first call to Threads(), and not at the
   // time the ProcessReader was created or initialized.
   ProcessReader process_reader;
   ASSERT_TRUE(process_reader.Initialize(mach_task_self()));
 
   TestThreadPool thread_pool;
   const size_t kChildThreads = 16;
-  thread_pool.StartThreads(kChildThreads);
-  if (Test::HasFatalFailure()) {
-    return;
-  }
+  ASSERT_NO_FATAL_FAILURE(thread_pool.StartThreads(kChildThreads));
 
   // Build a map of all expected threads, keyed by each thread’s ID. The values
   // are addresses that should lie somewhere within each thread’s stack.
   ThreadMap thread_map;
   const uint64_t self_thread_id = PthreadToThreadID(pthread_self());
   TestThreadPool::ThreadExpectation expectation;
   expectation.stack_address = reinterpret_cast<mach_vm_address_t>(&thread_map);
   expectation.suspend_count = 0;
   thread_map[self_thread_id] = expectation;
   for (size_t thread_index = 0; thread_index < kChildThreads; ++thread_index) {
@@ skipping 68 matching lines @@
 
     const std::vector<ProcessReader::Thread>& threads = process_reader.Threads();
 
     // The child shouldn’t have any threads other than its main thread and the
     // ones it created in its pool, so pass false for |tolerate_extra_threads|.
     ExpectSeveralThreads(&thread_map, threads, false);
   }
 
   void MachMultiprocessChild() override {
     TestThreadPool thread_pool;
-    thread_pool.StartThreads(thread_count_);
-    if (testing::Test::HasFatalFailure()) {
-      return;
-    }
+    ASSERT_NO_FATAL_FAILURE(thread_pool.StartThreads(thread_count_));
 
     int write_fd = WritePipeFD();
 
     // This thread isn’t part of the thread pool, but the parent will be able
     // to inspect it. Write an entry for it.
     uint64_t thread_id = PthreadToThreadID(pthread_self());
 
     CheckedWriteFD(write_fd, &thread_id, sizeof(thread_id));
 
     TestThreadPool::ThreadExpectation expectation;
@@ skipping 210 matching lines @@
 };
 
 TEST(ProcessReader, ChildModules) {
   ProcessReaderModulesChild process_reader_modules_child;
   process_reader_modules_child.Run();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad