src/mojo/system/multiprocess_message_pipe_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <stdint.h>
   6 #include <stdio.h>
   7 #include <string.h>
   8
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/bind.h"
  13 #include "base/files/file_path.h"
  14 #include "base/files/file_util.h"
  15 #include "base/files/scoped_file.h"
  16 #include "base/files/scoped_temp_dir.h"
  17 #include "base/location.h"
  18 #include "base/logging.h"
  19 #include "base/macros.h"
  20 #include "build/build_config.h"  // TODO(vtl): Remove this.
  21 #include "mojo/common/test/test_utils.h"
  22 #include "mojo/embedder/platform_shared_buffer.h"
  23 #include "mojo/embedder/scoped_platform_handle.h"
  24 #include "mojo/system/channel.h"
  25 #include "mojo/system/dispatcher.h"
  26 #include "mojo/system/message_pipe.h"
  27 #include "mojo/system/message_pipe_test_utils.h"
  28 #include "mojo/system/platform_handle_dispatcher.h"
  29 #include "mojo/system/raw_channel.h"
  30 #include "mojo/system/shared_buffer_dispatcher.h"
  31 #include "mojo/system/test_utils.h"
  32 #include "testing/gtest/include/gtest/gtest.h"
  33
  34 namespace mojo {
  35 namespace system {
  36 namespace {
  37
  38 class MultiprocessMessagePipeTest
  39     : public test::MultiprocessMessagePipeTestBase {};
  40
  41 // For each message received, sends a reply message with the same contents
  42 // repeated twice, until the other end is closed or it receives "quitquitquit"
  43 // (which it doesn't reply to). It'll return the number of messages received,
  44 // not including any "quitquitquit" message, modulo 100.
  45 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(EchoEcho) {
  46   embedder::SimplePlatformSupport platform_support;
  47   test::ChannelThread channel_thread(&platform_support);
  48   embedder::ScopedPlatformHandle client_platform_handle =
  49       mojo::test::MultiprocessTestHelper::client_platform_handle.Pass();
  50   CHECK(client_platform_handle.is_valid());
  51   scoped_refptr<ChannelEndpoint> ep;
  52   scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
  53   channel_thread.Start(client_platform_handle.Pass(), ep);
  54
  55   const std::string quitquitquit("quitquitquit");
  56   int rv = 0;
  57   for (;; rv = (rv + 1) % 100) {
  58     // Wait for our end of the message pipe to be readable.
  59     HandleSignalsState hss;
  60     MojoResult result =
  61         test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss);
  62     if (result != MOJO_RESULT_OK) {
  63       // It was closed, probably.
  64       CHECK_EQ(result, MOJO_RESULT_FAILED_PRECONDITION);
  65       CHECK_EQ(hss.satisfied_signals, 0u);
  66       CHECK_EQ(hss.satisfiable_signals, 0u);
  67       break;
  68     } else {
  69       CHECK((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
  70       CHECK((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
  71     }
  72
  73     std::string read_buffer(1000, '\0');
  74     uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
  75     CHECK_EQ(mp->ReadMessage(0,
  76                              UserPointer<void>(&read_buffer[0]),
  77                              MakeUserPointer(&read_buffer_size),
  78                              nullptr,
  79                              nullptr,
  80                              MOJO_READ_MESSAGE_FLAG_NONE),
  81              MOJO_RESULT_OK);
  82     read_buffer.resize(read_buffer_size);
  83     VLOG(2) << "Child got: " << read_buffer;
  84
  85     if (read_buffer == quitquitquit) {
  86       VLOG(2) << "Child quitting.";
  87       break;
  88     }
  89
  90     std::string write_buffer = read_buffer + read_buffer;
  91     CHECK_EQ(mp->WriteMessage(0,
  92                               UserPointer<const void>(write_buffer.data()),
  93                               static_cast<uint32_t>(write_buffer.size()),
  94                               nullptr,
  95                               MOJO_WRITE_MESSAGE_FLAG_NONE),
  96              MOJO_RESULT_OK);
  97   }
  98
  99   mp->Close(0);
 100   return rv;
 101 }
 102
 103 // Sends "hello" to child, and expects "hellohello" back.
 104 TEST_F(MultiprocessMessagePipeTest, Basic) {
 105   helper()->StartChild("EchoEcho");
 106
 107   scoped_refptr<ChannelEndpoint> ep;
 108   scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
 109   Init(ep);
 110
 111   std::string hello("hello");
 112   EXPECT_EQ(MOJO_RESULT_OK,
 113             mp->WriteMessage(0,
 114                              UserPointer<const void>(hello.data()),
 115                              static_cast<uint32_t>(hello.size()),
 116                              nullptr,
 117                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 118
 119   HandleSignalsState hss;
 120   EXPECT_EQ(MOJO_RESULT_OK,
 121             test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
 122   // The child may or may not have closed its end of the message pipe and died
 123   // (and we may or may not know it yet), so our end may or may not appear as
 124   // writable.
 125   EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
 126   EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
 127
 128   std::string read_buffer(1000, '\0');
 129   uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
 130   CHECK_EQ(mp->ReadMessage(0,
 131                            UserPointer<void>(&read_buffer[0]),
 132                            MakeUserPointer(&read_buffer_size),
 133                            nullptr,
 134                            nullptr,
 135                            MOJO_READ_MESSAGE_FLAG_NONE),
 136            MOJO_RESULT_OK);
 137   read_buffer.resize(read_buffer_size);
 138   VLOG(2) << "Parent got: " << read_buffer;
 139   EXPECT_EQ(hello + hello, read_buffer);
 140
 141   mp->Close(0);
 142
 143   // We sent one message.
 144   EXPECT_EQ(1 % 100, helper()->WaitForChildShutdown());
 145 }
 146
 147 // Sends a bunch of messages to the child. Expects them "repeated" back. Waits
 148 // for the child to close its end before quitting.
 149 TEST_F(MultiprocessMessagePipeTest, QueueMessages) {
 150   helper()->StartChild("EchoEcho");
 151
 152   scoped_refptr<ChannelEndpoint> ep;
 153   scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
 154   Init(ep);
 155
 156   static const size_t kNumMessages = 1001;
 157   for (size_t i = 0; i < kNumMessages; i++) {
 158     std::string write_buffer(i, 'A' + (i % 26));
 159     EXPECT_EQ(MOJO_RESULT_OK,
 160               mp->WriteMessage(0,
 161                                UserPointer<const void>(write_buffer.data()),
 162                                static_cast<uint32_t>(write_buffer.size()),
 163                                nullptr,
 164                                MOJO_WRITE_MESSAGE_FLAG_NONE));
 165   }
 166
 167   const std::string quitquitquit("quitquitquit");
 168   EXPECT_EQ(MOJO_RESULT_OK,
 169             mp->WriteMessage(0,
 170                              UserPointer<const void>(quitquitquit.data()),
 171                              static_cast<uint32_t>(quitquitquit.size()),
 172                              nullptr,
 173                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 174
 175   for (size_t i = 0; i < kNumMessages; i++) {
 176     HandleSignalsState hss;
 177     EXPECT_EQ(MOJO_RESULT_OK,
 178               test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
 179     // The child may or may not have closed its end of the message pipe and died
 180     // (and we may or may not know it yet), so our end may or may not appear as
 181     // writable.
 182     EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
 183     EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
 184
 185     std::string read_buffer(kNumMessages * 2, '\0');
 186     uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
 187     CHECK_EQ(mp->ReadMessage(0,
 188                              UserPointer<void>(&read_buffer[0]),
 189                              MakeUserPointer(&read_buffer_size),
 190                              nullptr,
 191                              nullptr,
 192                              MOJO_READ_MESSAGE_FLAG_NONE),
 193              MOJO_RESULT_OK);
 194     read_buffer.resize(read_buffer_size);
 195
 196     EXPECT_EQ(std::string(i * 2, 'A' + (i % 26)), read_buffer);
 197   }
 198
 199   // Wait for it to become readable, which should fail (since we sent
 200   // "quitquitquit").
 201   HandleSignalsState hss;
 202   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 203             test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
 204   EXPECT_EQ(0u, hss.satisfied_signals);
 205   EXPECT_EQ(0u, hss.satisfiable_signals);
 206
 207   mp->Close(0);
 208
 209   EXPECT_EQ(static_cast<int>(kNumMessages % 100),
 210             helper()->WaitForChildShutdown());
 211 }
 212
 213 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckSharedBuffer) {
 214   embedder::SimplePlatformSupport platform_support;
 215   test::ChannelThread channel_thread(&platform_support);
 216   embedder::ScopedPlatformHandle client_platform_handle =
 217       mojo::test::MultiprocessTestHelper::client_platform_handle.Pass();
 218   CHECK(client_platform_handle.is_valid());
 219   scoped_refptr<ChannelEndpoint> ep;
 220   scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
 221   channel_thread.Start(client_platform_handle.Pass(), ep);
 222
 223   // Wait for the first message from our parent.
 224   HandleSignalsState hss;
 225   CHECK_EQ(test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss),
 226            MOJO_RESULT_OK);
 227   // In this test, the parent definitely doesn't close its end of the message
 228   // pipe before we do.
 229   CHECK_EQ(hss.satisfied_signals,
 230            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
 231   CHECK_EQ(hss.satisfiable_signals,
 232            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
 233
 234   // It should have a shared buffer.
 235   std::string read_buffer(100, '\0');
 236   uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
 237   DispatcherVector dispatchers;
 238   uint32_t num_dispatchers = 10;  // Maximum number to receive.
 239   CHECK_EQ(mp->ReadMessage(0,
 240                            UserPointer<void>(&read_buffer[0]),
 241                            MakeUserPointer(&num_bytes),
 242                            &dispatchers,
 243                            &num_dispatchers,
 244                            MOJO_READ_MESSAGE_FLAG_NONE),
 245            MOJO_RESULT_OK);
 246   read_buffer.resize(num_bytes);
 247   CHECK_EQ(read_buffer, std::string("go 1"));
 248   CHECK_EQ(num_dispatchers, 1u);
 249
 250   CHECK_EQ(dispatchers[0]->GetType(), Dispatcher::kTypeSharedBuffer);
 251
 252   scoped_refptr<SharedBufferDispatcher> dispatcher(
 253       static_cast<SharedBufferDispatcher*>(dispatchers[0].get()));
 254
 255   // Make a mapping.
 256   scoped_ptr<embedder::PlatformSharedBufferMapping> mapping;
 257   CHECK_EQ(dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping),
 258            MOJO_RESULT_OK);
 259   CHECK(mapping);
 260   CHECK(mapping->GetBase());
 261   CHECK_EQ(mapping->GetLength(), 100u);
 262
 263   // Write some stuff to the shared buffer.
 264   static const char kHello[] = "hello";
 265   memcpy(mapping->GetBase(), kHello, sizeof(kHello));
 266
 267   // We should be able to close the dispatcher now.
 268   dispatcher->Close();
 269
 270   // And send a message to signal that we've written stuff.
 271   const std::string go2("go 2");
 272   CHECK_EQ(mp->WriteMessage(0,
 273                             UserPointer<const void>(&go2[0]),
 274                             static_cast<uint32_t>(go2.size()),
 275                             nullptr,
 276                             MOJO_WRITE_MESSAGE_FLAG_NONE),
 277            MOJO_RESULT_OK);
 278
 279   // Now wait for our parent to send us a message.
 280   hss = HandleSignalsState();
 281   CHECK_EQ(test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss),
 282            MOJO_RESULT_OK);
 283   CHECK_EQ(hss.satisfied_signals,
 284            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
 285   CHECK_EQ(hss.satisfiable_signals,
 286            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
 287
 288   read_buffer = std::string(100, '\0');
 289   num_bytes = static_cast<uint32_t>(read_buffer.size());
 290   CHECK_EQ(mp->ReadMessage(0,
 291                            UserPointer<void>(&read_buffer[0]),
 292                            MakeUserPointer(&num_bytes),
 293                            nullptr,
 294                            nullptr,
 295                            MOJO_READ_MESSAGE_FLAG_NONE),
 296            MOJO_RESULT_OK);
 297   read_buffer.resize(num_bytes);
 298   CHECK_EQ(read_buffer, std::string("go 3"));
 299
 300   // It should have written something to the shared buffer.
 301   static const char kWorld[] = "world!!!";
 302   CHECK_EQ(memcmp(mapping->GetBase(), kWorld, sizeof(kWorld)), 0);
 303
 304   // And we're done.
 305   mp->Close(0);
 306
 307   return 0;
 308 }
 309
 310 #if defined(OS_POSIX)
 311 #define MAYBE_SharedBufferPassing SharedBufferPassing
 312 #else
 313 // Not yet implemented (on Windows).
 314 #define MAYBE_SharedBufferPassing DISABLED_SharedBufferPassing
 315 #endif
 316 TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) {
 317   helper()->StartChild("CheckSharedBuffer");
 318
 319   scoped_refptr<ChannelEndpoint> ep;
 320   scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
 321   Init(ep);
 322
 323   // Make a shared buffer.
 324   scoped_refptr<SharedBufferDispatcher> dispatcher;
 325   EXPECT_EQ(MOJO_RESULT_OK,
 326             SharedBufferDispatcher::Create(
 327                 platform_support(),
 328                 SharedBufferDispatcher::kDefaultCreateOptions,
 329                 100,
 330                 &dispatcher));
 331   ASSERT_TRUE(dispatcher.get());
 332
 333   // Make a mapping.
 334   scoped_ptr<embedder::PlatformSharedBufferMapping> mapping;
 335   EXPECT_EQ(MOJO_RESULT_OK,
 336             dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
 337   ASSERT_TRUE(mapping);
 338   ASSERT_TRUE(mapping->GetBase());
 339   ASSERT_EQ(100u, mapping->GetLength());
 340
 341   // Send the shared buffer.
 342   const std::string go1("go 1");
 343   DispatcherTransport transport(
 344       test::DispatcherTryStartTransport(dispatcher.get()));
 345   ASSERT_TRUE(transport.is_valid());
 346
 347   std::vector<DispatcherTransport> transports;
 348   transports.push_back(transport);
 349   EXPECT_EQ(MOJO_RESULT_OK,
 350             mp->WriteMessage(0,
 351                              UserPointer<const void>(&go1[0]),
 352                              static_cast<uint32_t>(go1.size()),
 353                              &transports,
 354                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 355   transport.End();
 356
 357   EXPECT_TRUE(dispatcher->HasOneRef());
 358   dispatcher = nullptr;
 359
 360   // Wait for a message from the child.
 361   HandleSignalsState hss;
 362   EXPECT_EQ(MOJO_RESULT_OK,
 363             test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
 364   EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
 365   EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
 366
 367   std::string read_buffer(100, '\0');
 368   uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
 369   EXPECT_EQ(MOJO_RESULT_OK,
 370             mp->ReadMessage(0,
 371                             UserPointer<void>(&read_buffer[0]),
 372                             MakeUserPointer(&num_bytes),
 373                             nullptr,
 374                             nullptr,
 375                             MOJO_READ_MESSAGE_FLAG_NONE));
 376   read_buffer.resize(num_bytes);
 377   EXPECT_EQ(std::string("go 2"), read_buffer);
 378
 379   // After we get it, the child should have written something to the shared
 380   // buffer.
 381   static const char kHello[] = "hello";
 382   EXPECT_EQ(0, memcmp(mapping->GetBase(), kHello, sizeof(kHello)));
 383
 384   // Now we'll write some stuff to the shared buffer.
 385   static const char kWorld[] = "world!!!";
 386   memcpy(mapping->GetBase(), kWorld, sizeof(kWorld));
 387
 388   // And send a message to signal that we've written stuff.
 389   const std::string go3("go 3");
 390   EXPECT_EQ(MOJO_RESULT_OK,
 391             mp->WriteMessage(0,
 392                              UserPointer<const void>(&go3[0]),
 393                              static_cast<uint32_t>(go3.size()),
 394                              nullptr,
 395                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 396
 397   // Wait for |mp| to become readable, which should fail.
 398   hss = HandleSignalsState();
 399   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 400             test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
 401   EXPECT_EQ(0u, hss.satisfied_signals);
 402   EXPECT_EQ(0u, hss.satisfiable_signals);
 403
 404   mp->Close(0);
 405
 406   EXPECT_EQ(0, helper()->WaitForChildShutdown());
 407 }
 408
 409 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckPlatformHandleFile) {
 410   embedder::SimplePlatformSupport platform_support;
 411   test::ChannelThread channel_thread(&platform_support);
 412   embedder::ScopedPlatformHandle client_platform_handle =
 413       mojo::test::MultiprocessTestHelper::client_platform_handle.Pass();
 414   CHECK(client_platform_handle.is_valid());
 415   scoped_refptr<ChannelEndpoint> ep;
 416   scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
 417   channel_thread.Start(client_platform_handle.Pass(), ep);
 418
 419   HandleSignalsState hss;
 420   CHECK_EQ(test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss),
 421            MOJO_RESULT_OK);
 422   CHECK_EQ(hss.satisfied_signals,
 423            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
 424   CHECK_EQ(hss.satisfiable_signals,
 425            MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
 426
 427   std::string read_buffer(100, '\0');
 428   uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
 429   DispatcherVector dispatchers;
 430   uint32_t num_dispatchers = 10;  // Maximum number to receive.
 431   CHECK_EQ(mp->ReadMessage(0,
 432                            UserPointer<void>(&read_buffer[0]),
 433                            MakeUserPointer(&num_bytes),
 434                            &dispatchers,
 435                            &num_dispatchers,
 436                            MOJO_READ_MESSAGE_FLAG_NONE),
 437            MOJO_RESULT_OK);
 438   mp->Close(0);
 439
 440   read_buffer.resize(num_bytes);
 441   CHECK_EQ(read_buffer, std::string("hello"));
 442   CHECK_EQ(num_dispatchers, 1u);
 443
 444   CHECK_EQ(dispatchers[0]->GetType(), Dispatcher::kTypePlatformHandle);
 445
 446   scoped_refptr<PlatformHandleDispatcher> dispatcher(
 447       static_cast<PlatformHandleDispatcher*>(dispatchers[0].get()));
 448   embedder::ScopedPlatformHandle h = dispatcher->PassPlatformHandle().Pass();
 449   CHECK(h.is_valid());
 450   dispatcher->Close();
 451
 452   base::ScopedFILE fp(mojo::test::FILEFromPlatformHandle(h.Pass(), "r"));
 453   CHECK(fp);
 454   std::string fread_buffer(100, '\0');
 455   size_t bytes_read = fread(&fread_buffer[0], 1, fread_buffer.size(), fp.get());
 456   fread_buffer.resize(bytes_read);
 457   CHECK_EQ(fread_buffer, "world");
 458
 459   return 0;
 460 }
 461
 462 #if defined(OS_POSIX)
 463 #define MAYBE_PlatformHandlePassing PlatformHandlePassing
 464 #else
 465 // Not yet implemented (on Windows).
 466 #define MAYBE_PlatformHandlePassing DISABLED_PlatformHandlePassing
 467 #endif
 468 TEST_F(MultiprocessMessagePipeTest, MAYBE_PlatformHandlePassing) {
 469   base::ScopedTempDir temp_dir;
 470   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 471
 472   helper()->StartChild("CheckPlatformHandleFile");
 473
 474   scoped_refptr<ChannelEndpoint> ep;
 475   scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
 476   Init(ep);
 477
 478   base::FilePath unused;
 479   base::ScopedFILE fp(
 480       CreateAndOpenTemporaryFileInDir(temp_dir.path(), &unused));
 481   const std::string world("world");
 482   ASSERT_EQ(fwrite(&world[0], 1, world.size(), fp.get()), world.size());
 483   fflush(fp.get());
 484   rewind(fp.get());
 485
 486   embedder::ScopedPlatformHandle h(
 487       mojo::test::PlatformHandleFromFILE(fp.Pass()));
 488   scoped_refptr<PlatformHandleDispatcher> dispatcher(
 489       new PlatformHandleDispatcher(h.Pass()));
 490
 491   const std::string hello("hello");
 492   DispatcherTransport transport(
 493       test::DispatcherTryStartTransport(dispatcher.get()));
 494   ASSERT_TRUE(transport.is_valid());
 495
 496   std::vector<DispatcherTransport> transports;
 497   transports.push_back(transport);
 498   EXPECT_EQ(MOJO_RESULT_OK,
 499             mp->WriteMessage(0,
 500                              UserPointer<const void>(&hello[0]),
 501                              static_cast<uint32_t>(hello.size()),
 502                              &transports,
 503                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 504   transport.End();
 505
 506   EXPECT_TRUE(dispatcher->HasOneRef());
 507   dispatcher = nullptr;
 508
 509   // Wait for it to become readable, which should fail.
 510   HandleSignalsState hss;
 511   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 512             test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
 513   EXPECT_EQ(0u, hss.satisfied_signals);
 514   EXPECT_EQ(0u, hss.satisfiable_signals);
 515
 516   mp->Close(0);
 517
 518   EXPECT_EQ(0, helper()->WaitForChildShutdown());
 519 }
 520
 521 }  // namespace
 522 }  // namespace system
 523 }  // namespace mojo