Add a Mojo EDK for Chrome that uses one OS pipe per message pipe.

mojo/edk/system/message_pipe_unittest.cc

+// 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 "base/memory/ref_counted.h"
+#include "base/test/test_io_thread.h"
+#include "mojo/edk/system/waiter.h"
+#include "mojo/edk/system/waiter_test_utils.h"
+#include "mojo/edk/test/scoped_ipc_support.h"
+#include "mojo/public/c/system/core.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace mojo {
+namespace system {
+namespace {
+
+class MessagePipeTest : public testing::Test {
+ public:
+  MessagePipeTest()
+      : test_io_thread_(base::TestIOThread::kAutoStart),
+        ipc_support_(test_io_thread_.task_runner()) {}
+  ~MessagePipeTest() override {}
+
+ private:
+  base::MessageLoop message_loop_;
+  base::TestIOThread test_io_thread_;
+  mojo::test::ScopedIPCSupport ipc_support_;
+
+  MOJO_DISALLOW_COPY_AND_ASSIGN(MessagePipeTest);
+};
+
+static const char kHelloWorld[] = "hello world";
+TEST_F(MessagePipeTest, WriteData) {
+  MojoHandle pipe1, pipe2;
+  ASSERT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &pipe1, &pipe2));
+  ASSERT_EQ(MOJO_RESULT_OK,
+            MojoWriteMessage(pipe1, kHelloWorld, sizeof(kHelloWorld), nullptr,
+                             0, MOJO_WRITE_MESSAGE_FLAG_NONE));
+  MojoClose(pipe1);
+  MojoClose(pipe2);
+}
+
+
+const MojoHandleSignals kAllSignals = MOJO_HANDLE_SIGNAL_READABLE |
+                                      MOJO_HANDLE_SIGNAL_WRITABLE |
+                                      MOJO_HANDLE_SIGNAL_PEER_CLOSED;
+
+// Tests:
+//  - only default flags
+//  - reading messages from a port
+//    - when there are no/one/two messages available for that port
+//    - with buffer size 0 (and null buffer) -- should get size
+//    - with too-small buffer -- should get size
+//    - also verify that buffers aren't modified when/where they shouldn't be
+//  - writing messages to a port
+//    - in the obvious scenarios (as above)
+//    - to a port that's been closed
+//  - writing a message to a port, closing the other (would be the source) port,
+//    and reading it
+TEST_F(MessagePipeTest, Basic) {
+  MojoHandle pipe0, pipe1;
+  ASSERT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &pipe0, &pipe1));
+
+  int32_t buffer[2];
+  const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
+  uint32_t buffer_size;
+
+  // Nothing to read yet on port 0.
+  buffer[0] = 123;
+  buffer[1] = 456;
+  buffer_size = kBufferSize;
+  EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
+            MojoReadMessage(pipe0, buffer, &buffer_size, nullptr, 0,
+                            MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(kBufferSize, buffer_size);
+  EXPECT_EQ(123, buffer[0]);
+  EXPECT_EQ(456, buffer[1]);
+
+  // Ditto for port 1.
+  buffer[0] = 123;
+  buffer[1] = 456;
+  buffer_size = kBufferSize;
+  EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
+            MojoReadMessage(pipe1, buffer, &buffer_size, nullptr, 0,
+                            MOJO_READ_MESSAGE_FLAG_NONE));
+
+  // Write from port 1 (to port 0).
+  buffer[0] = 789012345;
+  buffer[1] = 0;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            MojoWriteMessage(pipe1, buffer, sizeof(buffer[0]), nullptr, 0,
+                             MOJO_WRITE_MESSAGE_FLAG_NONE));
+
+  MojoHandleSignalsState state;
+  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(pipe0, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &state));
+
+  // Read from port 0.
+  buffer[0] = 123;
+  buffer[1] = 456;
+  buffer_size = kBufferSize;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            MojoReadMessage(pipe0, buffer, &buffer_size, nullptr, 0,
+                            MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
+  EXPECT_EQ(789012345, buffer[0]);
+  EXPECT_EQ(456, buffer[1]);
+
+  // Read again from port 0 -- it should be empty.
+  buffer_size = kBufferSize;
+  EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
+            MojoReadMessage(pipe0, buffer, &buffer_size, nullptr, 0,
+                            MOJO_READ_MESSAGE_FLAG_NONE));
+
+  // Write two messages from port 0 (to port 1).
+  buffer[0] = 123456789;
+  buffer[1] = 0;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            MojoWriteMessage(pipe0, buffer, sizeof(buffer[0]), nullptr, 0,
+                             MOJO_WRITE_MESSAGE_FLAG_NONE));
+  buffer[0] = 234567890;
+  buffer[1] = 0;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            MojoWriteMessage(pipe0, buffer, sizeof(buffer[0]), nullptr, 0,
+                             MOJO_WRITE_MESSAGE_FLAG_NONE));
+
+  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(pipe1, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &state));
+
+  // Read from port 1 with buffer size 0 (should get the size of next message).
+  // Also test that giving a null buffer is okay when the buffer size is 0.
+  buffer_size = 0;
+  EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
+            MojoReadMessage(pipe1, nullptr, &buffer_size, nullptr, 0,
+                            MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
+
+  // Read from port 1 with buffer size 1 (too small; should get the size of next
+  // message).
+  buffer[0] = 123;
+  buffer[1] = 456;
+  buffer_size = 1;
+  EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
+            MojoReadMessage(pipe1, buffer, &buffer_size, nullptr, 0,
+                            MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
+  EXPECT_EQ(123, buffer[0]);
+  EXPECT_EQ(456, buffer[1]);
+
+  // Read from port 1.
+  buffer[0] = 123;
+  buffer[1] = 456;
+  buffer_size = kBufferSize;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            MojoReadMessage(pipe1, buffer, &buffer_size, nullptr, 0,
+                            MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
+  EXPECT_EQ(123456789, buffer[0]);
+  EXPECT_EQ(456, buffer[1]);
+
+  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(pipe1, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &state));
+
+  // Read again from port 1.
+  buffer[0] = 123;
+  buffer[1] = 456;
+  buffer_size = kBufferSize;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            MojoReadMessage(pipe1, buffer, &buffer_size, nullptr, 0,
+                            MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
+  EXPECT_EQ(234567890, buffer[0]);
+  EXPECT_EQ(456, buffer[1]);
+
+  // Read again from port 1 -- it should be empty.
+  buffer_size = kBufferSize;
+  EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
+            MojoReadMessage(pipe1, buffer, &buffer_size, nullptr, 0,
+                            MOJO_READ_MESSAGE_FLAG_NONE));
+
+  // Write from port 0 (to port 1).
+  buffer[0] = 345678901;
+  buffer[1] = 0;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            MojoWriteMessage(pipe0, buffer, sizeof(buffer[0]), nullptr, 0,
+                             MOJO_WRITE_MESSAGE_FLAG_NONE));
+
+  // Close port 0.
+  MojoClose(pipe0);
+
+  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(pipe1, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+                                     MOJO_DEADLINE_INDEFINITE, &state));
+
+  // Try to write from port 1 (to port 0).
+  buffer[0] = 456789012;
+  buffer[1] = 0;
+  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
+            MojoWriteMessage(pipe1, buffer, sizeof(buffer[0]), nullptr, 0,
+                             MOJO_WRITE_MESSAGE_FLAG_NONE));
+
+  // Read from port 1; should still get message (even though port 0 was closed).
+  buffer[0] = 123;
+  buffer[1] = 456;
+  buffer_size = kBufferSize;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            MojoReadMessage(pipe1, buffer, &buffer_size, nullptr, 0,
+                            MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
+  EXPECT_EQ(345678901, buffer[0]);
+  EXPECT_EQ(456, buffer[1]);
+
+  // Read again from port 1 -- it should be empty (and port 0 is closed).
+  buffer_size = kBufferSize;
+  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
+            MojoReadMessage(pipe1, buffer, &buffer_size, nullptr, 0,
+                            MOJO_READ_MESSAGE_FLAG_NONE));
+
+  MojoClose(pipe1);
+}
+
+TEST_F(MessagePipeTest, CloseWithQueuedIncomingMessages) {
+  MojoHandle pipe0, pipe1;
+  ASSERT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &pipe0, &pipe1));
+
+  int32_t buffer[1];
+  const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
+  uint32_t buffer_size;
+
+  // Write some messages from port 1 (to port 0).
+  for (int32_t i = 0; i < 5; i++) {
+    buffer[0] = i;
+    EXPECT_EQ(MOJO_RESULT_OK,
+              MojoWriteMessage(pipe1, buffer, kBufferSize, nullptr, 0,
+                               MOJO_WRITE_MESSAGE_FLAG_NONE));
+  }
+
+  MojoHandleSignalsState state;
+  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(pipe0, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &state));
+
+  // Port 0 shouldn't be empty.
+  buffer_size = 0;
+  EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
+            MojoReadMessage(pipe0, nullptr, &buffer_size, nullptr, 0,
+                            MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(kBufferSize, buffer_size);
+
+  // Close port 0 first, which should have outstanding (incoming) messages.
+  MojoClose(pipe0);
+  MojoClose(pipe1);
+}
+
+TEST_F(MessagePipeTest, DiscardMode) {
+  MojoHandle pipe0, pipe1;
+  ASSERT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &pipe0, &pipe1));
+
+  int32_t buffer[2];
+  const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
+  uint32_t buffer_size;
+
+  // Write from port 1 (to port 0).
+  buffer[0] = 789012345;
+  buffer[1] = 0;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            MojoWriteMessage(pipe1, buffer, sizeof(buffer[0]), nullptr, 0,
+                             MOJO_WRITE_MESSAGE_FLAG_NONE));
+
+  MojoHandleSignalsState state;
+  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(pipe0, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &state));
+
+  // Read/discard from port 0 (no buffer); get size.
+  buffer_size = 0;
+  EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
+            MojoReadMessage(pipe0, nullptr, &buffer_size, nullptr, 0,
+                            MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
+  EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
+
+  // Read again from port 0 -- it should be empty.
+  buffer_size = kBufferSize;
+  EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
+            MojoReadMessage(pipe0, buffer, &buffer_size, nullptr, 0,
+                            MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
+
+  // Write from port 1 (to port 0).
+  buffer[0] = 890123456;
+  buffer[1] = 0;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            MojoWriteMessage(pipe1, buffer, sizeof(buffer[0]), nullptr, 0,
+                             MOJO_WRITE_MESSAGE_FLAG_NONE));
+
+  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(pipe0, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &state));
+
+  // Read from port 0 (buffer big enough).
+  buffer[0] = 123;
+  buffer[1] = 456;
+  buffer_size = kBufferSize;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            MojoReadMessage(pipe0, buffer, &buffer_size, 0, nullptr,
+                            MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
+  EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
+  EXPECT_EQ(890123456, buffer[0]);
+  EXPECT_EQ(456, buffer[1]);
+
+  // Read again from port 0 -- it should be empty.
+  buffer_size = kBufferSize;
+  EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
+            MojoReadMessage(pipe0, buffer, &buffer_size, nullptr, 0,
+                            MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
+
+  // Write from port 1 (to port 0).
+  buffer[0] = 901234567;
+  buffer[1] = 0;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            MojoWriteMessage(pipe1, buffer, sizeof(buffer[0]), nullptr, 0,
+                             MOJO_WRITE_MESSAGE_FLAG_NONE));
+
+  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(pipe0, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &state));
+
+  // Read/discard from port 0 (buffer too small); get size.
+  buffer_size = 1;
+  EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
+            MojoReadMessage(pipe0, buffer, &buffer_size, nullptr, 0,
+                            MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
+  EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
+
+  // Read again from port 0 -- it should be empty.
+  buffer_size = kBufferSize;
+  EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
+            MojoReadMessage(pipe0, buffer, &buffer_size, nullptr, 0,
+                            MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
+
+  // Write from port 1 (to port 0).
+  buffer[0] = 123456789;
+  buffer[1] = 0;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            MojoWriteMessage(pipe1, buffer, sizeof(buffer[0]), nullptr, 0,
+                             MOJO_WRITE_MESSAGE_FLAG_NONE));
+
+  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(pipe0, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &state));
+
+  // Discard from port 0.
+  buffer_size = 1;
+  EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
+            MojoReadMessage(pipe0, nullptr, 0, nullptr, 0,
+                            MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
+
+  // Read again from port 0 -- it should be empty.
+  buffer_size = kBufferSize;
+  EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
+            MojoReadMessage(pipe0, buffer, &buffer_size, nullptr, 0,
+                            MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
+
+  MojoClose(pipe0);
+  MojoClose(pipe1);
+}
+
+TEST_F(MessagePipeTest, BasicWaiting) {
+  MojoHandle pipe0, pipe1;
+  ASSERT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &pipe0, &pipe1));
+
+  HandleSignalsState hss;
+
+  int32_t buffer[1];
+  const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
+  uint32_t buffer_size;
+
+  // Always writable (until the other port is closed).
+  hss = HandleSignalsState();
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe0, MOJO_HANDLE_SIGNAL_WRITABLE, 0,
+                                     &hss));
+  ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
+  ASSERT_EQ(kAllSignals, hss.satisfiable_signals);
+  hss = HandleSignalsState();
+ 
+  // Not yet readable.
+  ASSERT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
+            MojoWait(pipe0, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss));
+  ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
+  ASSERT_EQ(kAllSignals, hss.satisfiable_signals);
+
+  // The peer is not closed.
+  hss = HandleSignalsState();
+  ASSERT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
+            MojoWait(pipe0, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 0, &hss));
+  ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
+  ASSERT_EQ(kAllSignals, hss.satisfiable_signals);
+
+  // Write from port 0 (to port 1), to make port 1 readable.
+  buffer[0] = 123456789;
+  ASSERT_EQ(MOJO_RESULT_OK,
+            MojoWriteMessage(pipe0, buffer, kBufferSize, nullptr, 0,
+                             MOJO_WRITE_MESSAGE_FLAG_NONE));
+
+  // Port 1 should already be readable now.
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &hss));
+  ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
+            hss.satisfied_signals);
+  ASSERT_EQ(kAllSignals, hss.satisfiable_signals);
+  // ... and still writable.
+  hss = HandleSignalsState();
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1, MOJO_HANDLE_SIGNAL_WRITABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &hss));
+  ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
+            hss.satisfied_signals);
+  ASSERT_EQ(kAllSignals, hss.satisfiable_signals);
+
+  // Close port 0.
+  MojoClose(pipe0);
+
+  // Port 1 should be signaled with peer closed.
+  hss = HandleSignalsState();
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+                                     MOJO_DEADLINE_INDEFINITE, &hss));
+  ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+            hss.satisfied_signals);
+  ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+            hss.satisfiable_signals);
+
+  // Port 1 should not be writable.
+  hss = HandleSignalsState();
+  
+  ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
+            MojoWait(pipe1, MOJO_HANDLE_SIGNAL_WRITABLE,
+                     MOJO_DEADLINE_INDEFINITE, &hss));
+  ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+            hss.satisfied_signals);
+  ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+            hss.satisfiable_signals);
+
+  // But it should still be readable.
+  hss = HandleSignalsState();
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &hss));
+  ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+            hss.satisfied_signals);
+  ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+            hss.satisfiable_signals);
+
+  // Read from port 1.
+  buffer[0] = 0;
+  buffer_size = kBufferSize;
+  ASSERT_EQ(MOJO_RESULT_OK,
+            MojoReadMessage(pipe1, buffer, &buffer_size, nullptr, 0,
+                            MOJO_READ_MESSAGE_FLAG_NONE));
+  ASSERT_EQ(123456789, buffer[0]);
+
+  // Now port 1 should no longer be readable.
+  hss = HandleSignalsState();
+  ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
+            MojoWait(pipe1, MOJO_HANDLE_SIGNAL_READABLE,
+                     MOJO_DEADLINE_INDEFINITE, &hss));
+  ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
+  ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
+
+  MojoClose(pipe1);
+}
+
+}  // namespace
+}  // namespace system
+}  // namespace mojo