Revert "Move mojo edk into mojo/edk"

mojo/edk/system/multiprocess_message_pipe_unittest.cc

Index: mojo/edk/system/multiprocess_message_pipe_unittest.cc
diff --git a/mojo/edk/system/multiprocess_message_pipe_unittest.cc b/mojo/edk/system/multiprocess_message_pipe_unittest.cc
deleted file mode 100644
index 2f22d6737e7c13b393c0f5d10568f3c863447aff..0000000000000000000000000000000000000000
--- a/mojo/edk/system/multiprocess_message_pipe_unittest.cc
+++ /dev/null
@@ -1,523 +0,0 @@
-// Copyright 2013 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 <stdint.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <string>
-#include <vector>
-
-#include "base/bind.h"
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "base/files/scoped_file.h"
-#include "base/files/scoped_temp_dir.h"
-#include "base/location.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "build/build_config.h"  // TODO(vtl): Remove this.
-#include "mojo/edk/embedder/platform_shared_buffer.h"
-#include "mojo/edk/embedder/scoped_platform_handle.h"
-#include "mojo/edk/system/channel.h"
-#include "mojo/edk/system/dispatcher.h"
-#include "mojo/edk/system/message_pipe.h"
-#include "mojo/edk/system/message_pipe_test_utils.h"
-#include "mojo/edk/system/platform_handle_dispatcher.h"
-#include "mojo/edk/system/raw_channel.h"
-#include "mojo/edk/system/shared_buffer_dispatcher.h"
-#include "mojo/edk/system/test_utils.h"
-#include "mojo/edk/test/test_utils.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace mojo {
-namespace system {
-namespace {
-
-class MultiprocessMessagePipeTest
-    : public test::MultiprocessMessagePipeTestBase {};
-
-// For each message received, sends a reply message with the same contents
-// repeated twice, until the other end is closed or it receives "quitquitquit"
-// (which it doesn't reply to). It'll return the number of messages received,
-// not including any "quitquitquit" message, modulo 100.
-MOJO_MULTIPROCESS_TEST_CHILD_MAIN(EchoEcho) {
-  embedder::SimplePlatformSupport platform_support;
-  test::ChannelThread channel_thread(&platform_support);
-  embedder::ScopedPlatformHandle client_platform_handle =
-      mojo::test::MultiprocessTestHelper::client_platform_handle.Pass();
-  CHECK(client_platform_handle.is_valid());
-  scoped_refptr<ChannelEndpoint> ep;
-  scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
-  channel_thread.Start(client_platform_handle.Pass(), ep);
-
-  const std::string quitquitquit("quitquitquit");
-  int rv = 0;
-  for (;; rv = (rv + 1) % 100) {
-    // Wait for our end of the message pipe to be readable.
-    HandleSignalsState hss;
-    MojoResult result =
-        test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss);
-    if (result != MOJO_RESULT_OK) {
-      // It was closed, probably.
-      CHECK_EQ(result, MOJO_RESULT_FAILED_PRECONDITION);
-      CHECK_EQ(hss.satisfied_signals, 0u);
-      CHECK_EQ(hss.satisfiable_signals, 0u);
-      break;
-    } else {
-      CHECK((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
-      CHECK((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
-    }
-
-    std::string read_buffer(1000, '\0');
-    uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
-    CHECK_EQ(mp->ReadMessage(0,
-                             UserPointer<void>(&read_buffer[0]),
-                             MakeUserPointer(&read_buffer_size),
-                             nullptr,
-                             nullptr,
-                             MOJO_READ_MESSAGE_FLAG_NONE),
-             MOJO_RESULT_OK);
-    read_buffer.resize(read_buffer_size);
-    VLOG(2) << "Child got: " << read_buffer;
-
-    if (read_buffer == quitquitquit) {
-      VLOG(2) << "Child quitting.";
-      break;
-    }
-
-    std::string write_buffer = read_buffer + read_buffer;
-    CHECK_EQ(mp->WriteMessage(0,
-                              UserPointer<const void>(write_buffer.data()),
-                              static_cast<uint32_t>(write_buffer.size()),
-                              nullptr,
-                              MOJO_WRITE_MESSAGE_FLAG_NONE),
-             MOJO_RESULT_OK);
-  }
-
-  mp->Close(0);
-  return rv;
-}
-
-// Sends "hello" to child, and expects "hellohello" back.
-TEST_F(MultiprocessMessagePipeTest, Basic) {
-  helper()->StartChild("EchoEcho");
-
-  scoped_refptr<ChannelEndpoint> ep;
-  scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
-  Init(ep);
-
-  std::string hello("hello");
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(0,
-                             UserPointer<const void>(hello.data()),
-                             static_cast<uint32_t>(hello.size()),
-                             nullptr,
-                             MOJO_WRITE_MESSAGE_FLAG_NONE));
-
-  HandleSignalsState hss;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
-  // The child may or may not have closed its end of the message pipe and died
-  // (and we may or may not know it yet), so our end may or may not appear as
-  // writable.
-  EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
-  EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
-
-  std::string read_buffer(1000, '\0');
-  uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
-  CHECK_EQ(mp->ReadMessage(0,
-                           UserPointer<void>(&read_buffer[0]),
-                           MakeUserPointer(&read_buffer_size),
-                           nullptr,
-                           nullptr,
-                           MOJO_READ_MESSAGE_FLAG_NONE),
-           MOJO_RESULT_OK);
-  read_buffer.resize(read_buffer_size);
-  VLOG(2) << "Parent got: " << read_buffer;
-  EXPECT_EQ(hello + hello, read_buffer);
-
-  mp->Close(0);
-
-  // We sent one message.
-  EXPECT_EQ(1 % 100, helper()->WaitForChildShutdown());
-}
-
-// Sends a bunch of messages to the child. Expects them "repeated" back. Waits
-// for the child to close its end before quitting.
-TEST_F(MultiprocessMessagePipeTest, QueueMessages) {
-  helper()->StartChild("EchoEcho");
-
-  scoped_refptr<ChannelEndpoint> ep;
-  scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
-  Init(ep);
-
-  static const size_t kNumMessages = 1001;
-  for (size_t i = 0; i < kNumMessages; i++) {
-    std::string write_buffer(i, 'A' + (i % 26));
-    EXPECT_EQ(MOJO_RESULT_OK,
-              mp->WriteMessage(0,
-                               UserPointer<const void>(write_buffer.data()),
-                               static_cast<uint32_t>(write_buffer.size()),
-                               nullptr,
-                               MOJO_WRITE_MESSAGE_FLAG_NONE));
-  }
-
-  const std::string quitquitquit("quitquitquit");
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(0,
-                             UserPointer<const void>(quitquitquit.data()),
-                             static_cast<uint32_t>(quitquitquit.size()),
-                             nullptr,
-                             MOJO_WRITE_MESSAGE_FLAG_NONE));
-
-  for (size_t i = 0; i < kNumMessages; i++) {
-    HandleSignalsState hss;
-    EXPECT_EQ(MOJO_RESULT_OK,
-              test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
-    // The child may or may not have closed its end of the message pipe and died
-    // (and we may or may not know it yet), so our end may or may not appear as
-    // writable.
-    EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
-    EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
-
-    std::string read_buffer(kNumMessages * 2, '\0');
-    uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
-    CHECK_EQ(mp->ReadMessage(0,
-                             UserPointer<void>(&read_buffer[0]),
-                             MakeUserPointer(&read_buffer_size),
-                             nullptr,
-                             nullptr,
-                             MOJO_READ_MESSAGE_FLAG_NONE),
-             MOJO_RESULT_OK);
-    read_buffer.resize(read_buffer_size);
-
-    EXPECT_EQ(std::string(i * 2, 'A' + (i % 26)), read_buffer);
-  }
-
-  // Wait for it to become readable, which should fail (since we sent
-  // "quitquitquit").
-  HandleSignalsState hss;
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
-  EXPECT_EQ(0u, hss.satisfied_signals);
-  EXPECT_EQ(0u, hss.satisfiable_signals);
-
-  mp->Close(0);
-
-  EXPECT_EQ(static_cast<int>(kNumMessages % 100),
-            helper()->WaitForChildShutdown());
-}
-
-MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckSharedBuffer) {
-  embedder::SimplePlatformSupport platform_support;
-  test::ChannelThread channel_thread(&platform_support);
-  embedder::ScopedPlatformHandle client_platform_handle =
-      mojo::test::MultiprocessTestHelper::client_platform_handle.Pass();
-  CHECK(client_platform_handle.is_valid());
-  scoped_refptr<ChannelEndpoint> ep;
-  scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
-  channel_thread.Start(client_platform_handle.Pass(), ep);
-
-  // Wait for the first message from our parent.
-  HandleSignalsState hss;
-  CHECK_EQ(test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss),
-           MOJO_RESULT_OK);
-  // In this test, the parent definitely doesn't close its end of the message
-  // pipe before we do.
-  CHECK_EQ(hss.satisfied_signals,
-           MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
-  CHECK_EQ(hss.satisfiable_signals,
-           MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
-
-  // It should have a shared buffer.
-  std::string read_buffer(100, '\0');
-  uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
-  DispatcherVector dispatchers;
-  uint32_t num_dispatchers = 10;  // Maximum number to receive.
-  CHECK_EQ(mp->ReadMessage(0,
-                           UserPointer<void>(&read_buffer[0]),
-                           MakeUserPointer(&num_bytes),
-                           &dispatchers,
-                           &num_dispatchers,
-                           MOJO_READ_MESSAGE_FLAG_NONE),
-           MOJO_RESULT_OK);
-  read_buffer.resize(num_bytes);
-  CHECK_EQ(read_buffer, std::string("go 1"));
-  CHECK_EQ(num_dispatchers, 1u);
-
-  CHECK_EQ(dispatchers[0]->GetType(), Dispatcher::kTypeSharedBuffer);
-
-  scoped_refptr<SharedBufferDispatcher> dispatcher(
-      static_cast<SharedBufferDispatcher*>(dispatchers[0].get()));
-
-  // Make a mapping.
-  scoped_ptr<embedder::PlatformSharedBufferMapping> mapping;
-  CHECK_EQ(dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping),
-           MOJO_RESULT_OK);
-  CHECK(mapping);
-  CHECK(mapping->GetBase());
-  CHECK_EQ(mapping->GetLength(), 100u);
-
-  // Write some stuff to the shared buffer.
-  static const char kHello[] = "hello";
-  memcpy(mapping->GetBase(), kHello, sizeof(kHello));
-
-  // We should be able to close the dispatcher now.
-  dispatcher->Close();
-
-  // And send a message to signal that we've written stuff.
-  const std::string go2("go 2");
-  CHECK_EQ(mp->WriteMessage(0,
-                            UserPointer<const void>(&go2[0]),
-                            static_cast<uint32_t>(go2.size()),
-                            nullptr,
-                            MOJO_WRITE_MESSAGE_FLAG_NONE),
-           MOJO_RESULT_OK);
-
-  // Now wait for our parent to send us a message.
-  hss = HandleSignalsState();
-  CHECK_EQ(test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss),
-           MOJO_RESULT_OK);
-  CHECK_EQ(hss.satisfied_signals,
-           MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
-  CHECK_EQ(hss.satisfiable_signals,
-           MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
-
-  read_buffer = std::string(100, '\0');
-  num_bytes = static_cast<uint32_t>(read_buffer.size());
-  CHECK_EQ(mp->ReadMessage(0,
-                           UserPointer<void>(&read_buffer[0]),
-                           MakeUserPointer(&num_bytes),
-                           nullptr,
-                           nullptr,
-                           MOJO_READ_MESSAGE_FLAG_NONE),
-           MOJO_RESULT_OK);
-  read_buffer.resize(num_bytes);
-  CHECK_EQ(read_buffer, std::string("go 3"));
-
-  // It should have written something to the shared buffer.
-  static const char kWorld[] = "world!!!";
-  CHECK_EQ(memcmp(mapping->GetBase(), kWorld, sizeof(kWorld)), 0);
-
-  // And we're done.
-  mp->Close(0);
-
-  return 0;
-}
-
-#if defined(OS_POSIX)
-#define MAYBE_SharedBufferPassing SharedBufferPassing
-#else
-// Not yet implemented (on Windows).
-#define MAYBE_SharedBufferPassing DISABLED_SharedBufferPassing
-#endif
-TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) {
-  helper()->StartChild("CheckSharedBuffer");
-
-  scoped_refptr<ChannelEndpoint> ep;
-  scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
-  Init(ep);
-
-  // Make a shared buffer.
-  scoped_refptr<SharedBufferDispatcher> dispatcher;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            SharedBufferDispatcher::Create(
-                platform_support(),
-                SharedBufferDispatcher::kDefaultCreateOptions,
-                100,
-                &dispatcher));
-  ASSERT_TRUE(dispatcher.get());
-
-  // Make a mapping.
-  scoped_ptr<embedder::PlatformSharedBufferMapping> mapping;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
-  ASSERT_TRUE(mapping);
-  ASSERT_TRUE(mapping->GetBase());
-  ASSERT_EQ(100u, mapping->GetLength());
-
-  // Send the shared buffer.
-  const std::string go1("go 1");
-  DispatcherTransport transport(
-      test::DispatcherTryStartTransport(dispatcher.get()));
-  ASSERT_TRUE(transport.is_valid());
-
-  std::vector<DispatcherTransport> transports;
-  transports.push_back(transport);
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(0,
-                             UserPointer<const void>(&go1[0]),
-                             static_cast<uint32_t>(go1.size()),
-                             &transports,
-                             MOJO_WRITE_MESSAGE_FLAG_NONE));
-  transport.End();
-
-  EXPECT_TRUE(dispatcher->HasOneRef());
-  dispatcher = nullptr;
-
-  // Wait for a message from the child.
-  HandleSignalsState hss;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
-  EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
-  EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
-
-  std::string read_buffer(100, '\0');
-  uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp->ReadMessage(0,
-                            UserPointer<void>(&read_buffer[0]),
-                            MakeUserPointer(&num_bytes),
-                            nullptr,
-                            nullptr,
-                            MOJO_READ_MESSAGE_FLAG_NONE));
-  read_buffer.resize(num_bytes);
-  EXPECT_EQ(std::string("go 2"), read_buffer);
-
-  // After we get it, the child should have written something to the shared
-  // buffer.
-  static const char kHello[] = "hello";
-  EXPECT_EQ(0, memcmp(mapping->GetBase(), kHello, sizeof(kHello)));
-
-  // Now we'll write some stuff to the shared buffer.
-  static const char kWorld[] = "world!!!";
-  memcpy(mapping->GetBase(), kWorld, sizeof(kWorld));
-
-  // And send a message to signal that we've written stuff.
-  const std::string go3("go 3");
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(0,
-                             UserPointer<const void>(&go3[0]),
-                             static_cast<uint32_t>(go3.size()),
-                             nullptr,
-                             MOJO_WRITE_MESSAGE_FLAG_NONE));
-
-  // Wait for |mp| to become readable, which should fail.
-  hss = HandleSignalsState();
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
-  EXPECT_EQ(0u, hss.satisfied_signals);
-  EXPECT_EQ(0u, hss.satisfiable_signals);
-
-  mp->Close(0);
-
-  EXPECT_EQ(0, helper()->WaitForChildShutdown());
-}
-
-MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckPlatformHandleFile) {
-  embedder::SimplePlatformSupport platform_support;
-  test::ChannelThread channel_thread(&platform_support);
-  embedder::ScopedPlatformHandle client_platform_handle =
-      mojo::test::MultiprocessTestHelper::client_platform_handle.Pass();
-  CHECK(client_platform_handle.is_valid());
-  scoped_refptr<ChannelEndpoint> ep;
-  scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
-  channel_thread.Start(client_platform_handle.Pass(), ep);
-
-  HandleSignalsState hss;
-  CHECK_EQ(test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss),
-           MOJO_RESULT_OK);
-  CHECK_EQ(hss.satisfied_signals,
-           MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
-  CHECK_EQ(hss.satisfiable_signals,
-           MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
-
-  std::string read_buffer(100, '\0');
-  uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
-  DispatcherVector dispatchers;
-  uint32_t num_dispatchers = 10;  // Maximum number to receive.
-  CHECK_EQ(mp->ReadMessage(0,
-                           UserPointer<void>(&read_buffer[0]),
-                           MakeUserPointer(&num_bytes),
-                           &dispatchers,
-                           &num_dispatchers,
-                           MOJO_READ_MESSAGE_FLAG_NONE),
-           MOJO_RESULT_OK);
-  mp->Close(0);
-
-  read_buffer.resize(num_bytes);
-  CHECK_EQ(read_buffer, std::string("hello"));
-  CHECK_EQ(num_dispatchers, 1u);
-
-  CHECK_EQ(dispatchers[0]->GetType(), Dispatcher::kTypePlatformHandle);
-
-  scoped_refptr<PlatformHandleDispatcher> dispatcher(
-      static_cast<PlatformHandleDispatcher*>(dispatchers[0].get()));
-  embedder::ScopedPlatformHandle h = dispatcher->PassPlatformHandle().Pass();
-  CHECK(h.is_valid());
-  dispatcher->Close();
-
-  base::ScopedFILE fp(mojo::test::FILEFromPlatformHandle(h.Pass(), "r"));
-  CHECK(fp);
-  std::string fread_buffer(100, '\0');
-  size_t bytes_read = fread(&fread_buffer[0], 1, fread_buffer.size(), fp.get());
-  fread_buffer.resize(bytes_read);
-  CHECK_EQ(fread_buffer, "world");
-
-  return 0;
-}
-
-#if defined(OS_POSIX)
-#define MAYBE_PlatformHandlePassing PlatformHandlePassing
-#else
-// Not yet implemented (on Windows).
-#define MAYBE_PlatformHandlePassing DISABLED_PlatformHandlePassing
-#endif
-TEST_F(MultiprocessMessagePipeTest, MAYBE_PlatformHandlePassing) {
-  base::ScopedTempDir temp_dir;
-  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-
-  helper()->StartChild("CheckPlatformHandleFile");
-
-  scoped_refptr<ChannelEndpoint> ep;
-  scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
-  Init(ep);
-
-  base::FilePath unused;
-  base::ScopedFILE fp(
-      CreateAndOpenTemporaryFileInDir(temp_dir.path(), &unused));
-  const std::string world("world");
-  ASSERT_EQ(fwrite(&world[0], 1, world.size(), fp.get()), world.size());
-  fflush(fp.get());
-  rewind(fp.get());
-
-  embedder::ScopedPlatformHandle h(
-      mojo::test::PlatformHandleFromFILE(fp.Pass()));
-  scoped_refptr<PlatformHandleDispatcher> dispatcher(
-      new PlatformHandleDispatcher(h.Pass()));
-
-  const std::string hello("hello");
-  DispatcherTransport transport(
-      test::DispatcherTryStartTransport(dispatcher.get()));
-  ASSERT_TRUE(transport.is_valid());
-
-  std::vector<DispatcherTransport> transports;
-  transports.push_back(transport);
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(0,
-                             UserPointer<const void>(&hello[0]),
-                             static_cast<uint32_t>(hello.size()),
-                             &transports,
-                             MOJO_WRITE_MESSAGE_FLAG_NONE));
-  transport.End();
-
-  EXPECT_TRUE(dispatcher->HasOneRef());
-  dispatcher = nullptr;
-
-  // Wait for it to become readable, which should fail.
-  HandleSignalsState hss;
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
-  EXPECT_EQ(0u, hss.satisfied_signals);
-  EXPECT_EQ(0u, hss.satisfiable_signals);
-
-  mp->Close(0);
-
-  EXPECT_EQ(0, helper()->WaitForChildShutdown());
-}
-
-}  // namespace
-}  // namespace system
-}  // namespace mojo