Add Multiprocess::SetExpectedChildTermination()

util/test/multiprocess.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 34 matching lines @@
 
   base::ScopedFD pipe_c2p_read;  // child to parent
   base::ScopedFD pipe_c2p_write;  // child to parent
   base::ScopedFD pipe_p2c_read;  // parent to child
   base::ScopedFD pipe_p2c_write;  // parent to child
   pid_t child_pid;  // valid only in parent
 };
 
 }  // namespace internal
 
-Multiprocess::Multiprocess() : info_(NULL) {
+Multiprocess::Multiprocess()
+    : info_(NULL),
+      code_(EXIT_SUCCESS),
+      reason_(kTerminationNormal) {
 }
 
 void Multiprocess::Run() {
   ASSERT_EQ(NULL, info_);
   scoped_ptr<internal::MultiprocessInfo> info(new internal::MultiprocessInfo);
   base::AutoReset<internal::MultiprocessInfo*> reset_info(&info_, info.get());
 
   PreFork();
   if (testing::Test::HasFatalFailure()) {
     return;
@@ skipping 16 matching lines @@
     // be broken, the child’s remote port will become a dead name, and an
     // attempt by the child to look up the service will fail. If this weren’t
     // done, the child might hang while waiting for a parent that has already
     // triggered a fatal assertion failure to do something.
     info.reset();
     info_ = NULL;
 
     int status;
     pid_t wait_pid = waitpid(pid, &status, 0);
     ASSERT_EQ(pid, wait_pid) << ErrnoMessage("waitpid");
-    if (status != 0) {
-      std::string message;
-      if (WIFEXITED(status)) {
-        message = base::StringPrintf("Child exited with code %d",
-                                     WEXITSTATUS(status));
-      } else if (WIFSIGNALED(status)) {
-        message = base::StringPrintf("Child terminated by signal %d (%s) %s",
-                                     WTERMSIG(status),
-                                     strsignal(WTERMSIG(status)),
-                                     WCOREDUMP(status) ? " (core dumped)" : "");
-      }
-      ASSERT_EQ(0, status) << message;
+
+    TerminationReason reason;
+    int code;
+    std::string message;
+    if (WIFEXITED(status)) {
+      reason = kTerminationNormal;
+      code = WEXITSTATUS(status);
+      message = base::StringPrintf("Child exited with code %d, expected", code);
+    } else if (WIFSIGNALED(status)) {
+      reason = kTerminationSignal;
+      code = WTERMSIG(status);
+      message =
+          base::StringPrintf("Child terminated by signal %d (%s)%s, expected",
+                             code,
+                             strsignal(code),
+                             WCOREDUMP(status) ? " (core dumped)" : "");
+    } else {
+      FAIL() << "Unknown termination reason";
+    }
+
+    if (reason_ == kTerminationNormal) {
+      message += base::StringPrintf("exit with code %d", code_);
+    } else if (reason == kTerminationSignal) {
+      message += base::StringPrintf("termination by signal %d", code_);
+    }
+
+    if (reason != reason_ || code != code_) {
+      ADD_FAILURE() << message;
     }
   } else {
     RunChild();
   }
 }
 
+void Multiprocess::SetExpectedChildTermination(TerminationReason reason,
+                                               int code) {
+  reason_ = reason;
+  code_ = code;
+}
+
 Multiprocess::~Multiprocess() {
 }
 
 void Multiprocess::PreFork() {
   int pipe_fds_c2p[2];
   int rv = pipe(pipe_fds_c2p);
   ASSERT_EQ(0, rv) << ErrnoMessage("pipe");
 
   info_->pipe_c2p_read.reset(pipe_fds_c2p[0]);
   info_->pipe_c2p_write.reset(pipe_fds_c2p[1]);
@@ skipping 51 matching lines @@
   if (Test::HasFailure()) {
     // Trigger the ScopedForbidReturn destructor.
     return;
   }
 
   exit(0);
 }
 
 }  // namespace test
 }  // namespace crashpad