In tests, use ASSERT_NO_FATAL_FAILURE()

util/mach/mach_message_server_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 380 matching lines @@
 
     for (size_t index = 0;
          index < options_.client_send_request_count;
          ++index) {
       if (options_.child_send_all_requests_before_receiving_any_replies) {
         // For this test, all of the messages need to go into the queue before
         // the parent is allowed to start processing them. Don’t attempt to
         // process replies before all of the requests are sent, because the
         // server won’t have sent any replies until all of the requests are in
         // its queue.
-        ChildSendRequest();
+        ASSERT_NO_FATAL_FAILURE(ChildSendRequest());
       } else {
-        ChildSendRequestAndWaitForReply();
-      }
-      if (testing::Test::HasFatalFailure()) {
-        return;
+        ASSERT_NO_FATAL_FAILURE(ChildSendRequestAndWaitForReply());
       }
     }
 
     if (options_.parent_wait_for_child_pipe &&
         options_.child_send_all_requests_before_receiving_any_replies) {
       // Now that all of the requests have been sent, let the parent know that
       // it’s safe to begin processing them, and then wait for the replies.
-      ChildNotifyParentViaPipe();
-      if (testing::Test::HasFatalFailure()) {
-        return;
-      }
+      ASSERT_NO_FATAL_FAILURE(ChildNotifyParentViaPipe());
 
       for (size_t index = 0;
            index < options_.client_send_request_count;
            ++index) {
-        ChildWaitForReply();
-        if (testing::Test::HasFatalFailure()) {
-          return;
-        }
+        ASSERT_NO_FATAL_FAILURE(ChildWaitForReply());
       }
     }
 
     if (options_.child_wait_for_parent_pipe_late) {
       char c;
       CheckedReadFD(ReadPipeFD(), &c, 1);
       ASSERT_EQ('\0', c);
     }
   }
 
@@ skipping 119 matching lines @@
   // The parent will be waiting in a read() on this pipe, and will proceed to
   // running MachMessageServer() once it’s received.
   void ChildNotifyParentViaPipe() {
     char c = '\0';
     CheckedWriteFD(WritePipeFD(), &c, 1);
   }
 
   // In the child process, sends a request message to the server and then
   // receives a reply message.
   void ChildSendRequestAndWaitForReply() {
-    ChildSendRequest();
-    if (testing::Test::HasFatalFailure()) {
-      return;
-    }
+    ASSERT_NO_FATAL_FAILURE(ChildSendRequest());
 
     if (options_.parent_wait_for_child_pipe &&
         !options_.child_send_all_requests_before_receiving_any_replies) {
       // The parent is waiting to read a byte to indicate that the message has
       // been placed in the queue.
-      ChildNotifyParentViaPipe();
-      if (testing::Test::HasFatalFailure()) {
-        return;
-      }
+      ASSERT_NO_FATAL_FAILURE(ChildNotifyParentViaPipe());
     }
 
-    ChildWaitForReply();
+    ASSERT_NO_FATAL_FAILURE(ChildWaitForReply());
   }
 
   const Options& options_;
 
   // A receive right allocated in the child process. A send right will be
   // created from this right and sent to the parent parent process in the
   // request message.
   base::mac::ScopedMachReceiveRight child_complex_message_port_;
 
   // The send right received in the parent process. This right is stored in a
@@ skipping 248 matching lines @@
   TestMachMessageServer::Options options;
   options.server_options = MACH_RCV_LARGE;
   options.client_send_large = true;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad