ExceptionPorts test: accept a port of MACH_PORT_NULL as “no handler.”

util/mach/exception_ports_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 26 matching lines @@
 
 using namespace crashpad;
 using namespace crashpad::test;
 
 // Calls GetExceptionPorts() on its |exception_ports| argument to look up the
 // EXC_MASK_CRASH handler. If |expect_port| is not MACH_PORT_NULL, it expects to
 // find a handler for this mask whose port matches |expect_port| and whose
 // behavior matches |expect_behavior| exactly. In this case, if
 // |expect_behavior| is a state-carrying behavior, the looked-up thread state
 // flavor is expected to be MACHINE_THREAD_STATE, otherwise, it is expected to
-// be THREAD_STATE_NONE. If |expect_port| is MACH_PORT_NULL, no handler for
-// EXC_MASK_CRASH is expected to be found.
+// be THREAD_STATE_NONE. If |expect_port| is MACH_PORT_NULL, either no handler
+// for EXC_MASK_CRASH is expected to be found, or a handler whose port is
+// MACH_PORT_NULL is expected, with the behavior and flavor being irrelevant.
 //
 // A second GetExceptionPorts() lookup is also performed on a wider exception
 // mask, EXC_MASK_ALL | EXC_MASK_CRASH. The EXC_MASK_CRASH handler’s existence
 // and properties from this second lookup are validated in the same way.
 //
 // This function uses gtest EXPECT_* and ASSERT_* macros to perform its
 // validation.
 void TestGetExceptionPorts(const ExceptionPorts& exception_ports,
                            mach_port_t expect_port,
                            exception_behavior_t expect_behavior) {
   const exception_mask_t kExceptionMask = EXC_MASK_CRASH;
 
   thread_state_flavor_t expect_flavor = (expect_behavior == EXCEPTION_DEFAULT)
                                             ? THREAD_STATE_NONE
                                             : MACHINE_THREAD_STATE;
 
   std::vector<ExceptionPorts::ExceptionHandler> crash_handler;
   ASSERT_TRUE(
       exception_ports.GetExceptionPorts(kExceptionMask, &crash_handler));
 
-  if (expect_port != MACH_PORT_NULL) {
+  if (expect_port != MACH_PORT_NULL || !crash_handler.empty()) {
     ASSERT_EQ(1u, crash_handler.size());
     base::mac::ScopedMachSendRight port_owner(crash_handler[0].port);
 
     EXPECT_EQ(kExceptionMask, crash_handler[0].mask);
     EXPECT_EQ(expect_port, crash_handler[0].port);
-    EXPECT_EQ(expect_behavior, crash_handler[0].behavior);
-    EXPECT_EQ(expect_flavor, crash_handler[0].flavor);
-  } else {
-    EXPECT_TRUE(crash_handler.empty());
+    if (expect_port != MACH_PORT_NULL) {
+      EXPECT_EQ(expect_behavior, crash_handler[0].behavior);
+      EXPECT_EQ(expect_flavor, crash_handler[0].flavor);
+    }
   }
 
   std::vector<ExceptionPorts::ExceptionHandler> handlers;
   ASSERT_TRUE(exception_ports.GetExceptionPorts(
       ExcMaskAll() | EXC_MASK_CRASH, &handlers));
 
   EXPECT_GE(handlers.size(), crash_handler.size());
   bool found = false;
   for (const ExceptionPorts::ExceptionHandler& handler : handlers) {
     if ((handler.mask & kExceptionMask) != 0) {
       base::mac::ScopedMachSendRight port_owner(handler.port);
 
-      EXPECT_FALSE(found);
-      found = true;
+      if (handler.port != MACH_PORT_NULL) {
+        EXPECT_FALSE(found);
+        found = true;
+      }
+
       EXPECT_EQ(expect_port, handler.port);
-      EXPECT_EQ(expect_behavior, handler.behavior);
-      EXPECT_EQ(expect_flavor, handler.flavor);
+      if (expect_port != MACH_PORT_NULL) {
+        EXPECT_EQ(expect_behavior, handler.behavior);
+        EXPECT_EQ(expect_flavor, handler.flavor);
+      }
     }
   }
 
   if (expect_port != MACH_PORT_NULL) {
     EXPECT_TRUE(found);
   } else {
     EXPECT_FALSE(found);
   }
 }
 
@@ skipping 468 matching lines @@
   rv = implicit_host_ports.GetExceptionPorts(
       ExcMaskAll() | EXC_MASK_CRASH, &handlers);
   if (geteuid() == 0) {
     EXPECT_TRUE(rv);
   } else {
     EXPECT_FALSE(rv);
   }
 }
 
 }  // namespace