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 <limits>
   8
   9 #include "base/basictypes.h"
  10 #include "base/threading/platform_thread.h"
  11 #include "base/time/time.h"
  12 #include "mojo/system/core_test_base.h"
  13
  14 namespace mojo {
  15 namespace system {
  16 namespace {
  17
  18 typedef test::CoreTestBase CoreTest;
  19
  20 TEST_F(CoreTest, GetTimeTicksNow) {
  21   const MojoTimeTicks start = core()->GetTimeTicksNow();
  22   EXPECT_NE(static_cast<MojoTimeTicks>(0), start)
  23       << "GetTimeTicksNow should return nonzero value";
  24   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(15));
  25   const MojoTimeTicks finish = core()->GetTimeTicksNow();
  26   // Allow for some fuzz in sleep.
  27   EXPECT_GE((finish - start), static_cast<MojoTimeTicks>(8000))
  28       << "Sleeping should result in increasing time ticks";
  29 }
  30
  31 TEST_F(CoreTest, Basic) {
  32   MockHandleInfo info;
  33
  34   EXPECT_EQ(0u, info.GetCtorCallCount());
  35   MojoHandle h = CreateMockHandle(&info);
  36   EXPECT_EQ(1u, info.GetCtorCallCount());
  37   EXPECT_NE(h, MOJO_HANDLE_INVALID);
  38
  39   EXPECT_EQ(0u, info.GetWriteMessageCallCount());
  40   EXPECT_EQ(MOJO_RESULT_OK,
  41             core()->WriteMessage(h, NULL, 0, NULL, 0,
  42                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
  43   EXPECT_EQ(1u, info.GetWriteMessageCallCount());
  44   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  45             core()->WriteMessage(h, NULL, 1, NULL, 0,
  46                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
  47   EXPECT_EQ(2u, info.GetWriteMessageCallCount());
  48
  49   EXPECT_EQ(0u, info.GetReadMessageCallCount());
  50   uint32_t num_bytes = 0;
  51   EXPECT_EQ(MOJO_RESULT_OK,
  52             core()->ReadMessage(h, NULL, &num_bytes, NULL, NULL,
  53                                 MOJO_READ_MESSAGE_FLAG_NONE));
  54   EXPECT_EQ(1u, info.GetReadMessageCallCount());
  55   num_bytes = 1;
  56   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  57             core()->ReadMessage(h, NULL, &num_bytes, NULL, NULL,
  58                                 MOJO_READ_MESSAGE_FLAG_NONE));
  59   EXPECT_EQ(2u, info.GetReadMessageCallCount());
  60   EXPECT_EQ(MOJO_RESULT_OK,
  61             core()->ReadMessage(h, NULL, NULL, NULL, NULL,
  62                                 MOJO_READ_MESSAGE_FLAG_NONE));
  63   EXPECT_EQ(3u, info.GetReadMessageCallCount());
  64
  65   EXPECT_EQ(0u, info.GetWriteDataCallCount());
  66   EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
  67             core()->WriteData(h, NULL, NULL, MOJO_WRITE_DATA_FLAG_NONE));
  68   EXPECT_EQ(1u, info.GetWriteDataCallCount());
  69
  70   EXPECT_EQ(0u, info.GetBeginWriteDataCallCount());
  71   EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
  72             core()->BeginWriteData(h, NULL, NULL, MOJO_WRITE_DATA_FLAG_NONE));
  73   EXPECT_EQ(1u, info.GetBeginWriteDataCallCount());
  74
  75   EXPECT_EQ(0u, info.GetEndWriteDataCallCount());
  76   EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
  77             core()->EndWriteData(h, 0));
  78   EXPECT_EQ(1u, info.GetEndWriteDataCallCount());
  79
  80   EXPECT_EQ(0u, info.GetReadDataCallCount());
  81   EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
  82             core()->ReadData(h, NULL, NULL, MOJO_READ_DATA_FLAG_NONE));
  83   EXPECT_EQ(1u, info.GetReadDataCallCount());
  84
  85   EXPECT_EQ(0u, info.GetBeginReadDataCallCount());
  86   EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
  87             core()->BeginReadData(h, NULL, NULL, MOJO_READ_DATA_FLAG_NONE));
  88   EXPECT_EQ(1u, info.GetBeginReadDataCallCount());
  89
  90   EXPECT_EQ(0u, info.GetEndReadDataCallCount());
  91   EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
  92             core()->EndReadData(h, 0));
  93   EXPECT_EQ(1u, info.GetEndReadDataCallCount());
  94
  95   EXPECT_EQ(0u, info.GetAddWaiterCallCount());
  96   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
  97             core()->Wait(h, MOJO_WAIT_FLAG_EVERYTHING,
  98                          MOJO_DEADLINE_INDEFINITE));
  99   EXPECT_EQ(1u, info.GetAddWaiterCallCount());
 100   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 101             core()->Wait(h, MOJO_WAIT_FLAG_EVERYTHING, 0));
 102   EXPECT_EQ(2u, info.GetAddWaiterCallCount());
 103   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 104             core()->Wait(h, MOJO_WAIT_FLAG_EVERYTHING, 10 * 1000));
 105   EXPECT_EQ(3u, info.GetAddWaiterCallCount());
 106   MojoWaitFlags wait_flags = MOJO_WAIT_FLAG_EVERYTHING;
 107   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 108             core()->WaitMany(&h, &wait_flags, 1, MOJO_DEADLINE_INDEFINITE));
 109   EXPECT_EQ(4u, info.GetAddWaiterCallCount());
 110
 111   EXPECT_EQ(0u, info.GetDtorCallCount());
 112   EXPECT_EQ(0u, info.GetCloseCallCount());
 113   EXPECT_EQ(0u, info.GetCancelAllWaitersCallCount());
 114   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
 115   EXPECT_EQ(1u, info.GetCancelAllWaitersCallCount());
 116   EXPECT_EQ(1u, info.GetCloseCallCount());
 117   EXPECT_EQ(1u, info.GetDtorCallCount());
 118
 119   // No waiters should ever have ever been added.
 120   EXPECT_EQ(0u, info.GetRemoveWaiterCallCount());
 121 }
 122
 123 TEST_F(CoreTest, InvalidArguments) {
 124   // |Close()|:
 125   {
 126     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(MOJO_HANDLE_INVALID));
 127     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(10));
 128     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(1000000000));
 129
 130     // Test a double-close.
 131     MockHandleInfo info;
 132     MojoHandle h = CreateMockHandle(&info);
 133     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
 134     EXPECT_EQ(1u, info.GetCloseCallCount());
 135     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(h));
 136     EXPECT_EQ(1u, info.GetCloseCallCount());
 137   }
 138
 139   // |Wait()|:
 140   {
 141     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 142               core()->Wait(MOJO_HANDLE_INVALID, MOJO_WAIT_FLAG_EVERYTHING,
 143                            MOJO_DEADLINE_INDEFINITE));
 144     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 145               core()->Wait(10, MOJO_WAIT_FLAG_EVERYTHING,
 146                            MOJO_DEADLINE_INDEFINITE));
 147   }
 148
 149   // |WaitMany()|:
 150   {
 151     MojoHandle handles[2] = { MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID };
 152     MojoWaitFlags flags[2] = { MOJO_WAIT_FLAG_EVERYTHING,
 153                                MOJO_WAIT_FLAG_EVERYTHING };
 154     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 155               core()->WaitMany(handles, flags, 0, MOJO_DEADLINE_INDEFINITE));
 156     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 157               core()->WaitMany(NULL, flags, 0, MOJO_DEADLINE_INDEFINITE));
 158     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 159               core()->WaitMany(handles, NULL, 0, MOJO_DEADLINE_INDEFINITE));
 160
 161     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 162               core()->WaitMany(NULL, flags, 1, MOJO_DEADLINE_INDEFINITE));
 163     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 164               core()->WaitMany(handles, NULL, 1, MOJO_DEADLINE_INDEFINITE));
 165     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 166               core()->WaitMany(handles, flags, 1, MOJO_DEADLINE_INDEFINITE));
 167
 168     MockHandleInfo info[2];
 169     handles[0] = CreateMockHandle(&info[0]);
 170
 171     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 172               core()->WaitMany(handles, flags, 1, MOJO_DEADLINE_INDEFINITE));
 173     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 174               core()->WaitMany(handles, flags, 2, MOJO_DEADLINE_INDEFINITE));
 175     handles[1] = handles[0] + 1;  // Invalid handle.
 176     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 177               core()->WaitMany(handles, flags, 2, MOJO_DEADLINE_INDEFINITE));
 178     handles[1] = CreateMockHandle(&info[1]);
 179     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 180               core()->WaitMany(handles, flags, 2, MOJO_DEADLINE_INDEFINITE));
 181
 182     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(handles[0]));
 183     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(handles[1]));
 184   }
 185
 186   // |CreateMessagePipe()|:
 187   {
 188     MojoHandle h;
 189     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 190               core()->CreateMessagePipe(NULL, NULL));
 191     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 192               core()->CreateMessagePipe(&h, NULL));
 193     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 194               core()->CreateMessagePipe(NULL, &h));
 195   }
 196
 197   // |WriteMessage()|:
 198   // Only check arguments checked by |Core|, namely |handle|, |handles|, and
 199   // |num_handles|.
 200   {
 201     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 202               core()->WriteMessage(MOJO_HANDLE_INVALID, NULL, 0, NULL, 0,
 203                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 204
 205     MockHandleInfo info;
 206     MojoHandle h = CreateMockHandle(&info);
 207     MojoHandle handles[2] = { MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID };
 208
 209     // Null |handles| with nonzero |num_handles|.
 210     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 211               core()->WriteMessage(h, NULL, 0, NULL, 1,
 212                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 213     // Checked by |Core|, shouldn't go through to the dispatcher.
 214     EXPECT_EQ(0u, info.GetWriteMessageCallCount());
 215
 216     // Huge handle count (implausibly big on some systems -- more than can be
 217     // stored in a 32-bit address space).
 218     // Note: This may return either |MOJO_RESULT_INVALID_ARGUMENT| or
 219     // |MOJO_RESULT_RESOURCE_EXHAUSTED|, depending on whether it's plausible or
 220     // not.
 221     EXPECT_NE(MOJO_RESULT_OK,
 222               core()->WriteMessage(h, NULL, 0, handles,
 223                                    std::numeric_limits<uint32_t>::max(),
 224                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 225     EXPECT_EQ(0u, info.GetWriteMessageCallCount());
 226
 227     // Huge handle count (plausibly big).
 228     EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
 229               core()->WriteMessage(h, NULL, 0, handles,
 230                                    std::numeric_limits<uint32_t>::max() /
 231                                        sizeof(handles[0]),
 232                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 233     EXPECT_EQ(0u, info.GetWriteMessageCallCount());
 234
 235     // Invalid handle in |handles|.
 236     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 237               core()->WriteMessage(h, NULL, 0, handles, 1,
 238                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 239     EXPECT_EQ(0u, info.GetWriteMessageCallCount());
 240
 241     // Two invalid handles in |handles|.
 242     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 243               core()->WriteMessage(h, NULL, 0, handles, 2,
 244                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 245     EXPECT_EQ(0u, info.GetWriteMessageCallCount());
 246
 247     // Can't send a handle over itself.
 248     handles[0] = h;
 249     EXPECT_EQ(MOJO_RESULT_BUSY,
 250               core()->WriteMessage(h, NULL, 0, handles, 1,
 251                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 252     EXPECT_EQ(0u, info.GetWriteMessageCallCount());
 253
 254     MockHandleInfo info2;
 255     MojoHandle h2 = CreateMockHandle(&info2);
 256
 257     // This is "okay", but |MockDispatcher| doesn't implement it.
 258     handles[0] = h2;
 259     EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
 260               core()->WriteMessage(h, NULL, 0, handles, 1,
 261                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 262     EXPECT_EQ(1u, info.GetWriteMessageCallCount());
 263
 264     // One of the |handles| is still invalid.
 265     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 266               core()->WriteMessage(h, NULL, 0, handles, 2,
 267                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 268     EXPECT_EQ(1u, info.GetWriteMessageCallCount());
 269
 270     // One of the |handles| is the same as |handle|.
 271     handles[1] = h;
 272     EXPECT_EQ(MOJO_RESULT_BUSY,
 273               core()->WriteMessage(h, NULL, 0, handles, 2,
 274                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 275     EXPECT_EQ(1u, info.GetWriteMessageCallCount());
 276
 277     // Can't send a handle twice in the same message.
 278     handles[1] = h2;
 279     EXPECT_EQ(MOJO_RESULT_BUSY,
 280               core()->WriteMessage(h, NULL, 0, handles, 2,
 281                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 282     EXPECT_EQ(1u, info.GetWriteMessageCallCount());
 283
 284     // Note: Since we never successfully sent anything with it, |h2| should
 285     // still be valid.
 286     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h2));
 287
 288     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
 289   }
 290
 291   // |ReadMessage()|:
 292   // Only check arguments checked by |Core|, namely |handle|, |handles|, and
 293   // |num_handles|.
 294   {
 295     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 296               core()->ReadMessage(MOJO_HANDLE_INVALID, NULL, NULL, NULL, NULL,
 297                                   MOJO_READ_MESSAGE_FLAG_NONE));
 298
 299     MockHandleInfo info;
 300     MojoHandle h = CreateMockHandle(&info);
 301
 302     uint32_t handle_count = 1;
 303     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 304               core()->ReadMessage(h, NULL, NULL, NULL, &handle_count,
 305                                   MOJO_READ_MESSAGE_FLAG_NONE));
 306     // Checked by |Core|, shouldn't go through to the dispatcher.
 307     EXPECT_EQ(0u, info.GetReadMessageCallCount());
 308
 309     // Okay.
 310     handle_count = 0;
 311     EXPECT_EQ(MOJO_RESULT_OK,
 312               core()->ReadMessage(h, NULL, NULL, NULL, &handle_count,
 313                                   MOJO_READ_MESSAGE_FLAG_NONE));
 314     // Checked by |Core|, shouldn't go through to the dispatcher.
 315     EXPECT_EQ(1u, info.GetReadMessageCallCount());
 316
 317     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
 318   }
 319 }
 320
 321 // TODO(vtl): test |Wait()| and |WaitMany()| properly
 322 //  - including |WaitMany()| with the same handle more than once (with
 323 //    same/different flags)
 324
 325 TEST_F(CoreTest, MessagePipe) {
 326   MojoHandle h[2];
 327
 328   EXPECT_EQ(MOJO_RESULT_OK, core()->CreateMessagePipe(&h[0], &h[1]));
 329   // Should get two distinct, valid handles.
 330   EXPECT_NE(h[0], MOJO_HANDLE_INVALID);
 331   EXPECT_NE(h[1], MOJO_HANDLE_INVALID);
 332   EXPECT_NE(h[0], h[1]);
 333
 334   // Neither should be readable.
 335   MojoWaitFlags flags[2] = { MOJO_WAIT_FLAG_READABLE, MOJO_WAIT_FLAG_READABLE };
 336   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
 337             core()->WaitMany(h, flags, 2, 0));
 338
 339   // Try to read anyway.
 340   char buffer[1] = { 'a' };
 341   uint32_t buffer_size = 1;
 342   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
 343             core()->ReadMessage(h[0], buffer, &buffer_size, NULL, NULL,
 344                                 MOJO_READ_MESSAGE_FLAG_NONE));
 345   // Check that it left its inputs alone.
 346   EXPECT_EQ('a', buffer[0]);
 347   EXPECT_EQ(1u, buffer_size);
 348
 349   // Both should be writable.
 350   EXPECT_EQ(MOJO_RESULT_OK,
 351             core()->Wait(h[0], MOJO_WAIT_FLAG_WRITABLE, 1000000000));
 352   EXPECT_EQ(MOJO_RESULT_OK,
 353             core()->Wait(h[1], MOJO_WAIT_FLAG_WRITABLE, 1000000000));
 354
 355   // Also check that |h[1]| is writable using |WaitMany()|.
 356   flags[0] = MOJO_WAIT_FLAG_READABLE;
 357   flags[1] = MOJO_WAIT_FLAG_WRITABLE;
 358   EXPECT_EQ(1, core()->WaitMany(h, flags, 2, MOJO_DEADLINE_INDEFINITE));
 359
 360   // Write to |h[1]|.
 361   buffer[0] = 'b';
 362   EXPECT_EQ(MOJO_RESULT_OK,
 363             core()->WriteMessage(h[1], buffer, 1, NULL, 0,
 364                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 365
 366   // Check that |h[0]| is now readable.
 367   flags[0] = MOJO_WAIT_FLAG_READABLE;
 368   flags[1] = MOJO_WAIT_FLAG_READABLE;
 369   EXPECT_EQ(0, core()->WaitMany(h, flags, 2, MOJO_DEADLINE_INDEFINITE));
 370
 371   // Read from |h[0]|.
 372   // First, get only the size.
 373   buffer_size = 0;
 374   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
 375             core()->ReadMessage(h[0], NULL, &buffer_size, NULL, NULL,
 376                                 MOJO_READ_MESSAGE_FLAG_NONE));
 377   EXPECT_EQ(1u, buffer_size);
 378   // Then actually read it.
 379   buffer[0] = 'c';
 380   buffer_size = 1;
 381   EXPECT_EQ(MOJO_RESULT_OK,
 382             core()->ReadMessage(h[0], buffer, &buffer_size, NULL, NULL,
 383                                 MOJO_READ_MESSAGE_FLAG_NONE));
 384   EXPECT_EQ('b', buffer[0]);
 385   EXPECT_EQ(1u, buffer_size);
 386
 387   // |h[0]| should no longer be readable.
 388   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
 389             core()->Wait(h[0], MOJO_WAIT_FLAG_READABLE, 0));
 390
 391   // Write to |h[0]|.
 392   buffer[0] = 'd';
 393   EXPECT_EQ(MOJO_RESULT_OK,
 394             core()->WriteMessage(h[0], buffer, 1, NULL, 0,
 395                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 396
 397   // Close |h[0]|.
 398   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[0]));
 399
 400   // Check that |h[1]| is no longer writable (and will never be).
 401   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 402             core()->Wait(h[1], MOJO_WAIT_FLAG_WRITABLE, 1000000000));
 403
 404   // Check that |h[1]| is still readable (for the moment).
 405   EXPECT_EQ(MOJO_RESULT_OK,
 406             core()->Wait(h[1], MOJO_WAIT_FLAG_READABLE, 1000000000));
 407
 408   // Discard a message from |h[1]|.
 409   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
 410             core()->ReadMessage(h[1], NULL, NULL, NULL, NULL,
 411                                 MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
 412
 413   // |h[1]| is no longer readable (and will never be).
 414   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 415             core()->Wait(h[1], MOJO_WAIT_FLAG_READABLE, 1000000000));
 416
 417   // Try writing to |h[1]|.
 418   buffer[0] = 'e';
 419   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 420             core()->WriteMessage(h[1], buffer, 1, NULL, 0,
 421                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 422
 423   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[1]));
 424 }
 425
 426 // Tests passing a message pipe handle.
 427 TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) {
 428   const char kHello[] = "hello";
 429   const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
 430   const char kWorld[] = "world!!!";
 431   const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld));
 432   char buffer[100];
 433   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
 434   uint32_t num_bytes;
 435   MojoHandle handles[10];
 436   uint32_t num_handles;
 437   MojoHandle h_received;
 438
 439   MojoHandle h_passing[2];
 440   EXPECT_EQ(MOJO_RESULT_OK,
 441             core()->CreateMessagePipe(&h_passing[0], &h_passing[1]));
 442
 443   // Make sure that |h_passing[]| work properly.
 444   EXPECT_EQ(MOJO_RESULT_OK,
 445             core()->WriteMessage(h_passing[0],
 446                                  kHello, kHelloSize,
 447                                  NULL, 0,
 448                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 449   EXPECT_EQ(MOJO_RESULT_OK,
 450             core()->Wait(h_passing[1], MOJO_WAIT_FLAG_READABLE, 1000000000));
 451   num_bytes = kBufferSize;
 452   num_handles = arraysize(handles);
 453   EXPECT_EQ(MOJO_RESULT_OK,
 454             core()->ReadMessage(h_passing[1],
 455                                 buffer, &num_bytes,
 456                                 handles, &num_handles,
 457                                 MOJO_READ_MESSAGE_FLAG_NONE));
 458   EXPECT_EQ(kHelloSize, num_bytes);
 459   EXPECT_STREQ(kHello, buffer);
 460   EXPECT_EQ(0u, num_handles);
 461
 462   // Make sure that you can't pass either of the message pipe's handles over
 463   // itself.
 464   EXPECT_EQ(MOJO_RESULT_BUSY,
 465             core()->WriteMessage(h_passing[0],
 466                                  kHello, kHelloSize,
 467                                  &h_passing[0], 1,
 468                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 469   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 470             core()->WriteMessage(h_passing[0],
 471                                  kHello, kHelloSize,
 472                                  &h_passing[1], 1,
 473                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 474
 475   MojoHandle h_passed[2];
 476   EXPECT_EQ(MOJO_RESULT_OK,
 477             core()->CreateMessagePipe(&h_passed[0], &h_passed[1]));
 478
 479   // Make sure that |h_passed[]| work properly.
 480   EXPECT_EQ(MOJO_RESULT_OK,
 481             core()->WriteMessage(h_passed[0],
 482                                  kHello, kHelloSize,
 483                                  NULL, 0,
 484                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 485   EXPECT_EQ(MOJO_RESULT_OK,
 486             core()->Wait(h_passed[1], MOJO_WAIT_FLAG_READABLE, 1000000000));
 487   num_bytes = kBufferSize;
 488   num_handles = arraysize(handles);
 489   EXPECT_EQ(MOJO_RESULT_OK,
 490             core()->ReadMessage(h_passed[1],
 491                                 buffer, &num_bytes,
 492                                 handles, &num_handles,
 493                                 MOJO_READ_MESSAGE_FLAG_NONE));
 494   EXPECT_EQ(kHelloSize, num_bytes);
 495   EXPECT_STREQ(kHello, buffer);
 496   EXPECT_EQ(0u, num_handles);
 497
 498   // Send |h_passed[1]| from |h_passing[0]| to |h_passing[1]|.
 499   EXPECT_EQ(MOJO_RESULT_OK,
 500             core()->WriteMessage(h_passing[0],
 501                                  kWorld, kWorldSize,
 502                                  &h_passed[1], 1,
 503                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 504   EXPECT_EQ(MOJO_RESULT_OK,
 505             core()->Wait(h_passing[1], MOJO_WAIT_FLAG_READABLE, 1000000000));
 506   num_bytes = kBufferSize;
 507   num_handles = arraysize(handles);
 508   EXPECT_EQ(MOJO_RESULT_OK,
 509             core()->ReadMessage(h_passing[1],
 510                                 buffer, &num_bytes,
 511                                 handles, &num_handles,
 512                                 MOJO_READ_MESSAGE_FLAG_NONE));
 513   EXPECT_EQ(kWorldSize, num_bytes);
 514   EXPECT_STREQ(kWorld, buffer);
 515   EXPECT_EQ(1u, num_handles);
 516   h_received = handles[0];
 517   EXPECT_NE(h_received, MOJO_HANDLE_INVALID);
 518   EXPECT_NE(h_received, h_passing[0]);
 519   EXPECT_NE(h_received, h_passing[1]);
 520   EXPECT_NE(h_received, h_passed[0]);
 521
 522   // Note: We rely on the Mojo system not re-using handle values very often.
 523   EXPECT_NE(h_received, h_passed[1]);
 524
 525   // |h_passed[1]| should no longer be valid; check that trying to close it
 526   // fails. See above note.
 527   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(h_passed[1]));
 528
 529   // Write to |h_passed[0]|. Should receive on |h_received|.
 530   EXPECT_EQ(MOJO_RESULT_OK,
 531             core()->WriteMessage(h_passed[0],
 532                                  kHello, kHelloSize,
 533                                  NULL, 0,
 534                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 535   EXPECT_EQ(MOJO_RESULT_OK,
 536             core()->Wait(h_received, MOJO_WAIT_FLAG_READABLE, 1000000000));
 537   num_bytes = kBufferSize;
 538   num_handles = arraysize(handles);
 539   EXPECT_EQ(MOJO_RESULT_OK,
 540             core()->ReadMessage(h_received,
 541                                 buffer, &num_bytes,
 542                                 handles, &num_handles,
 543                                 MOJO_READ_MESSAGE_FLAG_NONE));
 544   EXPECT_EQ(kHelloSize, num_bytes);
 545   EXPECT_STREQ(kHello, buffer);
 546   EXPECT_EQ(0u, num_handles);
 547
 548   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[0]));
 549   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[1]));
 550   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passed[0]));
 551   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_received));
 552 }
 553
 554 TEST_F(CoreTest, DataPipe) {
 555   MojoHandle ph, ch;  // p is for producer and c is for consumer.
 556
 557   EXPECT_EQ(MOJO_RESULT_OK, core()->CreateDataPipe(NULL, &ph, &ch));
 558   // Should get two distinct, valid handles.
 559   EXPECT_NE(ph, MOJO_HANDLE_INVALID);
 560   EXPECT_NE(ch, MOJO_HANDLE_INVALID);
 561   EXPECT_NE(ph, ch);
 562
 563   // Producer should be never-readable, but already writable.
 564   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 565             core()->Wait(ph, MOJO_WAIT_FLAG_READABLE, 0));
 566   EXPECT_EQ(MOJO_RESULT_OK,
 567             core()->Wait(ph, MOJO_WAIT_FLAG_WRITABLE, 0));
 568
 569   // Consumer should be never-writable, and not yet readable.
 570   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 571             core()->Wait(ch, MOJO_WAIT_FLAG_WRITABLE, 0));
 572   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
 573             core()->Wait(ch, MOJO_WAIT_FLAG_READABLE, 0));
 574
 575   // Write.
 576   char elements[2] = { 'A', 'B' };
 577   uint32_t num_bytes = 2u;
 578   EXPECT_EQ(MOJO_RESULT_OK,
 579             core()->WriteData(ph, elements, &num_bytes,
 580                               MOJO_WRITE_DATA_FLAG_NONE));
 581   EXPECT_EQ(2u, num_bytes);
 582
 583   // Consumer should now be readable.
 584   EXPECT_EQ(MOJO_RESULT_OK,
 585             core()->Wait(ch, MOJO_WAIT_FLAG_READABLE, 0));
 586
 587   // Read one character.
 588   elements[0] = -1;
 589   elements[1] = -1;
 590   num_bytes = 1u;
 591   EXPECT_EQ(MOJO_RESULT_OK,
 592             core()->ReadData(ch, elements, &num_bytes,
 593                              MOJO_READ_DATA_FLAG_NONE));
 594   EXPECT_EQ('A', elements[0]);
 595   EXPECT_EQ(-1, elements[1]);
 596
 597   // Two-phase write.
 598   void* write_ptr = NULL;
 599   num_bytes = 0u;
 600   ASSERT_EQ(MOJO_RESULT_OK,
 601             core()->BeginWriteData(ph, &write_ptr, &num_bytes,
 602                                    MOJO_WRITE_DATA_FLAG_NONE));
 603   // We count on the default options providing a decent buffer size.
 604   ASSERT_GE(num_bytes, 3u);
 605
 606   // Trying to do a normal write during a two-phase write should fail.
 607   elements[0] = 'X';
 608   num_bytes = 1u;
 609   EXPECT_EQ(MOJO_RESULT_BUSY,
 610             core()->WriteData(ph, elements, &num_bytes,
 611                               MOJO_WRITE_DATA_FLAG_NONE));
 612
 613   // Actually write the data, and complete it now.
 614   static_cast<char*>(write_ptr)[0] = 'C';
 615   static_cast<char*>(write_ptr)[1] = 'D';
 616   static_cast<char*>(write_ptr)[2] = 'E';
 617   EXPECT_EQ(MOJO_RESULT_OK, core()->EndWriteData(ph, 3u));
 618
 619   // Query how much data we have.
 620   num_bytes = 0;
 621   EXPECT_EQ(MOJO_RESULT_OK,
 622             core()->ReadData(ch, NULL, &num_bytes, MOJO_READ_DATA_FLAG_QUERY));
 623   EXPECT_EQ(4u, num_bytes);
 624
 625   // Try to discard ten characters, in all-or-none mode. Should fail.
 626   num_bytes = 10;
 627   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
 628             core()->ReadData(ch, NULL, &num_bytes,
 629                              MOJO_READ_DATA_FLAG_DISCARD |
 630                                  MOJO_READ_DATA_FLAG_ALL_OR_NONE));
 631
 632   // Discard two characters.
 633   num_bytes = 2;
 634   EXPECT_EQ(MOJO_RESULT_OK,
 635             core()->ReadData(ch, NULL, &num_bytes,
 636                              MOJO_READ_DATA_FLAG_DISCARD |
 637                                  MOJO_READ_DATA_FLAG_ALL_OR_NONE));
 638
 639   // Read the remaining two characters, in two-phase mode (all-or-none).
 640   const void* read_ptr = NULL;
 641   num_bytes = 2;
 642   ASSERT_EQ(MOJO_RESULT_OK,
 643             core()->BeginReadData(ch, &read_ptr, &num_bytes,
 644                                   MOJO_READ_DATA_FLAG_ALL_OR_NONE));
 645   // Note: Count on still being able to do the contiguous read here.
 646   ASSERT_EQ(2u, num_bytes);
 647
 648   // Discarding right now should fail.
 649   num_bytes = 1;
 650   EXPECT_EQ(MOJO_RESULT_BUSY,
 651             core()->ReadData(ch, NULL, &num_bytes,
 652                              MOJO_READ_DATA_FLAG_DISCARD));
 653
 654   // Actually check our data and end the two-phase read.
 655   EXPECT_EQ('D', static_cast<const char*>(read_ptr)[0]);
 656   EXPECT_EQ('E', static_cast<const char*>(read_ptr)[1]);
 657   EXPECT_EQ(MOJO_RESULT_OK, core()->EndReadData(ch, 2u));
 658
 659   // Consumer should now be no longer readable.
 660   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
 661             core()->Wait(ch, MOJO_WAIT_FLAG_READABLE, 0));
 662
 663   // TODO(vtl): More.
 664
 665   // Close the producer.
 666   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ph));
 667
 668   // The consumer should now be never-readable.
 669   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 670             core()->Wait(ch, MOJO_WAIT_FLAG_READABLE, 0));
 671
 672   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ch));
 673 }
 674
 675 // Tests passing data pipe producer and consumer handles.
 676 TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) {
 677   const char kHello[] = "hello";
 678   const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
 679   const char kWorld[] = "world!!!";
 680   const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld));
 681   char buffer[100];
 682   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
 683   uint32_t num_bytes;
 684   MojoHandle handles[10];
 685   uint32_t num_handles;
 686
 687   MojoHandle h_passing[2];
 688   EXPECT_EQ(MOJO_RESULT_OK,
 689             core()->CreateMessagePipe(&h_passing[0], &h_passing[1]));
 690
 691   MojoHandle ph, ch;
 692   EXPECT_EQ(MOJO_RESULT_OK,
 693             core()->CreateDataPipe(NULL, &ph, &ch));
 694
 695   // Send |ch| from |h_passing[0]| to |h_passing[1]|.
 696   EXPECT_EQ(MOJO_RESULT_OK,
 697             core()->WriteMessage(h_passing[0],
 698                                  kHello, kHelloSize,
 699                                  &ch, 1,
 700                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 701   EXPECT_EQ(MOJO_RESULT_OK,
 702             core()->Wait(h_passing[1], MOJO_WAIT_FLAG_READABLE, 1000000000));
 703   num_bytes = kBufferSize;
 704   num_handles = arraysize(handles);
 705   EXPECT_EQ(MOJO_RESULT_OK,
 706             core()->ReadMessage(h_passing[1],
 707                                 buffer, &num_bytes,
 708                                 handles, &num_handles,
 709                                 MOJO_READ_MESSAGE_FLAG_NONE));
 710   EXPECT_EQ(kHelloSize, num_bytes);
 711   EXPECT_STREQ(kHello, buffer);
 712   EXPECT_EQ(1u, num_handles);
 713   MojoHandle ch_received = handles[0];
 714   EXPECT_NE(ch_received, MOJO_HANDLE_INVALID);
 715   EXPECT_NE(ch_received, h_passing[0]);
 716   EXPECT_NE(ch_received, h_passing[1]);
 717   EXPECT_NE(ch_received, ph);
 718
 719   // Note: We rely on the Mojo system not re-using handle values very often.
 720   EXPECT_NE(ch_received, ch);
 721
 722   // |ch| should no longer be valid; check that trying to close it fails. See
 723   // above note.
 724   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(ch));
 725
 726   // Write to |ph|. Should receive on |ch_received|.
 727   num_bytes = kWorldSize;
 728   EXPECT_EQ(MOJO_RESULT_OK,
 729             core()->WriteData(ph, kWorld, &num_bytes,
 730                               MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
 731   EXPECT_EQ(MOJO_RESULT_OK,
 732             core()->Wait(ch_received, MOJO_WAIT_FLAG_READABLE, 1000000000));
 733   num_bytes = kBufferSize;
 734   EXPECT_EQ(MOJO_RESULT_OK,
 735             core()->ReadData(ch_received, buffer, &num_bytes,
 736                              MOJO_READ_MESSAGE_FLAG_NONE));
 737   EXPECT_EQ(kWorldSize, num_bytes);
 738   EXPECT_STREQ(kWorld, buffer);
 739
 740   // Now pass |ph| in the same direction.
 741   EXPECT_EQ(MOJO_RESULT_OK,
 742             core()->WriteMessage(h_passing[0],
 743                                  kWorld, kWorldSize,
 744                                  &ph, 1,
 745                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 746   EXPECT_EQ(MOJO_RESULT_OK,
 747             core()->Wait(h_passing[1], MOJO_WAIT_FLAG_READABLE, 1000000000));
 748   num_bytes = kBufferSize;
 749   num_handles = arraysize(handles);
 750   EXPECT_EQ(MOJO_RESULT_OK,
 751             core()->ReadMessage(h_passing[1],
 752                                 buffer, &num_bytes,
 753                                 handles, &num_handles,
 754                                 MOJO_READ_MESSAGE_FLAG_NONE));
 755   EXPECT_EQ(kWorldSize, num_bytes);
 756   EXPECT_STREQ(kWorld, buffer);
 757   EXPECT_EQ(1u, num_handles);
 758   MojoHandle ph_received = handles[0];
 759   EXPECT_NE(ph_received, MOJO_HANDLE_INVALID);
 760   EXPECT_NE(ph_received, h_passing[0]);
 761   EXPECT_NE(ph_received, h_passing[1]);
 762   EXPECT_NE(ph_received, ch_received);
 763
 764   // Again, rely on the Mojo system not re-using handle values very often.
 765   EXPECT_NE(ph_received, ph);
 766
 767   // |ph| should no longer be valid; check that trying to close it fails. See
 768   // above note.
 769   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(ph));
 770
 771   // Write to |ph_received|. Should receive on |ch_received|.
 772   num_bytes = kHelloSize;
 773   EXPECT_EQ(MOJO_RESULT_OK,
 774             core()->WriteData(ph_received, kHello, &num_bytes,
 775                               MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
 776   EXPECT_EQ(MOJO_RESULT_OK,
 777             core()->Wait(ch_received, MOJO_WAIT_FLAG_READABLE, 1000000000));
 778   num_bytes = kBufferSize;
 779   EXPECT_EQ(MOJO_RESULT_OK,
 780             core()->ReadData(ch_received, buffer, &num_bytes,
 781                              MOJO_READ_MESSAGE_FLAG_NONE));
 782   EXPECT_EQ(kHelloSize, num_bytes);
 783   EXPECT_STREQ(kHello, buffer);
 784
 785   ph = ph_received;
 786   ph_received = MOJO_HANDLE_INVALID;
 787   ch = ch_received;
 788   ch_received = MOJO_HANDLE_INVALID;
 789
 790   // Make sure that |ph| can't be sent if it's in a two-phase write.
 791   void* write_ptr = NULL;
 792   num_bytes = 0;
 793   ASSERT_EQ(MOJO_RESULT_OK,
 794             core()->BeginWriteData(ph, &write_ptr, &num_bytes,
 795                                    MOJO_WRITE_DATA_FLAG_NONE));
 796   ASSERT_GE(num_bytes, 1u);
 797   EXPECT_EQ(MOJO_RESULT_BUSY,
 798             core()->WriteMessage(h_passing[0],
 799                                  kHello, kHelloSize,
 800                                  &ph, 1,
 801                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 802
 803   // But |ch| can, even if |ph| is in a two-phase write.
 804   EXPECT_EQ(MOJO_RESULT_OK,
 805             core()->WriteMessage(h_passing[0],
 806                                  kHello, kHelloSize,
 807                                  &ch, 1,
 808                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 809   ch = MOJO_HANDLE_INVALID;
 810   EXPECT_EQ(MOJO_RESULT_OK,
 811             core()->Wait(h_passing[1], MOJO_WAIT_FLAG_READABLE, 1000000000));
 812   num_bytes = kBufferSize;
 813   num_handles = arraysize(handles);
 814   EXPECT_EQ(MOJO_RESULT_OK,
 815             core()->ReadMessage(h_passing[1],
 816                                 buffer, &num_bytes,
 817                                 handles, &num_handles,
 818                                 MOJO_READ_MESSAGE_FLAG_NONE));
 819   EXPECT_EQ(kHelloSize, num_bytes);
 820   EXPECT_STREQ(kHello, buffer);
 821   EXPECT_EQ(1u, num_handles);
 822   ch = handles[0];
 823   EXPECT_NE(ch, MOJO_HANDLE_INVALID);
 824
 825   // Complete the two-phase write.
 826   static_cast<char*>(write_ptr)[0] = 'x';
 827   EXPECT_EQ(MOJO_RESULT_OK, core()->EndWriteData(ph, 1));
 828
 829   // Wait for |ch| to be readable.
 830   EXPECT_EQ(MOJO_RESULT_OK,
 831             core()->Wait(ch, MOJO_WAIT_FLAG_READABLE, 1000000000));
 832
 833   // Make sure that |ch| can't be sent if it's in a two-phase read.
 834   const void* read_ptr = NULL;
 835   num_bytes = 1;
 836   ASSERT_EQ(MOJO_RESULT_OK,
 837             core()->BeginReadData(ch, &read_ptr, &num_bytes,
 838                                   MOJO_READ_DATA_FLAG_ALL_OR_NONE));
 839   EXPECT_EQ(MOJO_RESULT_BUSY,
 840             core()->WriteMessage(h_passing[0],
 841                                  kHello, kHelloSize,
 842                                  &ch, 1,
 843                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 844
 845   // But |ph| can, even if |ch| is in a two-phase read.
 846   EXPECT_EQ(MOJO_RESULT_OK,
 847             core()->WriteMessage(h_passing[0],
 848                                  kWorld, kWorldSize,
 849                                  &ph, 1,
 850                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 851   ph = MOJO_HANDLE_INVALID;
 852   EXPECT_EQ(MOJO_RESULT_OK,
 853             core()->Wait(h_passing[1], MOJO_WAIT_FLAG_READABLE, 1000000000));
 854   num_bytes = kBufferSize;
 855   num_handles = arraysize(handles);
 856   EXPECT_EQ(MOJO_RESULT_OK,
 857             core()->ReadMessage(h_passing[1],
 858                                 buffer, &num_bytes,
 859                                 handles, &num_handles,
 860                                 MOJO_READ_MESSAGE_FLAG_NONE));
 861   EXPECT_EQ(kWorldSize, num_bytes);
 862   EXPECT_STREQ(kWorld, buffer);
 863   EXPECT_EQ(1u, num_handles);
 864   ph = handles[0];
 865   EXPECT_NE(ph, MOJO_HANDLE_INVALID);
 866
 867   // Complete the two-phase read.
 868   EXPECT_EQ('x', static_cast<const char*>(read_ptr)[0]);
 869   EXPECT_EQ(MOJO_RESULT_OK, core()->EndReadData(ch, 1));
 870
 871   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[0]));
 872   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[1]));
 873   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ph));
 874   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ch));
 875 }
 876
 877 // TODO(vtl): Test |DuplicateBufferHandle()| and |MapBuffer()|.
 878
 879 }  // namespace
 880 }  // namespace system
 881 }  // namespace mojo