Move //mojo/{public, edk} underneath //third_party

mojo/edk/system/core_unittest.cc

Index: mojo/edk/system/core_unittest.cc
diff --git a/mojo/edk/system/core_unittest.cc b/mojo/edk/system/core_unittest.cc
deleted file mode 100644
index b78930110bcbaafcbd1ff8c27d7fd0e1cc6f8b10..0000000000000000000000000000000000000000
--- a/mojo/edk/system/core_unittest.cc
+++ /dev/null
@@ -1,1317 +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 "mojo/edk/system/core.h"
-
-#include <stdint.h>
-
-#include <limits>
-
-#include "base/bind.h"
-#include "base/threading/platform_thread.h"
-#include "base/time/time.h"
-#include "mojo/edk/system/awakable.h"
-#include "mojo/edk/system/core_test_base.h"
-
-namespace mojo {
-namespace system {
-namespace {
-
-const MojoHandleSignalsState kEmptyMojoHandleSignalsState = {0u, 0u};
-const MojoHandleSignalsState kFullMojoHandleSignalsState = {~0u, ~0u};
-const MojoHandleSignals kAllSignals = MOJO_HANDLE_SIGNAL_READABLE |
-                                      MOJO_HANDLE_SIGNAL_WRITABLE |
-                                      MOJO_HANDLE_SIGNAL_PEER_CLOSED;
-
-typedef test::CoreTestBase CoreTest;
-
-TEST_F(CoreTest, GetTimeTicksNow) {
-  const MojoTimeTicks start = core()->GetTimeTicksNow();
-  EXPECT_NE(static_cast<MojoTimeTicks>(0), start)
-      << "GetTimeTicksNow should return nonzero value";
-  base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(15));
-  const MojoTimeTicks finish = core()->GetTimeTicksNow();
-  // Allow for some fuzz in sleep.
-  EXPECT_GE((finish - start), static_cast<MojoTimeTicks>(8000))
-      << "Sleeping should result in increasing time ticks";
-}
-
-TEST_F(CoreTest, Basic) {
-  MockHandleInfo info;
-
-  EXPECT_EQ(0u, info.GetCtorCallCount());
-  MojoHandle h = CreateMockHandle(&info);
-  EXPECT_EQ(1u, info.GetCtorCallCount());
-  EXPECT_NE(h, MOJO_HANDLE_INVALID);
-
-  EXPECT_EQ(0u, info.GetWriteMessageCallCount());
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteMessage(h, NullUserPointer(), 0, NullUserPointer(), 0,
-                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
-  EXPECT_EQ(1u, info.GetWriteMessageCallCount());
-
-  EXPECT_EQ(0u, info.GetReadMessageCallCount());
-  uint32_t num_bytes = 0;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      core()->ReadMessage(h, NullUserPointer(), MakeUserPointer(&num_bytes),
-                          NullUserPointer(), NullUserPointer(),
-                          MOJO_READ_MESSAGE_FLAG_NONE));
-  EXPECT_EQ(1u, info.GetReadMessageCallCount());
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadMessage(h, NullUserPointer(), NullUserPointer(),
-                                NullUserPointer(), NullUserPointer(),
-                                MOJO_READ_MESSAGE_FLAG_NONE));
-  EXPECT_EQ(2u, info.GetReadMessageCallCount());
-
-  EXPECT_EQ(0u, info.GetWriteDataCallCount());
-  EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
-            core()->WriteData(h, NullUserPointer(), NullUserPointer(),
-                              MOJO_WRITE_DATA_FLAG_NONE));
-  EXPECT_EQ(1u, info.GetWriteDataCallCount());
-
-  EXPECT_EQ(0u, info.GetBeginWriteDataCallCount());
-  EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
-            core()->BeginWriteData(h, NullUserPointer(), NullUserPointer(),
-                                   MOJO_WRITE_DATA_FLAG_NONE));
-  EXPECT_EQ(1u, info.GetBeginWriteDataCallCount());
-
-  EXPECT_EQ(0u, info.GetEndWriteDataCallCount());
-  EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, core()->EndWriteData(h, 0));
-  EXPECT_EQ(1u, info.GetEndWriteDataCallCount());
-
-  EXPECT_EQ(0u, info.GetReadDataCallCount());
-  EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
-            core()->ReadData(h, NullUserPointer(), NullUserPointer(),
-                             MOJO_READ_DATA_FLAG_NONE));
-  EXPECT_EQ(1u, info.GetReadDataCallCount());
-
-  EXPECT_EQ(0u, info.GetBeginReadDataCallCount());
-  EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
-            core()->BeginReadData(h, NullUserPointer(), NullUserPointer(),
-                                  MOJO_READ_DATA_FLAG_NONE));
-  EXPECT_EQ(1u, info.GetBeginReadDataCallCount());
-
-  EXPECT_EQ(0u, info.GetEndReadDataCallCount());
-  EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, core()->EndReadData(h, 0));
-  EXPECT_EQ(1u, info.GetEndReadDataCallCount());
-
-  EXPECT_EQ(0u, info.GetAddAwakableCallCount());
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE,
-                         NullUserPointer()));
-  EXPECT_EQ(1u, info.GetAddAwakableCallCount());
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 0, NullUserPointer()));
-  EXPECT_EQ(2u, info.GetAddAwakableCallCount());
-  MojoHandleSignalsState hss = kFullMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE,
-                         MakeUserPointer(&hss)));
-  EXPECT_EQ(3u, info.GetAddAwakableCallCount());
-  EXPECT_EQ(0u, hss.satisfied_signals);
-  EXPECT_EQ(0u, hss.satisfiable_signals);
-  EXPECT_EQ(
-      MOJO_RESULT_FAILED_PRECONDITION,
-      core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000, NullUserPointer()));
-  EXPECT_EQ(4u, info.GetAddAwakableCallCount());
-  hss = kFullMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000,
-                         MakeUserPointer(&hss)));
-  EXPECT_EQ(5u, info.GetAddAwakableCallCount());
-  EXPECT_EQ(0u, hss.satisfied_signals);
-  EXPECT_EQ(0u, hss.satisfiable_signals);
-
-  MojoHandleSignals handle_signals = ~MOJO_HANDLE_SIGNAL_NONE;
-  EXPECT_EQ(
-      MOJO_RESULT_FAILED_PRECONDITION,
-      core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1,
-                       MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
-                       NullUserPointer()));
-  EXPECT_EQ(6u, info.GetAddAwakableCallCount());
-  uint32_t result_index = static_cast<uint32_t>(-1);
-  EXPECT_EQ(
-      MOJO_RESULT_FAILED_PRECONDITION,
-      core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1,
-                       MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
-                       NullUserPointer()));
-  EXPECT_EQ(7u, info.GetAddAwakableCallCount());
-  EXPECT_EQ(0u, result_index);
-  hss = kFullMojoHandleSignalsState;
-  EXPECT_EQ(
-      MOJO_RESULT_FAILED_PRECONDITION,
-      core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1,
-                       MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
-                       MakeUserPointer(&hss)));
-  EXPECT_EQ(8u, info.GetAddAwakableCallCount());
-  EXPECT_EQ(0u, hss.satisfied_signals);
-  EXPECT_EQ(0u, hss.satisfiable_signals);
-  result_index = static_cast<uint32_t>(-1);
-  hss = kFullMojoHandleSignalsState;
-  EXPECT_EQ(
-      MOJO_RESULT_FAILED_PRECONDITION,
-      core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1,
-                       MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
-                       MakeUserPointer(&hss)));
-  EXPECT_EQ(9u, info.GetAddAwakableCallCount());
-  EXPECT_EQ(0u, result_index);
-  EXPECT_EQ(0u, hss.satisfied_signals);
-  EXPECT_EQ(0u, hss.satisfiable_signals);
-
-  EXPECT_EQ(0u, info.GetDtorCallCount());
-  EXPECT_EQ(0u, info.GetCloseCallCount());
-  EXPECT_EQ(0u, info.GetCancelAllAwakablesCallCount());
-  EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
-  EXPECT_EQ(1u, info.GetCancelAllAwakablesCallCount());
-  EXPECT_EQ(1u, info.GetCloseCallCount());
-  EXPECT_EQ(1u, info.GetDtorCallCount());
-
-  // No awakables should ever have ever been added.
-  EXPECT_EQ(0u, info.GetRemoveAwakableCallCount());
-}
-
-TEST_F(CoreTest, InvalidArguments) {
-  // |Close()|:
-  {
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(MOJO_HANDLE_INVALID));
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(10));
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(1000000000));
-
-    // Test a double-close.
-    MockHandleInfo info;
-    MojoHandle h = CreateMockHandle(&info);
-    EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
-    EXPECT_EQ(1u, info.GetCloseCallCount());
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(h));
-    EXPECT_EQ(1u, info.GetCloseCallCount());
-  }
-
-  // |Wait()|:
-  {
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->Wait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE,
-                           MOJO_DEADLINE_INDEFINITE, NullUserPointer()));
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->Wait(10, ~MOJO_HANDLE_SIGNAL_NONE,
-                           MOJO_DEADLINE_INDEFINITE, NullUserPointer()));
-
-    MojoHandleSignalsState hss = kFullMojoHandleSignalsState;
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->Wait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE,
-                           MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&hss)));
-    // On invalid argument, it shouldn't modify the handle signals state.
-    EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
-              hss.satisfied_signals);
-    EXPECT_EQ(kFullMojoHandleSignalsState.satisfiable_signals,
-              hss.satisfiable_signals);
-    hss = kFullMojoHandleSignalsState;
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->Wait(10, ~MOJO_HANDLE_SIGNAL_NONE,
-                           MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&hss)));
-    // On invalid argument, it shouldn't modify the handle signals state.
-    EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
-              hss.satisfied_signals);
-    EXPECT_EQ(kFullMojoHandleSignalsState.satisfiable_signals,
-              hss.satisfiable_signals);
-  }
-
-  // |WaitMany()|:
-  {
-    MojoHandle handles[2] = {MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID};
-    MojoHandleSignals signals[2] = {~MOJO_HANDLE_SIGNAL_NONE,
-                                    ~MOJO_HANDLE_SIGNAL_NONE};
-    EXPECT_EQ(
-        MOJO_RESULT_INVALID_ARGUMENT,
-        core()->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), 0,
-                         MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
-                         NullUserPointer()));
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WaitMany(NullUserPointer(), MakeUserPointer(signals), 0,
-                               MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
-                               NullUserPointer()));
-    // If |num_handles| is invalid, it should leave |result_index| and
-    // |signals_states| alone.
-    // (We use -1 internally; make sure that doesn't leak.)
-    uint32_t result_index = 123;
-    MojoHandleSignalsState hss = kFullMojoHandleSignalsState;
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WaitMany(NullUserPointer(), MakeUserPointer(signals), 0,
-                               MOJO_DEADLINE_INDEFINITE,
-                               MakeUserPointer(&result_index),
-                               MakeUserPointer(&hss)));
-    EXPECT_EQ(123u, result_index);
-    EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
-              hss.satisfied_signals);
-    EXPECT_EQ(kFullMojoHandleSignalsState.satisfiable_signals,
-              hss.satisfiable_signals);
-
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WaitMany(MakeUserPointer(handles), NullUserPointer(), 0,
-                               MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
-                               NullUserPointer()));
-    EXPECT_EQ(
-        MOJO_RESULT_INVALID_ARGUMENT,
-        core()->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), 1,
-                         MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
-                         NullUserPointer()));
-    // But if a handle is bad, then it should set |result_index| but still leave
-    // |signals_states| alone.
-    result_index = static_cast<uint32_t>(-1);
-    hss = kFullMojoHandleSignalsState;
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WaitMany(
-                  MakeUserPointer(handles), MakeUserPointer(signals), 1,
-                  MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
-                  MakeUserPointer(&hss)));
-    EXPECT_EQ(0u, result_index);
-    EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
-              hss.satisfied_signals);
-    EXPECT_EQ(kFullMojoHandleSignalsState.satisfiable_signals,
-              hss.satisfiable_signals);
-
-    MockHandleInfo info[2];
-    handles[0] = CreateMockHandle(&info[0]);
-
-    result_index = static_cast<uint32_t>(-1);
-    hss = kFullMojoHandleSignalsState;
-    EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-              core()->WaitMany(
-                  MakeUserPointer(handles), MakeUserPointer(signals), 1,
-                  MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
-                  MakeUserPointer(&hss)));
-    EXPECT_EQ(0u, result_index);
-    EXPECT_EQ(0u, hss.satisfied_signals);
-    EXPECT_EQ(0u, hss.satisfiable_signals);
-
-    // On invalid argument, it'll leave |signals_states| alone.
-    result_index = static_cast<uint32_t>(-1);
-    hss = kFullMojoHandleSignalsState;
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WaitMany(
-                  MakeUserPointer(handles), MakeUserPointer(signals), 2,
-                  MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
-                  MakeUserPointer(&hss)));
-    EXPECT_EQ(1u, result_index);
-    EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
-              hss.satisfied_signals);
-    EXPECT_EQ(kFullMojoHandleSignalsState.satisfiable_signals,
-              hss.satisfiable_signals);
-    handles[1] = handles[0] + 1;  // Invalid handle.
-    EXPECT_EQ(
-        MOJO_RESULT_INVALID_ARGUMENT,
-        core()->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), 2,
-                         MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
-                         NullUserPointer()));
-    handles[1] = CreateMockHandle(&info[1]);
-    EXPECT_EQ(
-        MOJO_RESULT_FAILED_PRECONDITION,
-        core()->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), 2,
-                         MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
-                         NullUserPointer()));
-
-    // TODO(vtl): Test one where we get "failed precondition" only for the
-    // second handle (and the first one is valid to wait on).
-
-    EXPECT_EQ(MOJO_RESULT_OK, core()->Close(handles[0]));
-    EXPECT_EQ(MOJO_RESULT_OK, core()->Close(handles[1]));
-  }
-
-  // |CreateMessagePipe()|: Nothing to check (apart from things that cause
-  // death).
-
-  // |WriteMessage()|:
-  // Only check arguments checked by |Core|, namely |handle|, |handles|, and
-  // |num_handles|.
-  {
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WriteMessage(MOJO_HANDLE_INVALID, NullUserPointer(), 0,
-                                   NullUserPointer(), 0,
-                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
-
-    MockHandleInfo info;
-    MojoHandle h = CreateMockHandle(&info);
-    MojoHandle handles[2] = {MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID};
-
-    // Huge handle count (implausibly big on some systems -- more than can be
-    // stored in a 32-bit address space).
-    // Note: This may return either |MOJO_RESULT_INVALID_ARGUMENT| or
-    // |MOJO_RESULT_RESOURCE_EXHAUSTED|, depending on whether it's plausible or
-    // not.
-    EXPECT_NE(
-        MOJO_RESULT_OK,
-        core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
-                             std::numeric_limits<uint32_t>::max(),
-                             MOJO_WRITE_MESSAGE_FLAG_NONE));
-    EXPECT_EQ(0u, info.GetWriteMessageCallCount());
-
-    // Huge handle count (plausibly big).
-    EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
-              core()->WriteMessage(
-                  h, NullUserPointer(), 0, MakeUserPointer(handles),
-                  std::numeric_limits<uint32_t>::max() / sizeof(handles[0]),
-                  MOJO_WRITE_MESSAGE_FLAG_NONE));
-    EXPECT_EQ(0u, info.GetWriteMessageCallCount());
-
-    // Invalid handle in |handles|.
-    EXPECT_EQ(
-        MOJO_RESULT_INVALID_ARGUMENT,
-        core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
-                             1, MOJO_WRITE_MESSAGE_FLAG_NONE));
-    EXPECT_EQ(0u, info.GetWriteMessageCallCount());
-
-    // Two invalid handles in |handles|.
-    EXPECT_EQ(
-        MOJO_RESULT_INVALID_ARGUMENT,
-        core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
-                             2, MOJO_WRITE_MESSAGE_FLAG_NONE));
-    EXPECT_EQ(0u, info.GetWriteMessageCallCount());
-
-    // Can't send a handle over itself.
-    handles[0] = h;
-    EXPECT_EQ(
-        MOJO_RESULT_BUSY,
-        core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
-                             1, MOJO_WRITE_MESSAGE_FLAG_NONE));
-    EXPECT_EQ(0u, info.GetWriteMessageCallCount());
-
-    MockHandleInfo info2;
-    MojoHandle h2 = CreateMockHandle(&info2);
-
-    // This is "okay", but |MockDispatcher| doesn't implement it.
-    handles[0] = h2;
-    EXPECT_EQ(
-        MOJO_RESULT_UNIMPLEMENTED,
-        core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
-                             1, MOJO_WRITE_MESSAGE_FLAG_NONE));
-    EXPECT_EQ(1u, info.GetWriteMessageCallCount());
-
-    // One of the |handles| is still invalid.
-    EXPECT_EQ(
-        MOJO_RESULT_INVALID_ARGUMENT,
-        core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
-                             2, MOJO_WRITE_MESSAGE_FLAG_NONE));
-    EXPECT_EQ(1u, info.GetWriteMessageCallCount());
-
-    // One of the |handles| is the same as |handle|.
-    handles[1] = h;
-    EXPECT_EQ(
-        MOJO_RESULT_BUSY,
-        core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
-                             2, MOJO_WRITE_MESSAGE_FLAG_NONE));
-    EXPECT_EQ(1u, info.GetWriteMessageCallCount());
-
-    // Can't send a handle twice in the same message.
-    handles[1] = h2;
-    EXPECT_EQ(
-        MOJO_RESULT_BUSY,
-        core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
-                             2, MOJO_WRITE_MESSAGE_FLAG_NONE));
-    EXPECT_EQ(1u, info.GetWriteMessageCallCount());
-
-    // Note: Since we never successfully sent anything with it, |h2| should
-    // still be valid.
-    EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h2));
-
-    EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
-  }
-
-  // |ReadMessage()|:
-  // Only check arguments checked by |Core|, namely |handle|, |handles|, and
-  // |num_handles|.
-  {
-    EXPECT_EQ(
-        MOJO_RESULT_INVALID_ARGUMENT,
-        core()->ReadMessage(MOJO_HANDLE_INVALID, NullUserPointer(),
-                            NullUserPointer(), NullUserPointer(),
-                            NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE));
-
-    MockHandleInfo info;
-    MojoHandle h = CreateMockHandle(&info);
-
-    // Okay.
-    uint32_t handle_count = 0;
-    EXPECT_EQ(MOJO_RESULT_OK,
-              core()->ReadMessage(
-                  h, NullUserPointer(), NullUserPointer(), NullUserPointer(),
-                  MakeUserPointer(&handle_count), MOJO_READ_MESSAGE_FLAG_NONE));
-    // Checked by |Core|, shouldn't go through to the dispatcher.
-    EXPECT_EQ(1u, info.GetReadMessageCallCount());
-
-    EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
-  }
-}
-
-// These test invalid arguments that should cause death if we're being paranoid
-// about checking arguments (which we would want to do if, e.g., we were in a
-// true "kernel" situation, but we might not want to do otherwise for
-// performance reasons). Probably blatant errors like passing in null pointers
-// (for required pointer arguments) will still cause death, but perhaps not
-// predictably.
-TEST_F(CoreTest, InvalidArgumentsDeath) {
-  const char kMemoryCheckFailedRegex[] = "Check failed";
-
-  // |WaitMany()|:
-  {
-    MojoHandle handle = MOJO_HANDLE_INVALID;
-    MojoHandleSignals signals = ~MOJO_HANDLE_SIGNAL_NONE;
-    EXPECT_DEATH_IF_SUPPORTED(
-        core()->WaitMany(NullUserPointer(), MakeUserPointer(&signals), 1,
-                         MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
-                         NullUserPointer()),
-        kMemoryCheckFailedRegex);
-    EXPECT_DEATH_IF_SUPPORTED(
-        core()->WaitMany(MakeUserPointer(&handle), NullUserPointer(), 1,
-                         MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
-                         NullUserPointer()),
-        kMemoryCheckFailedRegex);
-    // TODO(vtl): |result_index| and |signals_states| are optional. Test them
-    // with non-null invalid pointers?
-  }
-
-  // |CreateMessagePipe()|:
-  {
-    MojoHandle h;
-    EXPECT_DEATH_IF_SUPPORTED(
-        core()->CreateMessagePipe(NullUserPointer(), NullUserPointer(),
-                                  NullUserPointer()),
-        kMemoryCheckFailedRegex);
-    EXPECT_DEATH_IF_SUPPORTED(
-        core()->CreateMessagePipe(NullUserPointer(), MakeUserPointer(&h),
-                                  NullUserPointer()),
-        kMemoryCheckFailedRegex);
-    EXPECT_DEATH_IF_SUPPORTED(
-        core()->CreateMessagePipe(NullUserPointer(), NullUserPointer(),
-                                  MakeUserPointer(&h)),
-        kMemoryCheckFailedRegex);
-  }
-
-  // |WriteMessage()|:
-  // Only check arguments checked by |Core|, namely |handle|, |handles|, and
-  // |num_handles|.
-  {
-    MockHandleInfo info;
-    MojoHandle h = CreateMockHandle(&info);
-
-    // Null |handles| with nonzero |num_handles|.
-    EXPECT_DEATH_IF_SUPPORTED(
-        core()->WriteMessage(h, NullUserPointer(), 0, NullUserPointer(), 1,
-                             MOJO_WRITE_MESSAGE_FLAG_NONE),
-        kMemoryCheckFailedRegex);
-
-    EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
-  }
-
-  // |ReadMessage()|:
-  // Only check arguments checked by |Core|, namely |handle|, |handles|, and
-  // |num_handles|.
-  {
-    MockHandleInfo info;
-    MojoHandle h = CreateMockHandle(&info);
-
-    uint32_t handle_count = 1;
-    EXPECT_DEATH_IF_SUPPORTED(
-        core()->ReadMessage(h, NullUserPointer(), NullUserPointer(),
-                            NullUserPointer(), MakeUserPointer(&handle_count),
-                            MOJO_READ_MESSAGE_FLAG_NONE),
-        kMemoryCheckFailedRegex);
-
-    EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
-  }
-}
-
-// TODO(vtl): test |Wait()| and |WaitMany()| properly
-//  - including |WaitMany()| with the same handle more than once (with
-//    same/different signals)
-
-TEST_F(CoreTest, MessagePipe) {
-  MojoHandle h[2];
-  MojoHandleSignalsState hss[2];
-  uint32_t result_index;
-
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->CreateMessagePipe(NullUserPointer(), MakeUserPointer(&h[0]),
-                                      MakeUserPointer(&h[1])));
-  // Should get two distinct, valid handles.
-  EXPECT_NE(h[0], MOJO_HANDLE_INVALID);
-  EXPECT_NE(h[1], MOJO_HANDLE_INVALID);
-  EXPECT_NE(h[0], h[1]);
-
-  // Neither should be readable.
-  MojoHandleSignals signals[2] = {MOJO_HANDLE_SIGNAL_READABLE,
-                                  MOJO_HANDLE_SIGNAL_READABLE};
-  result_index = static_cast<uint32_t>(-1);
-  hss[0] = kEmptyMojoHandleSignalsState;
-  hss[1] = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(
-      MOJO_RESULT_DEADLINE_EXCEEDED,
-      core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2, 0,
-                       MakeUserPointer(&result_index), MakeUserPointer(hss)));
-  EXPECT_EQ(static_cast<uint32_t>(-1), result_index);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
-  EXPECT_EQ(kAllSignals, hss[0].satisfiable_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[1].satisfied_signals);
-  EXPECT_EQ(kAllSignals, hss[1].satisfiable_signals);
-
-  // Try to read anyway.
-  char buffer[1] = {'a'};
-  uint32_t buffer_size = 1;
-  EXPECT_EQ(
-      MOJO_RESULT_SHOULD_WAIT,
-      core()->ReadMessage(h[0], UserPointer<void>(buffer),
-                          MakeUserPointer(&buffer_size), NullUserPointer(),
-                          NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE));
-  // Check that it left its inputs alone.
-  EXPECT_EQ('a', buffer[0]);
-  EXPECT_EQ(1u, buffer_size);
-
-  // Both should be writable.
-  hss[0] = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(h[0], MOJO_HANDLE_SIGNAL_WRITABLE,
-                                         1000000000, MakeUserPointer(&hss[0])));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
-  EXPECT_EQ(kAllSignals, hss[0].satisfiable_signals);
-  hss[0] = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(h[1], MOJO_HANDLE_SIGNAL_WRITABLE,
-                                         1000000000, MakeUserPointer(&hss[0])));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
-  EXPECT_EQ(kAllSignals, hss[0].satisfiable_signals);
-
-  // Also check that |h[1]| is writable using |WaitMany()|.
-  signals[0] = MOJO_HANDLE_SIGNAL_READABLE;
-  signals[1] = MOJO_HANDLE_SIGNAL_WRITABLE;
-  result_index = static_cast<uint32_t>(-1);
-  hss[0] = kEmptyMojoHandleSignalsState;
-  hss[1] = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2,
-                       MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
-                       MakeUserPointer(hss)));
-  EXPECT_EQ(1u, result_index);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
-  EXPECT_EQ(kAllSignals, hss[0].satisfiable_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[1].satisfied_signals);
-  EXPECT_EQ(kAllSignals, hss[1].satisfiable_signals);
-
-  // Write to |h[1]|.
-  buffer[0] = 'b';
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      core()->WriteMessage(h[1], UserPointer<const void>(buffer), 1,
-                           NullUserPointer(), 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
-
-  // Check that |h[0]| is now readable.
-  signals[0] = MOJO_HANDLE_SIGNAL_READABLE;
-  signals[1] = MOJO_HANDLE_SIGNAL_READABLE;
-  result_index = static_cast<uint32_t>(-1);
-  hss[0] = kEmptyMojoHandleSignalsState;
-  hss[1] = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2,
-                       MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
-                       MakeUserPointer(hss)));
-  EXPECT_EQ(0u, result_index);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
-            hss[0].satisfied_signals);
-  EXPECT_EQ(kAllSignals, hss[0].satisfiable_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[1].satisfied_signals);
-  EXPECT_EQ(kAllSignals, hss[1].satisfiable_signals);
-
-  // Read from |h[0]|.
-  // First, get only the size.
-  buffer_size = 0;
-  EXPECT_EQ(
-      MOJO_RESULT_RESOURCE_EXHAUSTED,
-      core()->ReadMessage(h[0], NullUserPointer(),
-                          MakeUserPointer(&buffer_size), NullUserPointer(),
-                          NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE));
-  EXPECT_EQ(1u, buffer_size);
-  // Then actually read it.
-  buffer[0] = 'c';
-  buffer_size = 1;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      core()->ReadMessage(h[0], UserPointer<void>(buffer),
-                          MakeUserPointer(&buffer_size), NullUserPointer(),
-                          NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE));
-  EXPECT_EQ('b', buffer[0]);
-  EXPECT_EQ(1u, buffer_size);
-
-  // |h[0]| should no longer be readable.
-  hss[0] = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
-            core()->Wait(h[0], MOJO_HANDLE_SIGNAL_READABLE, 0,
-                         MakeUserPointer(&hss[0])));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
-  EXPECT_EQ(kAllSignals, hss[0].satisfiable_signals);
-
-  // Write to |h[0]|.
-  buffer[0] = 'd';
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      core()->WriteMessage(h[0], UserPointer<const void>(buffer), 1,
-                           NullUserPointer(), 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
-
-  // Close |h[0]|.
-  EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[0]));
-
-  // Check that |h[1]| is no longer writable (and will never be).
-  hss[0] = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->Wait(h[1], MOJO_HANDLE_SIGNAL_WRITABLE, 1000000000,
-                         MakeUserPointer(&hss[0])));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-            hss[0].satisfied_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-            hss[0].satisfiable_signals);
-
-  // Check that |h[1]| is still readable (for the moment).
-  hss[0] = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(h[1], MOJO_HANDLE_SIGNAL_READABLE,
-                                         1000000000, MakeUserPointer(&hss[0])));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-            hss[0].satisfied_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-            hss[0].satisfiable_signals);
-
-  // Discard a message from |h[1]|.
-  EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
-            core()->ReadMessage(h[1], NullUserPointer(), NullUserPointer(),
-                                NullUserPointer(), NullUserPointer(),
-                                MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
-
-  // |h[1]| is no longer readable (and will never be).
-  hss[0] = kFullMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->Wait(h[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
-                         MakeUserPointer(&hss[0])));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss[0].satisfied_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss[0].satisfiable_signals);
-
-  // Try writing to |h[1]|.
-  buffer[0] = 'e';
-  EXPECT_EQ(
-      MOJO_RESULT_FAILED_PRECONDITION,
-      core()->WriteMessage(h[1], UserPointer<const void>(buffer), 1,
-                           NullUserPointer(), 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
-
-  EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[1]));
-}
-
-// Tests passing a message pipe handle.
-TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) {
-  const char kHello[] = "hello";
-  const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
-  const char kWorld[] = "world!!!";
-  const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld));
-  char buffer[100];
-  const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
-  uint32_t num_bytes;
-  MojoHandle handles[10];
-  uint32_t num_handles;
-  MojoHandleSignalsState hss;
-  MojoHandle h_received;
-
-  MojoHandle h_passing[2];
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->CreateMessagePipe(NullUserPointer(),
-                                      MakeUserPointer(&h_passing[0]),
-                                      MakeUserPointer(&h_passing[1])));
-
-  // Make sure that |h_passing[]| work properly.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
-                                 kHelloSize, NullUserPointer(), 0,
-                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
-  hss = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
-                         MakeUserPointer(&hss)));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
-            hss.satisfied_signals);
-  EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
-  num_bytes = kBufferSize;
-  num_handles = arraysize(handles);
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadMessage(
-                h_passing[1], UserPointer<void>(buffer),
-                MakeUserPointer(&num_bytes), MakeUserPointer(handles),
-                MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
-  EXPECT_EQ(kHelloSize, num_bytes);
-  EXPECT_STREQ(kHello, buffer);
-  EXPECT_EQ(0u, num_handles);
-
-  // Make sure that you can't pass either of the message pipe's handles over
-  // itself.
-  EXPECT_EQ(MOJO_RESULT_BUSY,
-            core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
-                                 kHelloSize, MakeUserPointer(&h_passing[0]), 1,
-                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
-  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
-                                 kHelloSize, MakeUserPointer(&h_passing[1]), 1,
-                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
-
-  MojoHandle h_passed[2];
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->CreateMessagePipe(NullUserPointer(),
-                                      MakeUserPointer(&h_passed[0]),
-                                      MakeUserPointer(&h_passed[1])));
-
-  // Make sure that |h_passed[]| work properly.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteMessage(h_passed[0], UserPointer<const void>(kHello),
-                                 kHelloSize, NullUserPointer(), 0,
-                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
-  hss = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passed[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
-                         MakeUserPointer(&hss)));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
-            hss.satisfied_signals);
-  EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
-  num_bytes = kBufferSize;
-  num_handles = arraysize(handles);
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadMessage(
-                h_passed[1], UserPointer<void>(buffer),
-                MakeUserPointer(&num_bytes), MakeUserPointer(handles),
-                MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
-  EXPECT_EQ(kHelloSize, num_bytes);
-  EXPECT_STREQ(kHello, buffer);
-  EXPECT_EQ(0u, num_handles);
-
-  // Send |h_passed[1]| from |h_passing[0]| to |h_passing[1]|.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteMessage(h_passing[0], UserPointer<const void>(kWorld),
-                                 kWorldSize, MakeUserPointer(&h_passed[1]), 1,
-                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
-  hss = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
-                         MakeUserPointer(&hss)));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
-            hss.satisfied_signals);
-  EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
-  num_bytes = kBufferSize;
-  num_handles = arraysize(handles);
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadMessage(
-                h_passing[1], UserPointer<void>(buffer),
-                MakeUserPointer(&num_bytes), MakeUserPointer(handles),
-                MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
-  EXPECT_EQ(kWorldSize, num_bytes);
-  EXPECT_STREQ(kWorld, buffer);
-  EXPECT_EQ(1u, num_handles);
-  h_received = handles[0];
-  EXPECT_NE(h_received, MOJO_HANDLE_INVALID);
-  EXPECT_NE(h_received, h_passing[0]);
-  EXPECT_NE(h_received, h_passing[1]);
-  EXPECT_NE(h_received, h_passed[0]);
-
-  // Note: We rely on the Mojo system not re-using handle values very often.
-  EXPECT_NE(h_received, h_passed[1]);
-
-  // |h_passed[1]| should no longer be valid; check that trying to close it
-  // fails. See above note.
-  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(h_passed[1]));
-
-  // Write to |h_passed[0]|. Should receive on |h_received|.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteMessage(h_passed[0], UserPointer<const void>(kHello),
-                                 kHelloSize, NullUserPointer(), 0,
-                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
-  hss = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
-                         MakeUserPointer(&hss)));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
-            hss.satisfied_signals);
-  EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
-  num_bytes = kBufferSize;
-  num_handles = arraysize(handles);
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadMessage(
-                h_received, UserPointer<void>(buffer),
-                MakeUserPointer(&num_bytes), MakeUserPointer(handles),
-                MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
-  EXPECT_EQ(kHelloSize, num_bytes);
-  EXPECT_STREQ(kHello, buffer);
-  EXPECT_EQ(0u, num_handles);
-
-  EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[0]));
-  EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[1]));
-  EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passed[0]));
-  EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_received));
-}
-
-TEST_F(CoreTest, DataPipe) {
-  MojoHandle ph, ch;  // p is for producer and c is for consumer.
-  MojoHandleSignalsState hss;
-
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->CreateDataPipe(NullUserPointer(), MakeUserPointer(&ph),
-                                   MakeUserPointer(&ch)));
-  // Should get two distinct, valid handles.
-  EXPECT_NE(ph, MOJO_HANDLE_INVALID);
-  EXPECT_NE(ch, MOJO_HANDLE_INVALID);
-  EXPECT_NE(ph, ch);
-
-  // Producer should be never-readable, but already writable.
-  hss = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(
-      MOJO_RESULT_FAILED_PRECONDITION,
-      core()->Wait(ph, MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss)));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-            hss.satisfiable_signals);
-  hss = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ph, MOJO_HANDLE_SIGNAL_WRITABLE, 0,
-                                         MakeUserPointer(&hss)));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-            hss.satisfiable_signals);
-
-  // Consumer should be never-writable, and not yet readable.
-  hss = kFullMojoHandleSignalsState;
-  EXPECT_EQ(
-      MOJO_RESULT_FAILED_PRECONDITION,
-      core()->Wait(ch, MOJO_HANDLE_SIGNAL_WRITABLE, 0, MakeUserPointer(&hss)));
-  EXPECT_EQ(0u, hss.satisfied_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-            hss.satisfiable_signals);
-  hss = kFullMojoHandleSignalsState;
-  EXPECT_EQ(
-      MOJO_RESULT_DEADLINE_EXCEEDED,
-      core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss)));
-  EXPECT_EQ(0u, hss.satisfied_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-            hss.satisfiable_signals);
-
-  // Write.
-  signed char elements[2] = {'A', 'B'};
-  uint32_t num_bytes = 2u;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteData(ph, UserPointer<const void>(elements),
-                              MakeUserPointer(&num_bytes),
-                              MOJO_WRITE_DATA_FLAG_NONE));
-  EXPECT_EQ(2u, num_bytes);
-
-  // Consumer should now be readable.
-  hss = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0,
-                                         MakeUserPointer(&hss)));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-            hss.satisfiable_signals);
-
-  // Peek one character.
-  elements[0] = -1;
-  elements[1] = -1;
-  num_bytes = 1u;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadData(
-                ch, UserPointer<void>(elements), MakeUserPointer(&num_bytes),
-                MOJO_READ_DATA_FLAG_NONE | MOJO_READ_DATA_FLAG_PEEK));
-  EXPECT_EQ('A', elements[0]);
-  EXPECT_EQ(-1, elements[1]);
-
-  // Read one character.
-  elements[0] = -1;
-  elements[1] = -1;
-  num_bytes = 1u;
-  EXPECT_EQ(MOJO_RESULT_OK, core()->ReadData(ch, UserPointer<void>(elements),
-                                             MakeUserPointer(&num_bytes),
-                                             MOJO_READ_DATA_FLAG_NONE));
-  EXPECT_EQ('A', elements[0]);
-  EXPECT_EQ(-1, elements[1]);
-
-  // Two-phase write.
-  void* write_ptr = nullptr;
-  num_bytes = 0u;
-  ASSERT_EQ(MOJO_RESULT_OK,
-            core()->BeginWriteData(ph, MakeUserPointer(&write_ptr),
-                                   MakeUserPointer(&num_bytes),
-                                   MOJO_WRITE_DATA_FLAG_NONE));
-  // We count on the default options providing a decent buffer size.
-  ASSERT_GE(num_bytes, 3u);
-
-  // Trying to do a normal write during a two-phase write should fail.
-  elements[0] = 'X';
-  num_bytes = 1u;
-  EXPECT_EQ(MOJO_RESULT_BUSY,
-            core()->WriteData(ph, UserPointer<const void>(elements),
-                              MakeUserPointer(&num_bytes),
-                              MOJO_WRITE_DATA_FLAG_NONE));
-
-  // Actually write the data, and complete it now.
-  static_cast<char*>(write_ptr)[0] = 'C';
-  static_cast<char*>(write_ptr)[1] = 'D';
-  static_cast<char*>(write_ptr)[2] = 'E';
-  EXPECT_EQ(MOJO_RESULT_OK, core()->EndWriteData(ph, 3u));
-
-  // Query how much data we have.
-  num_bytes = 0;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes),
-                             MOJO_READ_DATA_FLAG_QUERY));
-  EXPECT_EQ(4u, num_bytes);
-
-  // Try to query with peek. Should fail.
-  num_bytes = 0;
-  EXPECT_EQ(
-      MOJO_RESULT_INVALID_ARGUMENT,
-      core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes),
-                       MOJO_READ_DATA_FLAG_QUERY | MOJO_READ_DATA_FLAG_PEEK));
-  EXPECT_EQ(0u, num_bytes);
-
-  // Try to discard ten characters, in all-or-none mode. Should fail.
-  num_bytes = 10;
-  EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
-            core()->ReadData(
-                ch, NullUserPointer(), MakeUserPointer(&num_bytes),
-                MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_ALL_OR_NONE));
-
-  // Try to discard two characters, in peek mode. Should fail.
-  num_bytes = 2;
-  EXPECT_EQ(
-      MOJO_RESULT_INVALID_ARGUMENT,
-      core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes),
-                       MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_PEEK));
-
-  // Discard two characters.
-  num_bytes = 2;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadData(
-                ch, NullUserPointer(), MakeUserPointer(&num_bytes),
-                MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_ALL_OR_NONE));
-
-  // Try a two-phase read of the remaining two bytes with peek. Should fail.
-  const void* read_ptr = nullptr;
-  num_bytes = 2;
-  ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            core()->BeginReadData(ch, MakeUserPointer(&read_ptr),
-                                  MakeUserPointer(&num_bytes),
-                                  MOJO_READ_DATA_FLAG_PEEK));
-
-  // Read the remaining two characters, in two-phase mode (all-or-none).
-  num_bytes = 2;
-  ASSERT_EQ(MOJO_RESULT_OK,
-            core()->BeginReadData(ch, MakeUserPointer(&read_ptr),
-                                  MakeUserPointer(&num_bytes),
-                                  MOJO_READ_DATA_FLAG_ALL_OR_NONE));
-  // Note: Count on still being able to do the contiguous read here.
-  ASSERT_EQ(2u, num_bytes);
-
-  // Discarding right now should fail.
-  num_bytes = 1;
-  EXPECT_EQ(MOJO_RESULT_BUSY,
-            core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes),
-                             MOJO_READ_DATA_FLAG_DISCARD));
-
-  // Actually check our data and end the two-phase read.
-  EXPECT_EQ('D', static_cast<const char*>(read_ptr)[0]);
-  EXPECT_EQ('E', static_cast<const char*>(read_ptr)[1]);
-  EXPECT_EQ(MOJO_RESULT_OK, core()->EndReadData(ch, 2u));
-
-  // Consumer should now be no longer readable.
-  hss = kFullMojoHandleSignalsState;
-  EXPECT_EQ(
-      MOJO_RESULT_DEADLINE_EXCEEDED,
-      core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss)));
-  EXPECT_EQ(0u, hss.satisfied_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-            hss.satisfiable_signals);
-
-  // TODO(vtl): More.
-
-  // Close the producer.
-  EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ph));
-
-  // The consumer should now be never-readable.
-  hss = kFullMojoHandleSignalsState;
-  EXPECT_EQ(
-      MOJO_RESULT_FAILED_PRECONDITION,
-      core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss)));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
-
-  EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ch));
-}
-
-// Tests passing data pipe producer and consumer handles.
-TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) {
-  const char kHello[] = "hello";
-  const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
-  const char kWorld[] = "world!!!";
-  const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld));
-  char buffer[100];
-  const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
-  uint32_t num_bytes;
-  MojoHandle handles[10];
-  uint32_t num_handles;
-  MojoHandleSignalsState hss;
-
-  MojoHandle h_passing[2];
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->CreateMessagePipe(NullUserPointer(),
-                                      MakeUserPointer(&h_passing[0]),
-                                      MakeUserPointer(&h_passing[1])));
-
-  MojoHandle ph, ch;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->CreateDataPipe(NullUserPointer(), MakeUserPointer(&ph),
-                                   MakeUserPointer(&ch)));
-
-  // Send |ch| from |h_passing[0]| to |h_passing[1]|.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
-                                 kHelloSize, MakeUserPointer(&ch), 1,
-                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
-  hss = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
-                         MakeUserPointer(&hss)));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
-            hss.satisfied_signals);
-  EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
-  num_bytes = kBufferSize;
-  num_handles = arraysize(handles);
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadMessage(
-                h_passing[1], UserPointer<void>(buffer),
-                MakeUserPointer(&num_bytes), MakeUserPointer(handles),
-                MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
-  EXPECT_EQ(kHelloSize, num_bytes);
-  EXPECT_STREQ(kHello, buffer);
-  EXPECT_EQ(1u, num_handles);
-  MojoHandle ch_received = handles[0];
-  EXPECT_NE(ch_received, MOJO_HANDLE_INVALID);
-  EXPECT_NE(ch_received, h_passing[0]);
-  EXPECT_NE(ch_received, h_passing[1]);
-  EXPECT_NE(ch_received, ph);
-
-  // Note: We rely on the Mojo system not re-using handle values very often.
-  EXPECT_NE(ch_received, ch);
-
-  // |ch| should no longer be valid; check that trying to close it fails. See
-  // above note.
-  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(ch));
-
-  // Write to |ph|. Should receive on |ch_received|.
-  num_bytes = kWorldSize;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteData(ph, UserPointer<const void>(kWorld),
-                              MakeUserPointer(&num_bytes),
-                              MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
-  hss = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(ch_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
-                         MakeUserPointer(&hss)));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-            hss.satisfiable_signals);
-  num_bytes = kBufferSize;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadData(ch_received, UserPointer<void>(buffer),
-                             MakeUserPointer(&num_bytes),
-                             MOJO_READ_MESSAGE_FLAG_NONE));
-  EXPECT_EQ(kWorldSize, num_bytes);
-  EXPECT_STREQ(kWorld, buffer);
-
-  // Now pass |ph| in the same direction.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteMessage(h_passing[0], UserPointer<const void>(kWorld),
-                                 kWorldSize, MakeUserPointer(&ph), 1,
-                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
-  hss = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
-                         MakeUserPointer(&hss)));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
-            hss.satisfied_signals);
-  EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
-  num_bytes = kBufferSize;
-  num_handles = arraysize(handles);
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadMessage(
-                h_passing[1], UserPointer<void>(buffer),
-                MakeUserPointer(&num_bytes), MakeUserPointer(handles),
-                MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
-  EXPECT_EQ(kWorldSize, num_bytes);
-  EXPECT_STREQ(kWorld, buffer);
-  EXPECT_EQ(1u, num_handles);
-  MojoHandle ph_received = handles[0];
-  EXPECT_NE(ph_received, MOJO_HANDLE_INVALID);
-  EXPECT_NE(ph_received, h_passing[0]);
-  EXPECT_NE(ph_received, h_passing[1]);
-  EXPECT_NE(ph_received, ch_received);
-
-  // Again, rely on the Mojo system not re-using handle values very often.
-  EXPECT_NE(ph_received, ph);
-
-  // |ph| should no longer be valid; check that trying to close it fails. See
-  // above note.
-  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(ph));
-
-  // Write to |ph_received|. Should receive on |ch_received|.
-  num_bytes = kHelloSize;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteData(ph_received, UserPointer<const void>(kHello),
-                              MakeUserPointer(&num_bytes),
-                              MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
-  hss = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(ch_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
-                         MakeUserPointer(&hss)));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-            hss.satisfiable_signals);
-  num_bytes = kBufferSize;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadData(ch_received, UserPointer<void>(buffer),
-                             MakeUserPointer(&num_bytes),
-                             MOJO_READ_MESSAGE_FLAG_NONE));
-  EXPECT_EQ(kHelloSize, num_bytes);
-  EXPECT_STREQ(kHello, buffer);
-
-  ph = ph_received;
-  ph_received = MOJO_HANDLE_INVALID;
-  ch = ch_received;
-  ch_received = MOJO_HANDLE_INVALID;
-
-  // Make sure that |ph| can't be sent if it's in a two-phase write.
-  void* write_ptr = nullptr;
-  num_bytes = 0;
-  ASSERT_EQ(MOJO_RESULT_OK,
-            core()->BeginWriteData(ph, MakeUserPointer(&write_ptr),
-                                   MakeUserPointer(&num_bytes),
-                                   MOJO_WRITE_DATA_FLAG_NONE));
-  ASSERT_GE(num_bytes, 1u);
-  EXPECT_EQ(MOJO_RESULT_BUSY,
-            core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
-                                 kHelloSize, MakeUserPointer(&ph), 1,
-                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
-
-  // But |ch| can, even if |ph| is in a two-phase write.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
-                                 kHelloSize, MakeUserPointer(&ch), 1,
-                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
-  ch = MOJO_HANDLE_INVALID;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
-                         NullUserPointer()));
-  num_bytes = kBufferSize;
-  num_handles = arraysize(handles);
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadMessage(
-                h_passing[1], UserPointer<void>(buffer),
-                MakeUserPointer(&num_bytes), MakeUserPointer(handles),
-                MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
-  EXPECT_EQ(kHelloSize, num_bytes);
-  EXPECT_STREQ(kHello, buffer);
-  EXPECT_EQ(1u, num_handles);
-  ch = handles[0];
-  EXPECT_NE(ch, MOJO_HANDLE_INVALID);
-
-  // Complete the two-phase write.
-  static_cast<char*>(write_ptr)[0] = 'x';
-  EXPECT_EQ(MOJO_RESULT_OK, core()->EndWriteData(ph, 1));
-
-  // Wait for |ch| to be readable.
-  hss = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE,
-                                         1000000000, MakeUserPointer(&hss)));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
-            hss.satisfiable_signals);
-
-  // Make sure that |ch| can't be sent if it's in a two-phase read.
-  const void* read_ptr = nullptr;
-  num_bytes = 1;
-  ASSERT_EQ(MOJO_RESULT_OK,
-            core()->BeginReadData(ch, MakeUserPointer(&read_ptr),
-                                  MakeUserPointer(&num_bytes),
-                                  MOJO_READ_DATA_FLAG_ALL_OR_NONE));
-  EXPECT_EQ(MOJO_RESULT_BUSY,
-            core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
-                                 kHelloSize, MakeUserPointer(&ch), 1,
-                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
-
-  // But |ph| can, even if |ch| is in a two-phase read.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteMessage(h_passing[0], UserPointer<const void>(kWorld),
-                                 kWorldSize, MakeUserPointer(&ph), 1,
-                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
-  ph = MOJO_HANDLE_INVALID;
-  hss = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
-                         MakeUserPointer(&hss)));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
-            hss.satisfied_signals);
-  EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
-  num_bytes = kBufferSize;
-  num_handles = arraysize(handles);
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadMessage(
-                h_passing[1], UserPointer<void>(buffer),
-                MakeUserPointer(&num_bytes), MakeUserPointer(handles),
-                MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
-  EXPECT_EQ(kWorldSize, num_bytes);
-  EXPECT_STREQ(kWorld, buffer);
-  EXPECT_EQ(1u, num_handles);
-  ph = handles[0];
-  EXPECT_NE(ph, MOJO_HANDLE_INVALID);
-
-  // Complete the two-phase read.
-  EXPECT_EQ('x', static_cast<const char*>(read_ptr)[0]);
-  EXPECT_EQ(MOJO_RESULT_OK, core()->EndReadData(ch, 1));
-
-  EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[0]));
-  EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[1]));
-  EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ph));
-  EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ch));
-}
-
-struct TestAsyncWaiter {
-  TestAsyncWaiter() : result(MOJO_RESULT_UNKNOWN) {}
-
-  void Awake(MojoResult r) { result = r; }
-
-  MojoResult result;
-};
-
-TEST_F(CoreTest, AsyncWait) {
-  TestAsyncWaiter waiter;
-  MockHandleInfo info;
-  MojoHandle h = CreateMockHandle(&info);
-
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->AsyncWait(h, MOJO_HANDLE_SIGNAL_READABLE,
-                              base::Bind(&TestAsyncWaiter::Awake,
-                                         base::Unretained(&waiter))));
-  EXPECT_EQ(0u, info.GetAddedAwakableSize());
-
-  info.AllowAddAwakable(true);
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->AsyncWait(h, MOJO_HANDLE_SIGNAL_READABLE,
-                              base::Bind(&TestAsyncWaiter::Awake,
-                                         base::Unretained(&waiter))));
-  EXPECT_EQ(1u, info.GetAddedAwakableSize());
-
-  EXPECT_FALSE(info.GetAddedAwakableAt(0)->Awake(MOJO_RESULT_BUSY, 0));
-  EXPECT_EQ(MOJO_RESULT_BUSY, waiter.result);
-
-  EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
-}
-
-// TODO(vtl): Test |DuplicateBufferHandle()| and |MapBuffer()|.
-
-}  // namespace
-}  // namespace system
-}  // namespace mojo