mojo/system/core_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 "mojo/system/core.h"
   6
   7 #include <stdint.h>
   8
   9 #include <limits>
  10
  11 #include "base/threading/platform_thread.h"
  12 #include "base/time/time.h"
  13 #include "mojo/system/core_test_base.h"
  14
  15 namespace mojo {
  16 namespace system {
  17 namespace {
  18
  19 const MojoHandleSignalsState kEmptyMojoHandleSignalsState = {0u, 0u};
  20 const MojoHandleSignalsState kFullMojoHandleSignalsState = {~0u, ~0u};
  21
  22 typedef test::CoreTestBase CoreTest;
  23
  24 TEST_F(CoreTest, GetTimeTicksNow) {
  25   const MojoTimeTicks start = core()->GetTimeTicksNow();
  26   EXPECT_NE(static_cast<MojoTimeTicks>(0), start)
  27       << "GetTimeTicksNow should return nonzero value";
  28   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(15));
  29   const MojoTimeTicks finish = core()->GetTimeTicksNow();
  30   // Allow for some fuzz in sleep.
  31   EXPECT_GE((finish - start), static_cast<MojoTimeTicks>(8000))
  32       << "Sleeping should result in increasing time ticks";
  33 }
  34
  35 TEST_F(CoreTest, Basic) {
  36   MockHandleInfo info;
  37
  38   EXPECT_EQ(0u, info.GetCtorCallCount());
  39   MojoHandle h = CreateMockHandle(&info);
  40   EXPECT_EQ(1u, info.GetCtorCallCount());
  41   EXPECT_NE(h, MOJO_HANDLE_INVALID);
  42
  43   EXPECT_EQ(0u, info.GetWriteMessageCallCount());
  44   EXPECT_EQ(MOJO_RESULT_OK,
  45             core()->WriteMessage(h,
  46                                  NullUserPointer(),
  47                                  0,
  48                                  NullUserPointer(),
  49                                  0,
  50                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
  51   EXPECT_EQ(1u, info.GetWriteMessageCallCount());
  52
  53   EXPECT_EQ(0u, info.GetReadMessageCallCount());
  54   uint32_t num_bytes = 0;
  55   EXPECT_EQ(MOJO_RESULT_OK,
  56             core()->ReadMessage(h,
  57                                 NullUserPointer(),
  58                                 MakeUserPointer(&num_bytes),
  59                                 NullUserPointer(),
  60                                 NullUserPointer(),
  61                                 MOJO_READ_MESSAGE_FLAG_NONE));
  62   EXPECT_EQ(1u, info.GetReadMessageCallCount());
  63   EXPECT_EQ(MOJO_RESULT_OK,
  64             core()->ReadMessage(h,
  65                                 NullUserPointer(),
  66                                 NullUserPointer(),
  67                                 NullUserPointer(),
  68                                 NullUserPointer(),
  69                                 MOJO_READ_MESSAGE_FLAG_NONE));
  70   EXPECT_EQ(2u, info.GetReadMessageCallCount());
  71
  72   EXPECT_EQ(0u, info.GetWriteDataCallCount());
  73   EXPECT_EQ(
  74       MOJO_RESULT_UNIMPLEMENTED,
  75       core()->WriteData(
  76           h, NullUserPointer(), NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE));
  77   EXPECT_EQ(1u, info.GetWriteDataCallCount());
  78
  79   EXPECT_EQ(0u, info.GetBeginWriteDataCallCount());
  80   EXPECT_EQ(
  81       MOJO_RESULT_UNIMPLEMENTED,
  82       core()->BeginWriteData(
  83           h, NullUserPointer(), NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE));
  84   EXPECT_EQ(1u, info.GetBeginWriteDataCallCount());
  85
  86   EXPECT_EQ(0u, info.GetEndWriteDataCallCount());
  87   EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, core()->EndWriteData(h, 0));
  88   EXPECT_EQ(1u, info.GetEndWriteDataCallCount());
  89
  90   EXPECT_EQ(0u, info.GetReadDataCallCount());
  91   EXPECT_EQ(
  92       MOJO_RESULT_UNIMPLEMENTED,
  93       core()->ReadData(
  94           h, NullUserPointer(), NullUserPointer(), MOJO_READ_DATA_FLAG_NONE));
  95   EXPECT_EQ(1u, info.GetReadDataCallCount());
  96
  97   EXPECT_EQ(0u, info.GetBeginReadDataCallCount());
  98   EXPECT_EQ(
  99       MOJO_RESULT_UNIMPLEMENTED,
 100       core()->BeginReadData(
 101           h, NullUserPointer(), NullUserPointer(), MOJO_READ_DATA_FLAG_NONE));
 102   EXPECT_EQ(1u, info.GetBeginReadDataCallCount());
 103
 104   EXPECT_EQ(0u, info.GetEndReadDataCallCount());
 105   EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, core()->EndReadData(h, 0));
 106   EXPECT_EQ(1u, info.GetEndReadDataCallCount());
 107
 108   EXPECT_EQ(0u, info.GetAddWaiterCallCount());
 109   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 110             core()->Wait(h,
 111                          ~MOJO_HANDLE_SIGNAL_NONE,
 112                          MOJO_DEADLINE_INDEFINITE,
 113                          NullUserPointer()));
 114   EXPECT_EQ(1u, info.GetAddWaiterCallCount());
 115   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 116             core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 0, NullUserPointer()));
 117   EXPECT_EQ(2u, info.GetAddWaiterCallCount());
 118   MojoHandleSignalsState hss = kFullMojoHandleSignalsState;
 119   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 120             core()->Wait(h,
 121                          ~MOJO_HANDLE_SIGNAL_NONE,
 122                          MOJO_DEADLINE_INDEFINITE,
 123                          MakeUserPointer(&hss)));
 124   EXPECT_EQ(3u, info.GetAddWaiterCallCount());
 125   EXPECT_EQ(0u, hss.satisfied_signals);
 126   EXPECT_EQ(0u, hss.satisfiable_signals);
 127   EXPECT_EQ(
 128       MOJO_RESULT_FAILED_PRECONDITION,
 129       core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000, NullUserPointer()));
 130   EXPECT_EQ(4u, info.GetAddWaiterCallCount());
 131   hss = kFullMojoHandleSignalsState;
 132   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 133             core()->Wait(
 134                 h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000, MakeUserPointer(&hss)));
 135   EXPECT_EQ(5u, info.GetAddWaiterCallCount());
 136   EXPECT_EQ(0u, hss.satisfied_signals);
 137   EXPECT_EQ(0u, hss.satisfiable_signals);
 138
 139   MojoHandleSignals handle_signals = ~MOJO_HANDLE_SIGNAL_NONE;
 140   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 141             core()->WaitMany(MakeUserPointer(&h),
 142                              MakeUserPointer(&handle_signals),
 143                              1,
 144                              MOJO_DEADLINE_INDEFINITE,
 145                              NullUserPointer(),
 146                              NullUserPointer()));
 147   EXPECT_EQ(6u, info.GetAddWaiterCallCount());
 148   uint32_t result_index = static_cast<uint32_t>(-1);
 149   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 150             core()->WaitMany(MakeUserPointer(&h),
 151                              MakeUserPointer(&handle_signals),
 152                              1,
 153                              MOJO_DEADLINE_INDEFINITE,
 154                              MakeUserPointer(&result_index),
 155                              NullUserPointer()));
 156   EXPECT_EQ(7u, info.GetAddWaiterCallCount());
 157   EXPECT_EQ(0u, result_index);
 158   hss = kFullMojoHandleSignalsState;
 159   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 160             core()->WaitMany(MakeUserPointer(&h),
 161                              MakeUserPointer(&handle_signals),
 162                              1,
 163                              MOJO_DEADLINE_INDEFINITE,
 164                              NullUserPointer(),
 165                              MakeUserPointer(&hss)));
 166   EXPECT_EQ(8u, info.GetAddWaiterCallCount());
 167   EXPECT_EQ(0u, hss.satisfied_signals);
 168   EXPECT_EQ(0u, hss.satisfiable_signals);
 169   result_index = static_cast<uint32_t>(-1);
 170   hss = kFullMojoHandleSignalsState;
 171   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 172             core()->WaitMany(MakeUserPointer(&h),
 173                              MakeUserPointer(&handle_signals),
 174                              1,
 175                              MOJO_DEADLINE_INDEFINITE,
 176                              MakeUserPointer(&result_index),
 177                              MakeUserPointer(&hss)));
 178   EXPECT_EQ(9u, info.GetAddWaiterCallCount());
 179   EXPECT_EQ(0u, result_index);
 180   EXPECT_EQ(0u, hss.satisfied_signals);
 181   EXPECT_EQ(0u, hss.satisfiable_signals);
 182
 183   EXPECT_EQ(0u, info.GetDtorCallCount());
 184   EXPECT_EQ(0u, info.GetCloseCallCount());
 185   EXPECT_EQ(0u, info.GetCancelAllWaitersCallCount());
 186   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
 187   EXPECT_EQ(1u, info.GetCancelAllWaitersCallCount());
 188   EXPECT_EQ(1u, info.GetCloseCallCount());
 189   EXPECT_EQ(1u, info.GetDtorCallCount());
 190
 191   // No waiters should ever have ever been added.
 192   EXPECT_EQ(0u, info.GetRemoveWaiterCallCount());
 193 }
 194
 195 TEST_F(CoreTest, InvalidArguments) {
 196   // |Close()|:
 197   {
 198     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(MOJO_HANDLE_INVALID));
 199     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(10));
 200     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(1000000000));
 201
 202     // Test a double-close.
 203     MockHandleInfo info;
 204     MojoHandle h = CreateMockHandle(&info);
 205     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
 206     EXPECT_EQ(1u, info.GetCloseCallCount());
 207     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(h));
 208     EXPECT_EQ(1u, info.GetCloseCallCount());
 209   }
 210
 211   // |Wait()|:
 212   {
 213     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 214               core()->Wait(MOJO_HANDLE_INVALID,
 215                            ~MOJO_HANDLE_SIGNAL_NONE,
 216                            MOJO_DEADLINE_INDEFINITE,
 217                            NullUserPointer()));
 218     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 219               core()->Wait(10,
 220                            ~MOJO_HANDLE_SIGNAL_NONE,
 221                            MOJO_DEADLINE_INDEFINITE,
 222                            NullUserPointer()));
 223
 224     MojoHandleSignalsState hss = kFullMojoHandleSignalsState;
 225     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 226               core()->Wait(MOJO_HANDLE_INVALID,
 227                            ~MOJO_HANDLE_SIGNAL_NONE,
 228                            MOJO_DEADLINE_INDEFINITE,
 229                            MakeUserPointer(&hss)));
 230     // On invalid argument, it shouldn't modify the handle signals state.
 231     EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
 232               hss.satisfied_signals);
 233     EXPECT_EQ(kFullMojoHandleSignalsState.satisfiable_signals,
 234               hss.satisfiable_signals);
 235     hss = kFullMojoHandleSignalsState;
 236     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 237               core()->Wait(10,
 238                            ~MOJO_HANDLE_SIGNAL_NONE,
 239                            MOJO_DEADLINE_INDEFINITE,
 240                            MakeUserPointer(&hss)));
 241     // On invalid argument, it shouldn't modify the handle signals state.
 242     EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
 243               hss.satisfied_signals);
 244     EXPECT_EQ(kFullMojoHandleSignalsState.satisfiable_signals,
 245               hss.satisfiable_signals);
 246   }
 247
 248   // |WaitMany()|:
 249   {
 250     MojoHandle handles[2] = {MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID};
 251     MojoHandleSignals signals[2] = {~MOJO_HANDLE_SIGNAL_NONE,
 252                                     ~MOJO_HANDLE_SIGNAL_NONE};
 253     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 254               core()->WaitMany(MakeUserPointer(handles),
 255                                MakeUserPointer(signals),
 256                                0,
 257                                MOJO_DEADLINE_INDEFINITE,
 258                                NullUserPointer(),
 259                                NullUserPointer()));
 260     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 261               core()->WaitMany(NullUserPointer(),
 262                                MakeUserPointer(signals),
 263                                0,
 264                                MOJO_DEADLINE_INDEFINITE,
 265                                NullUserPointer(),
 266                                NullUserPointer()));
 267     // If |num_handles| is invalid, it should leave |result_index| and
 268     // |signals_states| alone.
 269     // (We use -1 internally; make sure that doesn't leak.)
 270     uint32_t result_index = 123;
 271     MojoHandleSignalsState hss = kFullMojoHandleSignalsState;
 272     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 273               core()->WaitMany(NullUserPointer(),
 274                                MakeUserPointer(signals),
 275                                0,
 276                                MOJO_DEADLINE_INDEFINITE,
 277                                MakeUserPointer(&result_index),
 278                                MakeUserPointer(&hss)));
 279     EXPECT_EQ(123u, result_index);
 280     EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
 281               hss.satisfied_signals);
 282     EXPECT_EQ(kFullMojoHandleSignalsState.satisfiable_signals,
 283               hss.satisfiable_signals);
 284
 285     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 286               core()->WaitMany(MakeUserPointer(handles),
 287                                NullUserPointer(),
 288                                0,
 289                                MOJO_DEADLINE_INDEFINITE,
 290                                NullUserPointer(),
 291                                NullUserPointer()));
 292     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 293               core()->WaitMany(MakeUserPointer(handles),
 294                                MakeUserPointer(signals),
 295                                1,
 296                                MOJO_DEADLINE_INDEFINITE,
 297                                NullUserPointer(),
 298                                NullUserPointer()));
 299     // But if a handle is bad, then it should set |result_index| but still leave
 300     // |signals_states| alone.
 301     result_index = static_cast<uint32_t>(-1);
 302     hss = kFullMojoHandleSignalsState;
 303     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 304               core()->WaitMany(MakeUserPointer(handles),
 305                                MakeUserPointer(signals),
 306                                1,
 307                                MOJO_DEADLINE_INDEFINITE,
 308                                MakeUserPointer(&result_index),
 309                                MakeUserPointer(&hss)));
 310     EXPECT_EQ(0u, result_index);
 311     EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
 312               hss.satisfied_signals);
 313     EXPECT_EQ(kFullMojoHandleSignalsState.satisfiable_signals,
 314               hss.satisfiable_signals);
 315
 316     MockHandleInfo info[2];
 317     handles[0] = CreateMockHandle(&info[0]);
 318
 319     result_index = static_cast<uint32_t>(-1);
 320     hss = kFullMojoHandleSignalsState;
 321     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 322               core()->WaitMany(MakeUserPointer(handles),
 323                                MakeUserPointer(signals),
 324                                1,
 325                                MOJO_DEADLINE_INDEFINITE,
 326                                MakeUserPointer(&result_index),
 327                                MakeUserPointer(&hss)));
 328     EXPECT_EQ(0u, result_index);
 329     EXPECT_EQ(0u, hss.satisfied_signals);
 330     EXPECT_EQ(0u, hss.satisfiable_signals);
 331
 332     // On invalid argument, it'll leave |signals_states| alone.
 333     result_index = static_cast<uint32_t>(-1);
 334     hss = kFullMojoHandleSignalsState;
 335     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 336               core()->WaitMany(MakeUserPointer(handles),
 337                                MakeUserPointer(signals),
 338                                2,
 339                                MOJO_DEADLINE_INDEFINITE,
 340                                MakeUserPointer(&result_index),
 341                                MakeUserPointer(&hss)));
 342     EXPECT_EQ(1u, result_index);
 343     EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
 344               hss.satisfied_signals);
 345     EXPECT_EQ(kFullMojoHandleSignalsState.satisfiable_signals,
 346               hss.satisfiable_signals);
 347     handles[1] = handles[0] + 1;  // Invalid handle.
 348     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 349               core()->WaitMany(MakeUserPointer(handles),
 350                                MakeUserPointer(signals),
 351                                2,
 352                                MOJO_DEADLINE_INDEFINITE,
 353                                NullUserPointer(),
 354                                NullUserPointer()));
 355     handles[1] = CreateMockHandle(&info[1]);
 356     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 357               core()->WaitMany(MakeUserPointer(handles),
 358                                MakeUserPointer(signals),
 359                                2,
 360                                MOJO_DEADLINE_INDEFINITE,
 361                                NullUserPointer(),
 362                                NullUserPointer()));
 363
 364     // TODO(vtl): Test one where we get "failed precondition" only for the
 365     // second handle (and the first one is valid to wait on).
 366
 367     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(handles[0]));
 368     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(handles[1]));
 369   }
 370
 371   // |CreateMessagePipe()|: Nothing to check (apart from things that cause
 372   // death).
 373
 374   // |WriteMessage()|:
 375   // Only check arguments checked by |Core|, namely |handle|, |handles|, and
 376   // |num_handles|.
 377   {
 378     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 379               core()->WriteMessage(MOJO_HANDLE_INVALID,
 380                                    NullUserPointer(),
 381                                    0,
 382                                    NullUserPointer(),
 383                                    0,
 384                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 385
 386     MockHandleInfo info;
 387     MojoHandle h = CreateMockHandle(&info);
 388     MojoHandle handles[2] = {MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID};
 389
 390     // Huge handle count (implausibly big on some systems -- more than can be
 391     // stored in a 32-bit address space).
 392     // Note: This may return either |MOJO_RESULT_INVALID_ARGUMENT| or
 393     // |MOJO_RESULT_RESOURCE_EXHAUSTED|, depending on whether it's plausible or
 394     // not.
 395     EXPECT_NE(MOJO_RESULT_OK,
 396               core()->WriteMessage(h,
 397                                    NullUserPointer(),
 398                                    0,
 399                                    MakeUserPointer(handles),
 400                                    std::numeric_limits<uint32_t>::max(),
 401                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 402     EXPECT_EQ(0u, info.GetWriteMessageCallCount());
 403
 404     // Huge handle count (plausibly big).
 405     EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
 406               core()->WriteMessage(
 407                   h,
 408                   NullUserPointer(),
 409                   0,
 410                   MakeUserPointer(handles),
 411                   std::numeric_limits<uint32_t>::max() / sizeof(handles[0]),
 412                   MOJO_WRITE_MESSAGE_FLAG_NONE));
 413     EXPECT_EQ(0u, info.GetWriteMessageCallCount());
 414
 415     // Invalid handle in |handles|.
 416     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 417               core()->WriteMessage(h,
 418                                    NullUserPointer(),
 419                                    0,
 420                                    MakeUserPointer(handles),
 421                                    1,
 422                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 423     EXPECT_EQ(0u, info.GetWriteMessageCallCount());
 424
 425     // Two invalid handles in |handles|.
 426     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 427               core()->WriteMessage(h,
 428                                    NullUserPointer(),
 429                                    0,
 430                                    MakeUserPointer(handles),
 431                                    2,
 432                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 433     EXPECT_EQ(0u, info.GetWriteMessageCallCount());
 434
 435     // Can't send a handle over itself.
 436     handles[0] = h;
 437     EXPECT_EQ(MOJO_RESULT_BUSY,
 438               core()->WriteMessage(h,
 439                                    NullUserPointer(),
 440                                    0,
 441                                    MakeUserPointer(handles),
 442                                    1,
 443                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 444     EXPECT_EQ(0u, info.GetWriteMessageCallCount());
 445
 446     MockHandleInfo info2;
 447     MojoHandle h2 = CreateMockHandle(&info2);
 448
 449     // This is "okay", but |MockDispatcher| doesn't implement it.
 450     handles[0] = h2;
 451     EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
 452               core()->WriteMessage(h,
 453                                    NullUserPointer(),
 454                                    0,
 455                                    MakeUserPointer(handles),
 456                                    1,
 457                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 458     EXPECT_EQ(1u, info.GetWriteMessageCallCount());
 459
 460     // One of the |handles| is still invalid.
 461     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 462               core()->WriteMessage(h,
 463                                    NullUserPointer(),
 464                                    0,
 465                                    MakeUserPointer(handles),
 466                                    2,
 467                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 468     EXPECT_EQ(1u, info.GetWriteMessageCallCount());
 469
 470     // One of the |handles| is the same as |handle|.
 471     handles[1] = h;
 472     EXPECT_EQ(MOJO_RESULT_BUSY,
 473               core()->WriteMessage(h,
 474                                    NullUserPointer(),
 475                                    0,
 476                                    MakeUserPointer(handles),
 477                                    2,
 478                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 479     EXPECT_EQ(1u, info.GetWriteMessageCallCount());
 480
 481     // Can't send a handle twice in the same message.
 482     handles[1] = h2;
 483     EXPECT_EQ(MOJO_RESULT_BUSY,
 484               core()->WriteMessage(h,
 485                                    NullUserPointer(),
 486                                    0,
 487                                    MakeUserPointer(handles),
 488                                    2,
 489                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 490     EXPECT_EQ(1u, info.GetWriteMessageCallCount());
 491
 492     // Note: Since we never successfully sent anything with it, |h2| should
 493     // still be valid.
 494     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h2));
 495
 496     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
 497   }
 498
 499   // |ReadMessage()|:
 500   // Only check arguments checked by |Core|, namely |handle|, |handles|, and
 501   // |num_handles|.
 502   {
 503     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 504               core()->ReadMessage(MOJO_HANDLE_INVALID,
 505                                   NullUserPointer(),
 506                                   NullUserPointer(),
 507                                   NullUserPointer(),
 508                                   NullUserPointer(),
 509                                   MOJO_READ_MESSAGE_FLAG_NONE));
 510
 511     MockHandleInfo info;
 512     MojoHandle h = CreateMockHandle(&info);
 513
 514     // Okay.
 515     uint32_t handle_count = 0;
 516     EXPECT_EQ(MOJO_RESULT_OK,
 517               core()->ReadMessage(h,
 518                                   NullUserPointer(),
 519                                   NullUserPointer(),
 520                                   NullUserPointer(),
 521                                   MakeUserPointer(&handle_count),
 522                                   MOJO_READ_MESSAGE_FLAG_NONE));
 523     // Checked by |Core|, shouldn't go through to the dispatcher.
 524     EXPECT_EQ(1u, info.GetReadMessageCallCount());
 525
 526     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
 527   }
 528 }
 529
 530 // These test invalid arguments that should cause death if we're being paranoid
 531 // about checking arguments (which we would want to do if, e.g., we were in a
 532 // true "kernel" situation, but we might not want to do otherwise for
 533 // performance reasons). Probably blatant errors like passing in null pointers
 534 // (for required pointer arguments) will still cause death, but perhaps not
 535 // predictably.
 536 TEST_F(CoreTest, InvalidArgumentsDeath) {
 537   const char kMemoryCheckFailedRegex[] = "Check failed";
 538
 539   // |WaitMany()|:
 540   {
 541     MojoHandle handle = MOJO_HANDLE_INVALID;
 542     MojoHandleSignals signals = ~MOJO_HANDLE_SIGNAL_NONE;
 543     EXPECT_DEATH_IF_SUPPORTED(core()->WaitMany(NullUserPointer(),
 544                                                MakeUserPointer(&signals),
 545                                                1,
 546                                                MOJO_DEADLINE_INDEFINITE,
 547                                                NullUserPointer(),
 548                                                NullUserPointer()),
 549                               kMemoryCheckFailedRegex);
 550     EXPECT_DEATH_IF_SUPPORTED(core()->WaitMany(MakeUserPointer(&handle),
 551                                                NullUserPointer(),
 552                                                1,
 553                                                MOJO_DEADLINE_INDEFINITE,
 554                                                NullUserPointer(),
 555                                                NullUserPointer()),
 556                               kMemoryCheckFailedRegex);
 557     // TODO(vtl): |result_index| and |signals_states| are optional. Test them
 558     // with non-null invalid pointers?
 559   }
 560
 561   // |CreateMessagePipe()|:
 562   {
 563     MojoHandle h;
 564     EXPECT_DEATH_IF_SUPPORTED(
 565         core()->CreateMessagePipe(
 566             NullUserPointer(), NullUserPointer(), NullUserPointer()),
 567         kMemoryCheckFailedRegex);
 568     EXPECT_DEATH_IF_SUPPORTED(
 569         core()->CreateMessagePipe(
 570             NullUserPointer(), MakeUserPointer(&h), NullUserPointer()),
 571         kMemoryCheckFailedRegex);
 572     EXPECT_DEATH_IF_SUPPORTED(
 573         core()->CreateMessagePipe(
 574             NullUserPointer(), NullUserPointer(), MakeUserPointer(&h)),
 575         kMemoryCheckFailedRegex);
 576   }
 577
 578   // |WriteMessage()|:
 579   // Only check arguments checked by |Core|, namely |handle|, |handles|, and
 580   // |num_handles|.
 581   {
 582     MockHandleInfo info;
 583     MojoHandle h = CreateMockHandle(&info);
 584
 585     // Null |handles| with nonzero |num_handles|.
 586     EXPECT_DEATH_IF_SUPPORTED(
 587         core()->WriteMessage(h,
 588                              NullUserPointer(),
 589                              0,
 590                              NullUserPointer(),
 591                              1,
 592                              MOJO_WRITE_MESSAGE_FLAG_NONE),
 593         kMemoryCheckFailedRegex);
 594
 595     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
 596   }
 597
 598   // |ReadMessage()|:
 599   // Only check arguments checked by |Core|, namely |handle|, |handles|, and
 600   // |num_handles|.
 601   {
 602     MockHandleInfo info;
 603     MojoHandle h = CreateMockHandle(&info);
 604
 605     uint32_t handle_count = 1;
 606     EXPECT_DEATH_IF_SUPPORTED(
 607         core()->ReadMessage(h,
 608                             NullUserPointer(),
 609                             NullUserPointer(),
 610                             NullUserPointer(),
 611                             MakeUserPointer(&handle_count),
 612                             MOJO_READ_MESSAGE_FLAG_NONE),
 613         kMemoryCheckFailedRegex);
 614
 615     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
 616   }
 617 }
 618
 619 // TODO(vtl): test |Wait()| and |WaitMany()| properly
 620 //  - including |WaitMany()| with the same handle more than once (with
 621 //    same/different signals)
 622
 623 TEST_F(CoreTest, MessagePipe) {
 624   MojoHandle h[2];
 625   MojoHandleSignalsState hss[2];
 626   uint32_t result_index;
 627
 628   EXPECT_EQ(
 629       MOJO_RESULT_OK,
 630       core()->CreateMessagePipe(
 631           NullUserPointer(), MakeUserPointer(&h[0]), MakeUserPointer(&h[1])));
 632   // Should get two distinct, valid handles.
 633   EXPECT_NE(h[0], MOJO_HANDLE_INVALID);
 634   EXPECT_NE(h[1], MOJO_HANDLE_INVALID);
 635   EXPECT_NE(h[0], h[1]);
 636
 637   // Neither should be readable.
 638   MojoHandleSignals signals[2] = {MOJO_HANDLE_SIGNAL_READABLE,
 639                                   MOJO_HANDLE_SIGNAL_READABLE};
 640   result_index = static_cast<uint32_t>(-1);
 641   hss[0] = kEmptyMojoHandleSignalsState;
 642   hss[1] = kEmptyMojoHandleSignalsState;
 643   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
 644             core()->WaitMany(MakeUserPointer(h),
 645                              MakeUserPointer(signals),
 646                              2,
 647                              0,
 648                              MakeUserPointer(&result_index),
 649                              MakeUserPointer(hss)));
 650   EXPECT_EQ(static_cast<uint32_t>(-1), result_index);
 651   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
 652   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
 653             hss[0].satisfiable_signals);
 654   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[1].satisfied_signals);
 655   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
 656             hss[1].satisfiable_signals);
 657
 658   // Try to read anyway.
 659   char buffer[1] = {'a'};
 660   uint32_t buffer_size = 1;
 661   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
 662             core()->ReadMessage(h[0],
 663                                 UserPointer<void>(buffer),
 664                                 MakeUserPointer(&buffer_size),
 665                                 NullUserPointer(),
 666                                 NullUserPointer(),
 667                                 MOJO_READ_MESSAGE_FLAG_NONE));
 668   // Check that it left its inputs alone.
 669   EXPECT_EQ('a', buffer[0]);
 670   EXPECT_EQ(1u, buffer_size);
 671
 672   // Both should be writable.
 673   hss[0] = kEmptyMojoHandleSignalsState;
 674   EXPECT_EQ(MOJO_RESULT_OK,
 675             core()->Wait(h[0],
 676                          MOJO_HANDLE_SIGNAL_WRITABLE,
 677                          1000000000,
 678                          MakeUserPointer(&hss[0])));
 679   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
 680   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
 681             hss[0].satisfiable_signals);
 682   hss[0] = kEmptyMojoHandleSignalsState;
 683   EXPECT_EQ(MOJO_RESULT_OK,
 684             core()->Wait(h[1],
 685                          MOJO_HANDLE_SIGNAL_WRITABLE,
 686                          1000000000,
 687                          MakeUserPointer(&hss[0])));
 688   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
 689   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
 690             hss[0].satisfiable_signals);
 691
 692   // Also check that |h[1]| is writable using |WaitMany()|.
 693   signals[0] = MOJO_HANDLE_SIGNAL_READABLE;
 694   signals[1] = MOJO_HANDLE_SIGNAL_WRITABLE;
 695   result_index = static_cast<uint32_t>(-1);
 696   hss[0] = kEmptyMojoHandleSignalsState;
 697   hss[1] = kEmptyMojoHandleSignalsState;
 698   EXPECT_EQ(MOJO_RESULT_OK,
 699             core()->WaitMany(MakeUserPointer(h),
 700                              MakeUserPointer(signals),
 701                              2,
 702                              MOJO_DEADLINE_INDEFINITE,
 703                              MakeUserPointer(&result_index),
 704                              MakeUserPointer(hss)));
 705   EXPECT_EQ(1u, result_index);
 706   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
 707   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
 708             hss[0].satisfiable_signals);
 709   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[1].satisfied_signals);
 710   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
 711             hss[1].satisfiable_signals);
 712
 713   // Write to |h[1]|.
 714   buffer[0] = 'b';
 715   EXPECT_EQ(MOJO_RESULT_OK,
 716             core()->WriteMessage(h[1],
 717                                  UserPointer<const void>(buffer),
 718                                  1,
 719                                  NullUserPointer(),
 720                                  0,
 721                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 722
 723   // Check that |h[0]| is now readable.
 724   signals[0] = MOJO_HANDLE_SIGNAL_READABLE;
 725   signals[1] = MOJO_HANDLE_SIGNAL_READABLE;
 726   result_index = static_cast<uint32_t>(-1);
 727   hss[0] = kEmptyMojoHandleSignalsState;
 728   hss[1] = kEmptyMojoHandleSignalsState;
 729   EXPECT_EQ(MOJO_RESULT_OK,
 730             core()->WaitMany(MakeUserPointer(h),
 731                              MakeUserPointer(signals),
 732                              2,
 733                              MOJO_DEADLINE_INDEFINITE,
 734                              MakeUserPointer(&result_index),
 735                              MakeUserPointer(hss)));
 736   EXPECT_EQ(0u, result_index);
 737   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
 738             hss[0].satisfied_signals);
 739   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
 740             hss[0].satisfiable_signals);
 741   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[1].satisfied_signals);
 742   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
 743             hss[1].satisfiable_signals);
 744
 745   // Read from |h[0]|.
 746   // First, get only the size.
 747   buffer_size = 0;
 748   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
 749             core()->ReadMessage(h[0],
 750                                 NullUserPointer(),
 751                                 MakeUserPointer(&buffer_size),
 752                                 NullUserPointer(),
 753                                 NullUserPointer(),
 754                                 MOJO_READ_MESSAGE_FLAG_NONE));
 755   EXPECT_EQ(1u, buffer_size);
 756   // Then actually read it.
 757   buffer[0] = 'c';
 758   buffer_size = 1;
 759   EXPECT_EQ(MOJO_RESULT_OK,
 760             core()->ReadMessage(h[0],
 761                                 UserPointer<void>(buffer),
 762                                 MakeUserPointer(&buffer_size),
 763                                 NullUserPointer(),
 764                                 NullUserPointer(),
 765                                 MOJO_READ_MESSAGE_FLAG_NONE));
 766   EXPECT_EQ('b', buffer[0]);
 767   EXPECT_EQ(1u, buffer_size);
 768
 769   // |h[0]| should no longer be readable.
 770   hss[0] = kEmptyMojoHandleSignalsState;
 771   EXPECT_EQ(
 772       MOJO_RESULT_DEADLINE_EXCEEDED,
 773       core()->Wait(
 774           h[0], MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss[0])));
 775   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
 776   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
 777             hss[0].satisfiable_signals);
 778
 779   // Write to |h[0]|.
 780   buffer[0] = 'd';
 781   EXPECT_EQ(MOJO_RESULT_OK,
 782             core()->WriteMessage(h[0],
 783                                  UserPointer<const void>(buffer),
 784                                  1,
 785                                  NullUserPointer(),
 786                                  0,
 787                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 788
 789   // Close |h[0]|.
 790   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[0]));
 791
 792   // Check that |h[1]| is no longer writable (and will never be).
 793   hss[0] = kEmptyMojoHandleSignalsState;
 794   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 795             core()->Wait(h[1],
 796                          MOJO_HANDLE_SIGNAL_WRITABLE,
 797                          1000000000,
 798                          MakeUserPointer(&hss[0])));
 799   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss[0].satisfied_signals);
 800   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss[0].satisfiable_signals);
 801
 802   // Check that |h[1]| is still readable (for the moment).
 803   hss[0] = kEmptyMojoHandleSignalsState;
 804   EXPECT_EQ(MOJO_RESULT_OK,
 805             core()->Wait(h[1],
 806                          MOJO_HANDLE_SIGNAL_READABLE,
 807                          1000000000,
 808                          MakeUserPointer(&hss[0])));
 809   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss[0].satisfied_signals);
 810   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss[0].satisfiable_signals);
 811
 812   // Discard a message from |h[1]|.
 813   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
 814             core()->ReadMessage(h[1],
 815                                 NullUserPointer(),
 816                                 NullUserPointer(),
 817                                 NullUserPointer(),
 818                                 NullUserPointer(),
 819                                 MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
 820
 821   // |h[1]| is no longer readable (and will never be).
 822   hss[0] = kFullMojoHandleSignalsState;
 823   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 824             core()->Wait(h[1],
 825                          MOJO_HANDLE_SIGNAL_READABLE,
 826                          1000000000,
 827                          MakeUserPointer(&hss[0])));
 828   EXPECT_EQ(0u, hss[0].satisfied_signals);
 829   EXPECT_EQ(0u, hss[0].satisfiable_signals);
 830
 831   // Try writing to |h[1]|.
 832   buffer[0] = 'e';
 833   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 834             core()->WriteMessage(h[1],
 835                                  UserPointer<const void>(buffer),
 836                                  1,
 837                                  NullUserPointer(),
 838                                  0,
 839                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 840
 841   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[1]));
 842 }
 843
 844 // Tests passing a message pipe handle.
 845 TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) {
 846   const char kHello[] = "hello";
 847   const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
 848   const char kWorld[] = "world!!!";
 849   const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld));
 850   char buffer[100];
 851   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
 852   uint32_t num_bytes;
 853   MojoHandle handles[10];
 854   uint32_t num_handles;
 855   MojoHandleSignalsState hss;
 856   MojoHandle h_received;
 857
 858   MojoHandle h_passing[2];
 859   EXPECT_EQ(MOJO_RESULT_OK,
 860             core()->CreateMessagePipe(NullUserPointer(),
 861                                       MakeUserPointer(&h_passing[0]),
 862                                       MakeUserPointer(&h_passing[1])));
 863
 864   // Make sure that |h_passing[]| work properly.
 865   EXPECT_EQ(MOJO_RESULT_OK,
 866             core()->WriteMessage(h_passing[0],
 867                                  UserPointer<const void>(kHello),
 868                                  kHelloSize,
 869                                  NullUserPointer(),
 870                                  0,
 871                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 872   hss = kEmptyMojoHandleSignalsState;
 873   EXPECT_EQ(MOJO_RESULT_OK,
 874             core()->Wait(h_passing[1],
 875                          MOJO_HANDLE_SIGNAL_READABLE,
 876                          1000000000,
 877                          MakeUserPointer(&hss)));
 878   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
 879             hss.satisfied_signals);
 880   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
 881             hss.satisfiable_signals);
 882   num_bytes = kBufferSize;
 883   num_handles = arraysize(handles);
 884   EXPECT_EQ(MOJO_RESULT_OK,
 885             core()->ReadMessage(h_passing[1],
 886                                 UserPointer<void>(buffer),
 887                                 MakeUserPointer(&num_bytes),
 888                                 MakeUserPointer(handles),
 889                                 MakeUserPointer(&num_handles),
 890                                 MOJO_READ_MESSAGE_FLAG_NONE));
 891   EXPECT_EQ(kHelloSize, num_bytes);
 892   EXPECT_STREQ(kHello, buffer);
 893   EXPECT_EQ(0u, num_handles);
 894
 895   // Make sure that you can't pass either of the message pipe's handles over
 896   // itself.
 897   EXPECT_EQ(MOJO_RESULT_BUSY,
 898             core()->WriteMessage(h_passing[0],
 899                                  UserPointer<const void>(kHello),
 900                                  kHelloSize,
 901                                  MakeUserPointer(&h_passing[0]),
 902                                  1,
 903                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 904   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 905             core()->WriteMessage(h_passing[0],
 906                                  UserPointer<const void>(kHello),
 907                                  kHelloSize,
 908                                  MakeUserPointer(&h_passing[1]),
 909                                  1,
 910                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 911
 912   MojoHandle h_passed[2];
 913   EXPECT_EQ(MOJO_RESULT_OK,
 914             core()->CreateMessagePipe(NullUserPointer(),
 915                                       MakeUserPointer(&h_passed[0]),
 916                                       MakeUserPointer(&h_passed[1])));
 917
 918   // Make sure that |h_passed[]| work properly.
 919   EXPECT_EQ(MOJO_RESULT_OK,
 920             core()->WriteMessage(h_passed[0],
 921                                  UserPointer<const void>(kHello),
 922                                  kHelloSize,
 923                                  NullUserPointer(),
 924                                  0,
 925                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 926   hss = kEmptyMojoHandleSignalsState;
 927   EXPECT_EQ(MOJO_RESULT_OK,
 928             core()->Wait(h_passed[1],
 929                          MOJO_HANDLE_SIGNAL_READABLE,
 930                          1000000000,
 931                          MakeUserPointer(&hss)));
 932   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
 933             hss.satisfied_signals);
 934   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
 935             hss.satisfiable_signals);
 936   num_bytes = kBufferSize;
 937   num_handles = arraysize(handles);
 938   EXPECT_EQ(MOJO_RESULT_OK,
 939             core()->ReadMessage(h_passed[1],
 940                                 UserPointer<void>(buffer),
 941                                 MakeUserPointer(&num_bytes),
 942                                 MakeUserPointer(handles),
 943                                 MakeUserPointer(&num_handles),
 944                                 MOJO_READ_MESSAGE_FLAG_NONE));
 945   EXPECT_EQ(kHelloSize, num_bytes);
 946   EXPECT_STREQ(kHello, buffer);
 947   EXPECT_EQ(0u, num_handles);
 948
 949   // Send |h_passed[1]| from |h_passing[0]| to |h_passing[1]|.
 950   EXPECT_EQ(MOJO_RESULT_OK,
 951             core()->WriteMessage(h_passing[0],
 952                                  UserPointer<const void>(kWorld),
 953                                  kWorldSize,
 954                                  MakeUserPointer(&h_passed[1]),
 955                                  1,
 956                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 957   hss = kEmptyMojoHandleSignalsState;
 958   EXPECT_EQ(MOJO_RESULT_OK,
 959             core()->Wait(h_passing[1],
 960                          MOJO_HANDLE_SIGNAL_READABLE,
 961                          1000000000,
 962                          MakeUserPointer(&hss)));
 963   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
 964             hss.satisfied_signals);
 965   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
 966             hss.satisfiable_signals);
 967   num_bytes = kBufferSize;
 968   num_handles = arraysize(handles);
 969   EXPECT_EQ(MOJO_RESULT_OK,
 970             core()->ReadMessage(h_passing[1],
 971                                 UserPointer<void>(buffer),
 972                                 MakeUserPointer(&num_bytes),
 973                                 MakeUserPointer(handles),
 974                                 MakeUserPointer(&num_handles),
 975                                 MOJO_READ_MESSAGE_FLAG_NONE));
 976   EXPECT_EQ(kWorldSize, num_bytes);
 977   EXPECT_STREQ(kWorld, buffer);
 978   EXPECT_EQ(1u, num_handles);
 979   h_received = handles[0];
 980   EXPECT_NE(h_received, MOJO_HANDLE_INVALID);
 981   EXPECT_NE(h_received, h_passing[0]);
 982   EXPECT_NE(h_received, h_passing[1]);
 983   EXPECT_NE(h_received, h_passed[0]);
 984
 985   // Note: We rely on the Mojo system not re-using handle values very often.
 986   EXPECT_NE(h_received, h_passed[1]);
 987
 988   // |h_passed[1]| should no longer be valid; check that trying to close it
 989   // fails. See above note.
 990   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(h_passed[1]));
 991
 992   // Write to |h_passed[0]|. Should receive on |h_received|.
 993   EXPECT_EQ(MOJO_RESULT_OK,
 994             core()->WriteMessage(h_passed[0],
 995                                  UserPointer<const void>(kHello),
 996                                  kHelloSize,
 997                                  NullUserPointer(),
 998                                  0,
 999                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
1000   hss = kEmptyMojoHandleSignalsState;
1001   EXPECT_EQ(MOJO_RESULT_OK,
1002             core()->Wait(h_received,
1003                          MOJO_HANDLE_SIGNAL_READABLE,
1004                          1000000000,
1005                          MakeUserPointer(&hss)));
1006   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
1007             hss.satisfied_signals);
1008   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
1009             hss.satisfiable_signals);
1010   num_bytes = kBufferSize;
1011   num_handles = arraysize(handles);
1012   EXPECT_EQ(MOJO_RESULT_OK,
1013             core()->ReadMessage(h_received,
1014                                 UserPointer<void>(buffer),
1015                                 MakeUserPointer(&num_bytes),
1016                                 MakeUserPointer(handles),
1017                                 MakeUserPointer(&num_handles),
1018                                 MOJO_READ_MESSAGE_FLAG_NONE));
1019   EXPECT_EQ(kHelloSize, num_bytes);
1020   EXPECT_STREQ(kHello, buffer);
1021   EXPECT_EQ(0u, num_handles);
1022
1023   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[0]));
1024   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[1]));
1025   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passed[0]));
1026   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_received));
1027 }
1028
1029 TEST_F(CoreTest, DataPipe) {
1030   MojoHandle ph, ch;  // p is for producer and c is for consumer.
1031   MojoHandleSignalsState hss;
1032
1033   EXPECT_EQ(MOJO_RESULT_OK,
1034             core()->CreateDataPipe(
1035                 NullUserPointer(), MakeUserPointer(&ph), MakeUserPointer(&ch)));
1036   // Should get two distinct, valid handles.
1037   EXPECT_NE(ph, MOJO_HANDLE_INVALID);
1038   EXPECT_NE(ch, MOJO_HANDLE_INVALID);
1039   EXPECT_NE(ph, ch);
1040
1041   // Producer should be never-readable, but already writable.
1042   hss = kEmptyMojoHandleSignalsState;
1043   EXPECT_EQ(
1044       MOJO_RESULT_FAILED_PRECONDITION,
1045       core()->Wait(ph, MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss)));
1046   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
1047   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
1048   hss = kEmptyMojoHandleSignalsState;
1049   EXPECT_EQ(
1050       MOJO_RESULT_OK,
1051       core()->Wait(ph, MOJO_HANDLE_SIGNAL_WRITABLE, 0, MakeUserPointer(&hss)));
1052   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
1053   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
1054
1055   // Consumer should be never-writable, and not yet readable.
1056   hss = kFullMojoHandleSignalsState;
1057   EXPECT_EQ(
1058       MOJO_RESULT_FAILED_PRECONDITION,
1059       core()->Wait(ch, MOJO_HANDLE_SIGNAL_WRITABLE, 0, MakeUserPointer(&hss)));
1060   EXPECT_EQ(0u, hss.satisfied_signals);
1061   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
1062   hss = kFullMojoHandleSignalsState;
1063   EXPECT_EQ(
1064       MOJO_RESULT_DEADLINE_EXCEEDED,
1065       core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss)));
1066   EXPECT_EQ(0u, hss.satisfied_signals);
1067   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
1068
1069   // Write.
1070   char elements[2] = {'A', 'B'};
1071   uint32_t num_bytes = 2u;
1072   EXPECT_EQ(MOJO_RESULT_OK,
1073             core()->WriteData(ph,
1074                               UserPointer<const void>(elements),
1075                               MakeUserPointer(&num_bytes),
1076                               MOJO_WRITE_DATA_FLAG_NONE));
1077   EXPECT_EQ(2u, num_bytes);
1078
1079   // Consumer should now be readable.
1080   hss = kEmptyMojoHandleSignalsState;
1081   EXPECT_EQ(
1082       MOJO_RESULT_OK,
1083       core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss)));
1084   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
1085   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
1086
1087   // Read one character.
1088   elements[0] = -1;
1089   elements[1] = -1;
1090   num_bytes = 1u;
1091   EXPECT_EQ(MOJO_RESULT_OK,
1092             core()->ReadData(ch,
1093                              UserPointer<void>(elements),
1094                              MakeUserPointer(&num_bytes),
1095                              MOJO_READ_DATA_FLAG_NONE));
1096   EXPECT_EQ('A', elements[0]);
1097   EXPECT_EQ(-1, elements[1]);
1098
1099   // Two-phase write.
1100   void* write_ptr = NULL;
1101   num_bytes = 0u;
1102   ASSERT_EQ(MOJO_RESULT_OK,
1103             core()->BeginWriteData(ph,
1104                                    MakeUserPointer(&write_ptr),
1105                                    MakeUserPointer(&num_bytes),
1106                                    MOJO_WRITE_DATA_FLAG_NONE));
1107   // We count on the default options providing a decent buffer size.
1108   ASSERT_GE(num_bytes, 3u);
1109
1110   // Trying to do a normal write during a two-phase write should fail.
1111   elements[0] = 'X';
1112   num_bytes = 1u;
1113   EXPECT_EQ(MOJO_RESULT_BUSY,
1114             core()->WriteData(ph,
1115                               UserPointer<const void>(elements),
1116                               MakeUserPointer(&num_bytes),
1117                               MOJO_WRITE_DATA_FLAG_NONE));
1118
1119   // Actually write the data, and complete it now.
1120   static_cast<char*>(write_ptr)[0] = 'C';
1121   static_cast<char*>(write_ptr)[1] = 'D';
1122   static_cast<char*>(write_ptr)[2] = 'E';
1123   EXPECT_EQ(MOJO_RESULT_OK, core()->EndWriteData(ph, 3u));
1124
1125   // Query how much data we have.
1126   num_bytes = 0;
1127   EXPECT_EQ(MOJO_RESULT_OK,
1128             core()->ReadData(ch,
1129                              NullUserPointer(),
1130                              MakeUserPointer(&num_bytes),
1131                              MOJO_READ_DATA_FLAG_QUERY));
1132   EXPECT_EQ(4u, num_bytes);
1133
1134   // Try to discard ten characters, in all-or-none mode. Should fail.
1135   num_bytes = 10;
1136   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
1137             core()->ReadData(
1138                 ch,
1139                 NullUserPointer(),
1140                 MakeUserPointer(&num_bytes),
1141                 MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_ALL_OR_NONE));
1142
1143   // Discard two characters.
1144   num_bytes = 2;
1145   EXPECT_EQ(MOJO_RESULT_OK,
1146             core()->ReadData(
1147                 ch,
1148                 NullUserPointer(),
1149                 MakeUserPointer(&num_bytes),
1150                 MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_ALL_OR_NONE));
1151
1152   // Read the remaining two characters, in two-phase mode (all-or-none).
1153   const void* read_ptr = NULL;
1154   num_bytes = 2;
1155   ASSERT_EQ(MOJO_RESULT_OK,
1156             core()->BeginReadData(ch,
1157                                   MakeUserPointer(&read_ptr),
1158                                   MakeUserPointer(&num_bytes),
1159                                   MOJO_READ_DATA_FLAG_ALL_OR_NONE));
1160   // Note: Count on still being able to do the contiguous read here.
1161   ASSERT_EQ(2u, num_bytes);
1162
1163   // Discarding right now should fail.
1164   num_bytes = 1;
1165   EXPECT_EQ(MOJO_RESULT_BUSY,
1166             core()->ReadData(ch,
1167                              NullUserPointer(),
1168                              MakeUserPointer(&num_bytes),
1169                              MOJO_READ_DATA_FLAG_DISCARD));
1170
1171   // Actually check our data and end the two-phase read.
1172   EXPECT_EQ('D', static_cast<const char*>(read_ptr)[0]);
1173   EXPECT_EQ('E', static_cast<const char*>(read_ptr)[1]);
1174   EXPECT_EQ(MOJO_RESULT_OK, core()->EndReadData(ch, 2u));
1175
1176   // Consumer should now be no longer readable.
1177   hss = kFullMojoHandleSignalsState;
1178   EXPECT_EQ(
1179       MOJO_RESULT_DEADLINE_EXCEEDED,
1180       core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss)));
1181   EXPECT_EQ(0u, hss.satisfied_signals);
1182   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
1183
1184   // TODO(vtl): More.
1185
1186   // Close the producer.
1187   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ph));
1188
1189   // The consumer should now be never-readable.
1190   hss = kFullMojoHandleSignalsState;
1191   EXPECT_EQ(
1192       MOJO_RESULT_FAILED_PRECONDITION,
1193       core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss)));
1194   EXPECT_EQ(0u, hss.satisfied_signals);
1195   EXPECT_EQ(0u, hss.satisfiable_signals);
1196
1197   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ch));
1198 }
1199
1200 // Tests passing data pipe producer and consumer handles.
1201 TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) {
1202   const char kHello[] = "hello";
1203   const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
1204   const char kWorld[] = "world!!!";
1205   const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld));
1206   char buffer[100];
1207   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
1208   uint32_t num_bytes;
1209   MojoHandle handles[10];
1210   uint32_t num_handles;
1211   MojoHandleSignalsState hss;
1212
1213   MojoHandle h_passing[2];
1214   EXPECT_EQ(MOJO_RESULT_OK,
1215             core()->CreateMessagePipe(NullUserPointer(),
1216                                       MakeUserPointer(&h_passing[0]),
1217                                       MakeUserPointer(&h_passing[1])));
1218
1219   MojoHandle ph, ch;
1220   EXPECT_EQ(MOJO_RESULT_OK,
1221             core()->CreateDataPipe(
1222                 NullUserPointer(), MakeUserPointer(&ph), MakeUserPointer(&ch)));
1223
1224   // Send |ch| from |h_passing[0]| to |h_passing[1]|.
1225   EXPECT_EQ(MOJO_RESULT_OK,
1226             core()->WriteMessage(h_passing[0],
1227                                  UserPointer<const void>(kHello),
1228                                  kHelloSize,
1229                                  MakeUserPointer(&ch),
1230                                  1,
1231                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
1232   hss = kEmptyMojoHandleSignalsState;
1233   EXPECT_EQ(MOJO_RESULT_OK,
1234             core()->Wait(h_passing[1],
1235                          MOJO_HANDLE_SIGNAL_READABLE,
1236                          1000000000,
1237                          MakeUserPointer(&hss)));
1238   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
1239             hss.satisfied_signals);
1240   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
1241             hss.satisfiable_signals);
1242   num_bytes = kBufferSize;
1243   num_handles = arraysize(handles);
1244   EXPECT_EQ(MOJO_RESULT_OK,
1245             core()->ReadMessage(h_passing[1],
1246                                 UserPointer<void>(buffer),
1247                                 MakeUserPointer(&num_bytes),
1248                                 MakeUserPointer(handles),
1249                                 MakeUserPointer(&num_handles),
1250                                 MOJO_READ_MESSAGE_FLAG_NONE));
1251   EXPECT_EQ(kHelloSize, num_bytes);
1252   EXPECT_STREQ(kHello, buffer);
1253   EXPECT_EQ(1u, num_handles);
1254   MojoHandle ch_received = handles[0];
1255   EXPECT_NE(ch_received, MOJO_HANDLE_INVALID);
1256   EXPECT_NE(ch_received, h_passing[0]);
1257   EXPECT_NE(ch_received, h_passing[1]);
1258   EXPECT_NE(ch_received, ph);
1259
1260   // Note: We rely on the Mojo system not re-using handle values very often.
1261   EXPECT_NE(ch_received, ch);
1262
1263   // |ch| should no longer be valid; check that trying to close it fails. See
1264   // above note.
1265   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(ch));
1266
1267   // Write to |ph|. Should receive on |ch_received|.
1268   num_bytes = kWorldSize;
1269   EXPECT_EQ(MOJO_RESULT_OK,
1270             core()->WriteData(ph,
1271                               UserPointer<const void>(kWorld),
1272                               MakeUserPointer(&num_bytes),
1273                               MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
1274   hss = kEmptyMojoHandleSignalsState;
1275   EXPECT_EQ(MOJO_RESULT_OK,
1276             core()->Wait(ch_received,
1277                          MOJO_HANDLE_SIGNAL_READABLE,
1278                          1000000000,
1279                          MakeUserPointer(&hss)));
1280   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
1281   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
1282   num_bytes = kBufferSize;
1283   EXPECT_EQ(MOJO_RESULT_OK,
1284             core()->ReadData(ch_received,
1285                              UserPointer<void>(buffer),
1286                              MakeUserPointer(&num_bytes),
1287                              MOJO_READ_MESSAGE_FLAG_NONE));
1288   EXPECT_EQ(kWorldSize, num_bytes);
1289   EXPECT_STREQ(kWorld, buffer);
1290
1291   // Now pass |ph| in the same direction.
1292   EXPECT_EQ(MOJO_RESULT_OK,
1293             core()->WriteMessage(h_passing[0],
1294                                  UserPointer<const void>(kWorld),
1295                                  kWorldSize,
1296                                  MakeUserPointer(&ph),
1297                                  1,
1298                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
1299   hss = kEmptyMojoHandleSignalsState;
1300   EXPECT_EQ(MOJO_RESULT_OK,
1301             core()->Wait(h_passing[1],
1302                          MOJO_HANDLE_SIGNAL_READABLE,
1303                          1000000000,
1304                          MakeUserPointer(&hss)));
1305   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
1306             hss.satisfied_signals);
1307   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
1308             hss.satisfiable_signals);
1309   num_bytes = kBufferSize;
1310   num_handles = arraysize(handles);
1311   EXPECT_EQ(MOJO_RESULT_OK,
1312             core()->ReadMessage(h_passing[1],
1313                                 UserPointer<void>(buffer),
1314                                 MakeUserPointer(&num_bytes),
1315                                 MakeUserPointer(handles),
1316                                 MakeUserPointer(&num_handles),
1317                                 MOJO_READ_MESSAGE_FLAG_NONE));
1318   EXPECT_EQ(kWorldSize, num_bytes);
1319   EXPECT_STREQ(kWorld, buffer);
1320   EXPECT_EQ(1u, num_handles);
1321   MojoHandle ph_received = handles[0];
1322   EXPECT_NE(ph_received, MOJO_HANDLE_INVALID);
1323   EXPECT_NE(ph_received, h_passing[0]);
1324   EXPECT_NE(ph_received, h_passing[1]);
1325   EXPECT_NE(ph_received, ch_received);
1326
1327   // Again, rely on the Mojo system not re-using handle values very often.
1328   EXPECT_NE(ph_received, ph);
1329
1330   // |ph| should no longer be valid; check that trying to close it fails. See
1331   // above note.
1332   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(ph));
1333
1334   // Write to |ph_received|. Should receive on |ch_received|.
1335   num_bytes = kHelloSize;
1336   EXPECT_EQ(MOJO_RESULT_OK,
1337             core()->WriteData(ph_received,
1338                               UserPointer<const void>(kHello),
1339                               MakeUserPointer(&num_bytes),
1340                               MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
1341   hss = kEmptyMojoHandleSignalsState;
1342   EXPECT_EQ(MOJO_RESULT_OK,
1343             core()->Wait(ch_received,
1344                          MOJO_HANDLE_SIGNAL_READABLE,
1345                          1000000000,
1346                          MakeUserPointer(&hss)));
1347   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
1348   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
1349   num_bytes = kBufferSize;
1350   EXPECT_EQ(MOJO_RESULT_OK,
1351             core()->ReadData(ch_received,
1352                              UserPointer<void>(buffer),
1353                              MakeUserPointer(&num_bytes),
1354                              MOJO_READ_MESSAGE_FLAG_NONE));
1355   EXPECT_EQ(kHelloSize, num_bytes);
1356   EXPECT_STREQ(kHello, buffer);
1357
1358   ph = ph_received;
1359   ph_received = MOJO_HANDLE_INVALID;
1360   ch = ch_received;
1361   ch_received = MOJO_HANDLE_INVALID;
1362
1363   // Make sure that |ph| can't be sent if it's in a two-phase write.
1364   void* write_ptr = NULL;
1365   num_bytes = 0;
1366   ASSERT_EQ(MOJO_RESULT_OK,
1367             core()->BeginWriteData(ph,
1368                                    MakeUserPointer(&write_ptr),
1369                                    MakeUserPointer(&num_bytes),
1370                                    MOJO_WRITE_DATA_FLAG_NONE));
1371   ASSERT_GE(num_bytes, 1u);
1372   EXPECT_EQ(MOJO_RESULT_BUSY,
1373             core()->WriteMessage(h_passing[0],
1374                                  UserPointer<const void>(kHello),
1375                                  kHelloSize,
1376                                  MakeUserPointer(&ph),
1377                                  1,
1378                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
1379
1380   // But |ch| can, even if |ph| is in a two-phase write.
1381   EXPECT_EQ(MOJO_RESULT_OK,
1382             core()->WriteMessage(h_passing[0],
1383                                  UserPointer<const void>(kHello),
1384                                  kHelloSize,
1385                                  MakeUserPointer(&ch),
1386                                  1,
1387                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
1388   ch = MOJO_HANDLE_INVALID;
1389   EXPECT_EQ(MOJO_RESULT_OK,
1390             core()->Wait(h_passing[1],
1391                          MOJO_HANDLE_SIGNAL_READABLE,
1392                          1000000000,
1393                          NullUserPointer()));
1394   num_bytes = kBufferSize;
1395   num_handles = arraysize(handles);
1396   EXPECT_EQ(MOJO_RESULT_OK,
1397             core()->ReadMessage(h_passing[1],
1398                                 UserPointer<void>(buffer),
1399                                 MakeUserPointer(&num_bytes),
1400                                 MakeUserPointer(handles),
1401                                 MakeUserPointer(&num_handles),
1402                                 MOJO_READ_MESSAGE_FLAG_NONE));
1403   EXPECT_EQ(kHelloSize, num_bytes);
1404   EXPECT_STREQ(kHello, buffer);
1405   EXPECT_EQ(1u, num_handles);
1406   ch = handles[0];
1407   EXPECT_NE(ch, MOJO_HANDLE_INVALID);
1408
1409   // Complete the two-phase write.
1410   static_cast<char*>(write_ptr)[0] = 'x';
1411   EXPECT_EQ(MOJO_RESULT_OK, core()->EndWriteData(ph, 1));
1412
1413   // Wait for |ch| to be readable.
1414   hss = kEmptyMojoHandleSignalsState;
1415   EXPECT_EQ(
1416       MOJO_RESULT_OK,
1417       core()->Wait(
1418           ch, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, MakeUserPointer(&hss)));
1419   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
1420   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
1421
1422   // Make sure that |ch| can't be sent if it's in a two-phase read.
1423   const void* read_ptr = NULL;
1424   num_bytes = 1;
1425   ASSERT_EQ(MOJO_RESULT_OK,
1426             core()->BeginReadData(ch,
1427                                   MakeUserPointer(&read_ptr),
1428                                   MakeUserPointer(&num_bytes),
1429                                   MOJO_READ_DATA_FLAG_ALL_OR_NONE));
1430   EXPECT_EQ(MOJO_RESULT_BUSY,
1431             core()->WriteMessage(h_passing[0],
1432                                  UserPointer<const void>(kHello),
1433                                  kHelloSize,
1434                                  MakeUserPointer(&ch),
1435                                  1,
1436                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
1437
1438   // But |ph| can, even if |ch| is in a two-phase read.
1439   EXPECT_EQ(MOJO_RESULT_OK,
1440             core()->WriteMessage(h_passing[0],
1441                                  UserPointer<const void>(kWorld),
1442                                  kWorldSize,
1443                                  MakeUserPointer(&ph),
1444                                  1,
1445                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
1446   ph = MOJO_HANDLE_INVALID;
1447   hss = kEmptyMojoHandleSignalsState;
1448   EXPECT_EQ(MOJO_RESULT_OK,
1449             core()->Wait(h_passing[1],
1450                          MOJO_HANDLE_SIGNAL_READABLE,
1451                          1000000000,
1452                          MakeUserPointer(&hss)));
1453   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
1454             hss.satisfied_signals);
1455   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
1456             hss.satisfiable_signals);
1457   num_bytes = kBufferSize;
1458   num_handles = arraysize(handles);
1459   EXPECT_EQ(MOJO_RESULT_OK,
1460             core()->ReadMessage(h_passing[1],
1461                                 UserPointer<void>(buffer),
1462                                 MakeUserPointer(&num_bytes),
1463                                 MakeUserPointer(handles),
1464                                 MakeUserPointer(&num_handles),
1465                                 MOJO_READ_MESSAGE_FLAG_NONE));
1466   EXPECT_EQ(kWorldSize, num_bytes);
1467   EXPECT_STREQ(kWorld, buffer);
1468   EXPECT_EQ(1u, num_handles);
1469   ph = handles[0];
1470   EXPECT_NE(ph, MOJO_HANDLE_INVALID);
1471
1472   // Complete the two-phase read.
1473   EXPECT_EQ('x', static_cast<const char*>(read_ptr)[0]);
1474   EXPECT_EQ(MOJO_RESULT_OK, core()->EndReadData(ch, 1));
1475
1476   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[0]));
1477   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[1]));
1478   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ph));
1479   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ch));
1480 }
1481
1482 // TODO(vtl): Test |DuplicateBufferHandle()| and |MapBuffer()|.
1483
1484 }  // namespace
1485 }  // namespace system
1486 }  // namespace mojo