Disable BootstrapSandbox tests on macOS Sierra.

sandbox/mac/bootstrap_sandbox_unittest.mm

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "sandbox/mac/bootstrap_sandbox.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 #import <Foundation/Foundation.h>
 #include <mach/mach.h>
 #include <servers/bootstrap.h>
@@ skipping 120 matching lines @@
   EXPECT_EQ(0, code);
 
   [observer waitForNotification];
   EXPECT_EQ(1, [observer receivedCount]);
   EXPECT_EQ(process.Pid(), [[observer object] intValue]);
 }
 
 // Run the test with the sandbox enabled without notifications on the policy
 // whitelist.
 TEST_F(BootstrapSandboxTest, DistributedNotifications_SandboxDeny) {
+  if (base::mac::IsOSSierraOrLater()) {
+    LOG(ERROR) << "BootstrapSandbox does not work on macOS Sierra or later.";
+    return;
+  }
+
   base::scoped_nsobject<DistributedNotificationObserver> observer(
       [[DistributedNotificationObserver alloc] init]);
 
   sandbox_->RegisterSandboxPolicy(1, BaselinePolicy());
   RunChildWithPolicy(1, kNotificationTestMain, NULL);
 
   [observer waitForNotification];
   EXPECT_EQ(0, [observer receivedCount]);
   EXPECT_EQ(nil, [observer object]);
 }
 
 // Run the test with notifications permitted.
 TEST_F(BootstrapSandboxTest, DistributedNotifications_SandboxAllow) {
+  if (base::mac::IsOSSierraOrLater()) {
+    LOG(ERROR) << "BootstrapSandbox does not work on macOS Sierra or later.";
+    return;
+  }
+
   base::scoped_nsobject<DistributedNotificationObserver> observer(
       [[DistributedNotificationObserver alloc] init]);
 
   BootstrapSandboxPolicy policy(BaselinePolicy());
   // 10.9:
   policy.rules["com.apple.distributed_notifications@Uv3"] = Rule(POLICY_ALLOW);
   policy.rules["com.apple.distributed_notifications@1v3"] = Rule(POLICY_ALLOW);
   // 10.6:
   policy.rules["com.apple.system.notification_center"] = Rule(POLICY_ALLOW);
   policy.rules["com.apple.distributed_notifications.2"] = Rule(POLICY_ALLOW);
@@ skipping 10 matching lines @@
 MULTIPROCESS_TEST_MAIN(PostNotification) {
   [[NSDistributedNotificationCenter defaultCenter]
       postNotificationName:kTestNotification
                     object:[NSString stringWithFormat:@"%d", getpid()]];
   return 0;
 }
 
 const char kTestServer[] = "org.chromium.test_bootstrap_server";
 
 TEST_F(BootstrapSandboxTest, PolicyDenyError) {
+  if (base::mac::IsOSSierraOrLater()) {
+    LOG(ERROR) << "BootstrapSandbox does not work on macOS Sierra or later.";
+    return;
+  }
   BootstrapSandboxPolicy policy(BaselinePolicy());
   policy.rules[kTestServer] = Rule(POLICY_DENY_ERROR);
   sandbox_->RegisterSandboxPolicy(1, policy);
 
   RunChildWithPolicy(1, "PolicyDenyError", NULL);
 }
 
 MULTIPROCESS_TEST_MAIN(PolicyDenyError) {
   mach_port_t port = MACH_PORT_NULL;
   kern_return_t kr = bootstrap_look_up(bootstrap_port, kTestServer,
       &port);
   CHECK_EQ(BOOTSTRAP_UNKNOWN_SERVICE, kr);
   CHECK(port == MACH_PORT_NULL);
 
   kr = bootstrap_look_up(bootstrap_port, "org.chromium.some_other_server",
       &port);
   CHECK_EQ(BOOTSTRAP_UNKNOWN_SERVICE, kr);
   CHECK(port == MACH_PORT_NULL);
 
   return 0;
 }
 
 TEST_F(BootstrapSandboxTest, PolicyDenyDummyPort) {
+  if (base::mac::IsOSSierraOrLater()) {
+    LOG(ERROR) << "BootstrapSandbox does not work on macOS Sierra or later.";
+    return;
+  }
   BootstrapSandboxPolicy policy(BaselinePolicy());
   policy.rules[kTestServer] = Rule(POLICY_DENY_DUMMY_PORT);
   sandbox_->RegisterSandboxPolicy(1, policy);
 
   RunChildWithPolicy(1, "PolicyDenyDummyPort", NULL);
 }
 
 MULTIPROCESS_TEST_MAIN(PolicyDenyDummyPort) {
   mach_port_t port = MACH_PORT_NULL;
   kern_return_t kr = bootstrap_look_up(bootstrap_port, kTestServer,
       &port);
   CHECK_EQ(KERN_SUCCESS, kr);
   CHECK(port != MACH_PORT_NULL);
   return 0;
 }
 
 struct SubstitutePortAckSend {
   mach_msg_header_t header;
   char buf[32];
 };
 
 struct SubstitutePortAckRecv : public SubstitutePortAckSend {
   mach_msg_trailer_t trailer;
 };
 
 const char kSubstituteAck[] = "Hello, this is doge!";
 
 TEST_F(BootstrapSandboxTest, PolicySubstitutePort) {
+  if (base::mac::IsOSSierraOrLater()) {
+    LOG(ERROR) << "BootstrapSandbox does not work on macOS Sierra or later.";
+    return;
+  }
+
   mach_port_t task = mach_task_self();
 
   mach_port_t port;
   ASSERT_EQ(KERN_SUCCESS, mach_port_allocate(task, MACH_PORT_RIGHT_RECEIVE,
       &port));
   base::mac::ScopedMachReceiveRight scoped_port(port);
 
   mach_port_urefs_t send_rights = 0;
   ASSERT_EQ(KERN_SUCCESS, mach_port_get_refs(task, port, MACH_PORT_RIGHT_SEND,
       &send_rights));
@@ skipping 96 matching lines @@
       &send_rights));
   EXPECT_EQ(2u, send_rights);
 }
 
 const char kDefaultRuleTestAllow[] =
     "org.chromium.sandbox.test.DefaultRuleAllow";
 const char kDefaultRuleTestDeny[] =
     "org.chromium.sandbox.test.DefaultRuleAllow.Deny";
 
 TEST_F(BootstrapSandboxTest, DefaultRuleAllow) {
+  if (base::mac::IsOSSierraOrLater()) {
+    LOG(ERROR) << "BootstrapSandbox does not work on macOS Sierra or later.";
+    return;
+  }
+
   mach_port_t task = mach_task_self();
 
   mach_port_t port;
   ASSERT_EQ(KERN_SUCCESS, mach_port_allocate(task, MACH_PORT_RIGHT_RECEIVE,
       &port));
   base::mac::ScopedMachReceiveRight scoped_port_recv(port);
 
   ASSERT_EQ(KERN_SUCCESS, mach_port_insert_right(task, port, port,
       MACH_MSG_TYPE_MAKE_SEND));
   base::mac::ScopedMachSendRight scoped_port_send(port);
@@ skipping 47 matching lines @@
   msg.header.msgh_remote_port = port;
   msg.header.msgh_bits = MACH_MSGH_BITS_REMOTE(MACH_MSG_TYPE_MOVE_SEND);
   strncpy(msg.buf, kSubstituteAck, sizeof(msg.buf));
 
   CHECK_EQ(KERN_SUCCESS, mach_msg_send(&msg.header));
 
   return 0;
 }
 
 TEST_F(BootstrapSandboxTest, ChildOutliveSandbox) {
+  if (base::mac::IsOSSierraOrLater()) {
+    LOG(ERROR) << "BootstrapSandbox does not work on macOS Sierra or later.";
+    return;
+  }
+
   const int kTestPolicyId = 1;
   mach_port_t task = mach_task_self();
 
   // Create a server port.
   mach_port_t port;
   ASSERT_EQ(KERN_SUCCESS, mach_port_allocate(task, MACH_PORT_RIGHT_RECEIVE,
       &port));
   base::mac::ScopedMachReceiveRight scoped_port_recv(port);
 
   ASSERT_EQ(KERN_SUCCESS, mach_port_insert_right(task, port, port,
@@ skipping 79 matching lines @@
   kr = mach_msg_receive(&rcv_msg.header);
   MACH_CHECK(kr == KERN_SUCCESS, kr) << "mach_msg_receive";
 
   // Try to message the sandbox.
   bootstrap_look_up(bootstrap_port, "test", &port);
 
   return 0;
 }
 
 }  // namespace sandbox