src/mojo/system/local_data_pipe_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "mojo/system/local_data_pipe.h"
   6
   7 #include <string.h>
   8
   9 #include "base/macros.h"
  10 #include "base/memory/ref_counted.h"
  11 #include "mojo/system/data_pipe.h"
  12 #include "mojo/system/waiter.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace mojo {
  16 namespace system {
  17 namespace {
  18
  19 const uint32_t kSizeOfOptions =
  20     static_cast<uint32_t>(sizeof(MojoCreateDataPipeOptions));
  21
  22 // Validate options.
  23 TEST(LocalDataPipeTest, Creation) {
  24   // Create using default options.
  25   {
  26     // Get default options.
  27     MojoCreateDataPipeOptions default_options = {0};
  28     EXPECT_EQ(
  29         MOJO_RESULT_OK,
  30         DataPipe::ValidateCreateOptions(NullUserPointer(), &default_options));
  31     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(default_options));
  32     dp->ProducerClose();
  33     dp->ConsumerClose();
  34   }
  35
  36   // Create using non-default options.
  37   {
  38     const MojoCreateDataPipeOptions options = {
  39         kSizeOfOptions,                           // |struct_size|.
  40         MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
  41         1,                                        // |element_num_bytes|.
  42         1000                                      // |capacity_num_bytes|.
  43     };
  44     MojoCreateDataPipeOptions validated_options = {0};
  45     EXPECT_EQ(MOJO_RESULT_OK,
  46               DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
  47                                               &validated_options));
  48     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
  49     dp->ProducerClose();
  50     dp->ConsumerClose();
  51   }
  52   {
  53     const MojoCreateDataPipeOptions options = {
  54         kSizeOfOptions,                           // |struct_size|.
  55         MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
  56         4,                                        // |element_num_bytes|.
  57         4000                                      // |capacity_num_bytes|.
  58     };
  59     MojoCreateDataPipeOptions validated_options = {0};
  60     EXPECT_EQ(MOJO_RESULT_OK,
  61               DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
  62                                               &validated_options));
  63     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
  64     dp->ProducerClose();
  65     dp->ConsumerClose();
  66   }
  67   {
  68     const MojoCreateDataPipeOptions options = {
  69         kSizeOfOptions,                                  // |struct_size|.
  70         MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD,  // |flags|.
  71         7,                                               // |element_num_bytes|.
  72         7000000  // |capacity_num_bytes|.
  73     };
  74     MojoCreateDataPipeOptions validated_options = {0};
  75     EXPECT_EQ(MOJO_RESULT_OK,
  76               DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
  77                                               &validated_options));
  78     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
  79     dp->ProducerClose();
  80     dp->ConsumerClose();
  81   }
  82   // Default capacity.
  83   {
  84     const MojoCreateDataPipeOptions options = {
  85         kSizeOfOptions,                                  // |struct_size|.
  86         MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD,  // |flags|.
  87         100,                                             // |element_num_bytes|.
  88         0  // |capacity_num_bytes|.
  89     };
  90     MojoCreateDataPipeOptions validated_options = {0};
  91     EXPECT_EQ(MOJO_RESULT_OK,
  92               DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
  93                                               &validated_options));
  94     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
  95     dp->ProducerClose();
  96     dp->ConsumerClose();
  97   }
  98 }
  99
 100 TEST(LocalDataPipeTest, SimpleReadWrite) {
 101   const MojoCreateDataPipeOptions options = {
 102       kSizeOfOptions,                           // |struct_size|.
 103       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
 104       static_cast<uint32_t>(sizeof(int32_t)),   // |element_num_bytes|.
 105       1000 * sizeof(int32_t)                    // |capacity_num_bytes|.
 106   };
 107   MojoCreateDataPipeOptions validated_options = {0};
 108   EXPECT_EQ(MOJO_RESULT_OK,
 109             DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
 110                                             &validated_options));
 111
 112   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 113
 114   int32_t elements[10] = {0};
 115   uint32_t num_bytes = 0;
 116
 117   // Try reading; nothing there yet.
 118   num_bytes = static_cast<uint32_t>(arraysize(elements) * sizeof(elements[0]));
 119   EXPECT_EQ(
 120       MOJO_RESULT_SHOULD_WAIT,
 121       dp->ConsumerReadData(
 122           UserPointer<void>(elements), MakeUserPointer(&num_bytes), false));
 123
 124   // Query; nothing there yet.
 125   num_bytes = 0;
 126   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
 127   EXPECT_EQ(0u, num_bytes);
 128
 129   // Discard; nothing there yet.
 130   num_bytes = static_cast<uint32_t>(5u * sizeof(elements[0]));
 131   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
 132             dp->ConsumerDiscardData(MakeUserPointer(&num_bytes), false));
 133
 134   // Read with invalid |num_bytes|.
 135   num_bytes = sizeof(elements[0]) + 1;
 136   EXPECT_EQ(
 137       MOJO_RESULT_INVALID_ARGUMENT,
 138       dp->ConsumerReadData(
 139           UserPointer<void>(elements), MakeUserPointer(&num_bytes), false));
 140
 141   // Write two elements.
 142   elements[0] = 123;
 143   elements[1] = 456;
 144   num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
 145   EXPECT_EQ(MOJO_RESULT_OK,
 146             dp->ProducerWriteData(UserPointer<const void>(elements),
 147                                   MakeUserPointer(&num_bytes),
 148                                   false));
 149   // It should have written everything (even without "all or none").
 150   EXPECT_EQ(2u * sizeof(elements[0]), num_bytes);
 151
 152   // Query.
 153   num_bytes = 0;
 154   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
 155   EXPECT_EQ(2 * sizeof(elements[0]), num_bytes);
 156
 157   // Read one element.
 158   elements[0] = -1;
 159   elements[1] = -1;
 160   num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
 161   EXPECT_EQ(
 162       MOJO_RESULT_OK,
 163       dp->ConsumerReadData(
 164           UserPointer<void>(elements), MakeUserPointer(&num_bytes), false));
 165   EXPECT_EQ(1u * sizeof(elements[0]), num_bytes);
 166   EXPECT_EQ(123, elements[0]);
 167   EXPECT_EQ(-1, elements[1]);
 168
 169   // Query.
 170   num_bytes = 0;
 171   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
 172   EXPECT_EQ(1 * sizeof(elements[0]), num_bytes);
 173
 174   // Try to read two elements, with "all or none".
 175   elements[0] = -1;
 176   elements[1] = -1;
 177   num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
 178   EXPECT_EQ(
 179       MOJO_RESULT_OUT_OF_RANGE,
 180       dp->ConsumerReadData(
 181           UserPointer<void>(elements), MakeUserPointer(&num_bytes), true));
 182   EXPECT_EQ(-1, elements[0]);
 183   EXPECT_EQ(-1, elements[1]);
 184
 185   // Try to read two elements, without "all or none".
 186   elements[0] = -1;
 187   elements[1] = -1;
 188   num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
 189   EXPECT_EQ(
 190       MOJO_RESULT_OK,
 191       dp->ConsumerReadData(
 192           UserPointer<void>(elements), MakeUserPointer(&num_bytes), false));
 193   EXPECT_EQ(456, elements[0]);
 194   EXPECT_EQ(-1, elements[1]);
 195
 196   // Query.
 197   num_bytes = 0;
 198   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
 199   EXPECT_EQ(0u, num_bytes);
 200
 201   dp->ProducerClose();
 202   dp->ConsumerClose();
 203 }
 204
 205 // Note: The "basic" waiting tests test that the "wait states" are correct in
 206 // various situations; they don't test that waiters are properly awoken on state
 207 // changes. (For that, we need to use multiple threads.)
 208 TEST(LocalDataPipeTest, BasicProducerWaiting) {
 209   // Note: We take advantage of the fact that for |LocalDataPipe|, capacities
 210   // are strict maximums. This is not guaranteed by the API.
 211
 212   const MojoCreateDataPipeOptions options = {
 213       kSizeOfOptions,                           // |struct_size|.
 214       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
 215       static_cast<uint32_t>(sizeof(int32_t)),   // |element_num_bytes|.
 216       2 * sizeof(int32_t)                       // |capacity_num_bytes|.
 217   };
 218   MojoCreateDataPipeOptions validated_options = {0};
 219   EXPECT_EQ(MOJO_RESULT_OK,
 220             DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
 221                                             &validated_options));
 222
 223   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 224   Waiter waiter;
 225   uint32_t context = 0;
 226   HandleSignalsState hss;
 227
 228   // Never readable.
 229   waiter.Init();
 230   hss = HandleSignalsState();
 231   EXPECT_EQ(
 232       MOJO_RESULT_FAILED_PRECONDITION,
 233       dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12, &hss));
 234   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
 235   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
 236
 237   // Already writable.
 238   waiter.Init();
 239   hss = HandleSignalsState();
 240   EXPECT_EQ(
 241       MOJO_RESULT_ALREADY_EXISTS,
 242       dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 34, &hss));
 243
 244   // Write two elements.
 245   int32_t elements[2] = {123, 456};
 246   uint32_t num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
 247   EXPECT_EQ(MOJO_RESULT_OK,
 248             dp->ProducerWriteData(UserPointer<const void>(elements),
 249                                   MakeUserPointer(&num_bytes),
 250                                   true));
 251   EXPECT_EQ(static_cast<uint32_t>(2u * sizeof(elements[0])), num_bytes);
 252
 253   // Adding a waiter should now succeed.
 254   waiter.Init();
 255   ASSERT_EQ(
 256       MOJO_RESULT_OK,
 257       dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 56, nullptr));
 258   // And it shouldn't be writable yet.
 259   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
 260   hss = HandleSignalsState();
 261   dp->ProducerRemoveWaiter(&waiter, &hss);
 262   EXPECT_EQ(0u, hss.satisfied_signals);
 263   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
 264
 265   // Do it again.
 266   waiter.Init();
 267   ASSERT_EQ(
 268       MOJO_RESULT_OK,
 269       dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 78, nullptr));
 270
 271   // Read one element.
 272   elements[0] = -1;
 273   elements[1] = -1;
 274   num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
 275   EXPECT_EQ(
 276       MOJO_RESULT_OK,
 277       dp->ConsumerReadData(
 278           UserPointer<void>(elements), MakeUserPointer(&num_bytes), true));
 279   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
 280   EXPECT_EQ(123, elements[0]);
 281   EXPECT_EQ(-1, elements[1]);
 282
 283   // Waiting should now succeed.
 284   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(1000, &context));
 285   EXPECT_EQ(78u, context);
 286   hss = HandleSignalsState();
 287   dp->ProducerRemoveWaiter(&waiter, &hss);
 288   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
 289   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
 290
 291   // Try writing, using a two-phase write.
 292   void* buffer = nullptr;
 293   num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0]));
 294   EXPECT_EQ(MOJO_RESULT_OK,
 295             dp->ProducerBeginWriteData(
 296                 MakeUserPointer(&buffer), MakeUserPointer(&num_bytes), false));
 297   EXPECT_TRUE(buffer);
 298   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
 299
 300   static_cast<int32_t*>(buffer)[0] = 789;
 301   EXPECT_EQ(MOJO_RESULT_OK,
 302             dp->ProducerEndWriteData(
 303                 static_cast<uint32_t>(1u * sizeof(elements[0]))));
 304
 305   // Add a waiter.
 306   waiter.Init();
 307   ASSERT_EQ(
 308       MOJO_RESULT_OK,
 309       dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 90, nullptr));
 310
 311   // Read one element, using a two-phase read.
 312   const void* read_buffer = nullptr;
 313   num_bytes = 0u;
 314   EXPECT_EQ(
 315       MOJO_RESULT_OK,
 316       dp->ConsumerBeginReadData(
 317           MakeUserPointer(&read_buffer), MakeUserPointer(&num_bytes), false));
 318   EXPECT_TRUE(read_buffer);
 319   // Since we only read one element (after having written three in all), the
 320   // two-phase read should only allow us to read one. This checks an
 321   // implementation detail!
 322   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
 323   EXPECT_EQ(456, static_cast<const int32_t*>(read_buffer)[0]);
 324   EXPECT_EQ(
 325       MOJO_RESULT_OK,
 326       dp->ConsumerEndReadData(static_cast<uint32_t>(1u * sizeof(elements[0]))));
 327
 328   // Waiting should succeed.
 329   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(1000, &context));
 330   EXPECT_EQ(90u, context);
 331   hss = HandleSignalsState();
 332   dp->ProducerRemoveWaiter(&waiter, &hss);
 333   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
 334   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
 335
 336   // Write one element.
 337   elements[0] = 123;
 338   num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
 339   EXPECT_EQ(MOJO_RESULT_OK,
 340             dp->ProducerWriteData(UserPointer<const void>(elements),
 341                                   MakeUserPointer(&num_bytes),
 342                                   false));
 343   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
 344
 345   // Add a waiter.
 346   waiter.Init();
 347   ASSERT_EQ(
 348       MOJO_RESULT_OK,
 349       dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 12, nullptr));
 350
 351   // Close the consumer.
 352   dp->ConsumerClose();
 353
 354   // It should now be never-writable.
 355   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, waiter.Wait(1000, &context));
 356   EXPECT_EQ(12u, context);
 357   hss = HandleSignalsState();
 358   dp->ProducerRemoveWaiter(&waiter, &hss);
 359   EXPECT_EQ(0u, hss.satisfied_signals);
 360   EXPECT_EQ(0u, hss.satisfiable_signals);
 361
 362   dp->ProducerClose();
 363 }
 364
 365 TEST(LocalDataPipeTest, BasicConsumerWaiting) {
 366   const MojoCreateDataPipeOptions options = {
 367       kSizeOfOptions,                           // |struct_size|.
 368       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
 369       static_cast<uint32_t>(sizeof(int32_t)),   // |element_num_bytes|.
 370       1000 * sizeof(int32_t)                    // |capacity_num_bytes|.
 371   };
 372   MojoCreateDataPipeOptions validated_options = {0};
 373   EXPECT_EQ(MOJO_RESULT_OK,
 374             DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
 375                                             &validated_options));
 376
 377   {
 378     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 379     Waiter waiter;
 380     uint32_t context = 0;
 381     HandleSignalsState hss;
 382
 383     // Never writable.
 384     waiter.Init();
 385     hss = HandleSignalsState();
 386     EXPECT_EQ(
 387         MOJO_RESULT_FAILED_PRECONDITION,
 388         dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 12, &hss));
 389     EXPECT_EQ(0u, hss.satisfied_signals);
 390     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 391
 392     // Not yet readable.
 393     waiter.Init();
 394     ASSERT_EQ(MOJO_RESULT_OK,
 395               dp->ConsumerAddWaiter(
 396                   &waiter, MOJO_HANDLE_SIGNAL_READABLE, 34, nullptr));
 397     EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
 398     hss = HandleSignalsState();
 399     dp->ConsumerRemoveWaiter(&waiter, &hss);
 400     EXPECT_EQ(0u, hss.satisfied_signals);
 401     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 402
 403     // Write two elements.
 404     int32_t elements[2] = {123, 456};
 405     uint32_t num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
 406     EXPECT_EQ(MOJO_RESULT_OK,
 407               dp->ProducerWriteData(UserPointer<const void>(elements),
 408                                     MakeUserPointer(&num_bytes),
 409                                     true));
 410
 411     // Should already be readable.
 412     waiter.Init();
 413     hss = HandleSignalsState();
 414     EXPECT_EQ(
 415         MOJO_RESULT_ALREADY_EXISTS,
 416         dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 56, &hss));
 417     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
 418     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 419
 420     // Discard one element.
 421     num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
 422     EXPECT_EQ(MOJO_RESULT_OK,
 423               dp->ConsumerDiscardData(MakeUserPointer(&num_bytes), true));
 424     EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
 425
 426     // Should still be readable.
 427     waiter.Init();
 428     hss = HandleSignalsState();
 429     EXPECT_EQ(
 430         MOJO_RESULT_ALREADY_EXISTS,
 431         dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 78, &hss));
 432     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
 433     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 434
 435     // Read one element.
 436     elements[0] = -1;
 437     elements[1] = -1;
 438     num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
 439     EXPECT_EQ(
 440         MOJO_RESULT_OK,
 441         dp->ConsumerReadData(
 442             UserPointer<void>(elements), MakeUserPointer(&num_bytes), true));
 443     EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
 444     EXPECT_EQ(456, elements[0]);
 445     EXPECT_EQ(-1, elements[1]);
 446
 447     // Adding a waiter should now succeed.
 448     waiter.Init();
 449     ASSERT_EQ(MOJO_RESULT_OK,
 450               dp->ConsumerAddWaiter(
 451                   &waiter, MOJO_HANDLE_SIGNAL_READABLE, 90, nullptr));
 452
 453     // Write one element.
 454     elements[0] = 789;
 455     elements[1] = -1;
 456     num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
 457     EXPECT_EQ(MOJO_RESULT_OK,
 458               dp->ProducerWriteData(UserPointer<const void>(elements),
 459                                     MakeUserPointer(&num_bytes),
 460                                     true));
 461
 462     // Waiting should now succeed.
 463     EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(1000, &context));
 464     EXPECT_EQ(90u, context);
 465     hss = HandleSignalsState();
 466     dp->ConsumerRemoveWaiter(&waiter, &hss);
 467     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
 468     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 469
 470     // Close the producer.
 471     dp->ProducerClose();
 472
 473     // Should still be readable.
 474     waiter.Init();
 475     hss = HandleSignalsState();
 476     EXPECT_EQ(
 477         MOJO_RESULT_ALREADY_EXISTS,
 478         dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12, &hss));
 479     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
 480     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 481
 482     // Read one element.
 483     elements[0] = -1;
 484     elements[1] = -1;
 485     num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
 486     EXPECT_EQ(
 487         MOJO_RESULT_OK,
 488         dp->ConsumerReadData(
 489             UserPointer<void>(elements), MakeUserPointer(&num_bytes), true));
 490     EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
 491     EXPECT_EQ(789, elements[0]);
 492     EXPECT_EQ(-1, elements[1]);
 493
 494     // Should be never-readable.
 495     waiter.Init();
 496     hss = HandleSignalsState();
 497     EXPECT_EQ(
 498         MOJO_RESULT_FAILED_PRECONDITION,
 499         dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34, &hss));
 500     EXPECT_EQ(0u, hss.satisfied_signals);
 501     EXPECT_EQ(0u, hss.satisfiable_signals);
 502
 503     dp->ConsumerClose();
 504   }
 505
 506   // Test with two-phase APIs and closing the producer with an active consumer
 507   // waiter.
 508   {
 509     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 510     Waiter waiter;
 511     uint32_t context = 0;
 512     HandleSignalsState hss;
 513
 514     // Write two elements.
 515     int32_t* elements = nullptr;
 516     void* buffer = nullptr;
 517     // Request room for three (but we'll only write two).
 518     uint32_t num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0]));
 519     EXPECT_EQ(MOJO_RESULT_OK,
 520               dp->ProducerBeginWriteData(
 521                   MakeUserPointer(&buffer), MakeUserPointer(&num_bytes), true));
 522     EXPECT_TRUE(buffer);
 523     EXPECT_GE(num_bytes, static_cast<uint32_t>(3u * sizeof(elements[0])));
 524     elements = static_cast<int32_t*>(buffer);
 525     elements[0] = 123;
 526     elements[1] = 456;
 527     EXPECT_EQ(MOJO_RESULT_OK,
 528               dp->ProducerEndWriteData(
 529                   static_cast<uint32_t>(2u * sizeof(elements[0]))));
 530
 531     // Should already be readable.
 532     waiter.Init();
 533     hss = HandleSignalsState();
 534     EXPECT_EQ(
 535         MOJO_RESULT_ALREADY_EXISTS,
 536         dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12, &hss));
 537     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
 538     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 539
 540     // Read one element.
 541     // Request two in all-or-none mode, but only read one.
 542     const void* read_buffer = nullptr;
 543     num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
 544     EXPECT_EQ(
 545         MOJO_RESULT_OK,
 546         dp->ConsumerBeginReadData(
 547             MakeUserPointer(&read_buffer), MakeUserPointer(&num_bytes), true));
 548     EXPECT_TRUE(read_buffer);
 549     EXPECT_EQ(static_cast<uint32_t>(2u * sizeof(elements[0])), num_bytes);
 550     const int32_t* read_elements = static_cast<const int32_t*>(read_buffer);
 551     EXPECT_EQ(123, read_elements[0]);
 552     EXPECT_EQ(MOJO_RESULT_OK,
 553               dp->ConsumerEndReadData(
 554                   static_cast<uint32_t>(1u * sizeof(elements[0]))));
 555
 556     // Should still be readable.
 557     waiter.Init();
 558     hss = HandleSignalsState();
 559     EXPECT_EQ(
 560         MOJO_RESULT_ALREADY_EXISTS,
 561         dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34, &hss));
 562     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
 563     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 564
 565     // Read one element.
 566     // Request three, but not in all-or-none mode.
 567     read_buffer = nullptr;
 568     num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0]));
 569     EXPECT_EQ(
 570         MOJO_RESULT_OK,
 571         dp->ConsumerBeginReadData(
 572             MakeUserPointer(&read_buffer), MakeUserPointer(&num_bytes), false));
 573     EXPECT_TRUE(read_buffer);
 574     EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
 575     read_elements = static_cast<const int32_t*>(read_buffer);
 576     EXPECT_EQ(456, read_elements[0]);
 577     EXPECT_EQ(MOJO_RESULT_OK,
 578               dp->ConsumerEndReadData(
 579                   static_cast<uint32_t>(1u * sizeof(elements[0]))));
 580
 581     // Adding a waiter should now succeed.
 582     waiter.Init();
 583     ASSERT_EQ(MOJO_RESULT_OK,
 584               dp->ConsumerAddWaiter(
 585                   &waiter, MOJO_HANDLE_SIGNAL_READABLE, 56, nullptr));
 586
 587     // Close the producer.
 588     dp->ProducerClose();
 589
 590     // Should be never-readable.
 591     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, waiter.Wait(1000, &context));
 592     EXPECT_EQ(56u, context);
 593     hss = HandleSignalsState();
 594     dp->ConsumerRemoveWaiter(&waiter, &hss);
 595     EXPECT_EQ(0u, hss.satisfied_signals);
 596     EXPECT_EQ(0u, hss.satisfiable_signals);
 597
 598     dp->ConsumerClose();
 599   }
 600 }
 601
 602 // Tests that data pipes aren't writable/readable during two-phase writes/reads.
 603 TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) {
 604   const MojoCreateDataPipeOptions options = {
 605       kSizeOfOptions,                           // |struct_size|.
 606       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
 607       static_cast<uint32_t>(sizeof(int32_t)),   // |element_num_bytes|.
 608       1000 * sizeof(int32_t)                    // |capacity_num_bytes|.
 609   };
 610   MojoCreateDataPipeOptions validated_options = {0};
 611   EXPECT_EQ(MOJO_RESULT_OK,
 612             DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
 613                                             &validated_options));
 614
 615   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 616   Waiter waiter;
 617   HandleSignalsState hss;
 618
 619   // It should be writable.
 620   waiter.Init();
 621   hss = HandleSignalsState();
 622   EXPECT_EQ(
 623       MOJO_RESULT_ALREADY_EXISTS,
 624       dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss));
 625   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
 626   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
 627
 628   uint32_t num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t));
 629   void* write_ptr = nullptr;
 630   EXPECT_EQ(
 631       MOJO_RESULT_OK,
 632       dp->ProducerBeginWriteData(
 633           MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
 634   EXPECT_TRUE(write_ptr);
 635   EXPECT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(int32_t)));
 636
 637   // At this point, it shouldn't be writable.
 638   waiter.Init();
 639   ASSERT_EQ(
 640       MOJO_RESULT_OK,
 641       dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 1, nullptr));
 642   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
 643   hss = HandleSignalsState();
 644   dp->ProducerRemoveWaiter(&waiter, &hss);
 645   EXPECT_EQ(0u, hss.satisfied_signals);
 646   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
 647
 648   // It shouldn't be readable yet either.
 649   waiter.Init();
 650   ASSERT_EQ(
 651       MOJO_RESULT_OK,
 652       dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 2, nullptr));
 653   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
 654   hss = HandleSignalsState();
 655   dp->ConsumerRemoveWaiter(&waiter, &hss);
 656   EXPECT_EQ(0u, hss.satisfied_signals);
 657   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 658
 659   static_cast<int32_t*>(write_ptr)[0] = 123;
 660   EXPECT_EQ(
 661       MOJO_RESULT_OK,
 662       dp->ProducerEndWriteData(static_cast<uint32_t>(1u * sizeof(int32_t))));
 663
 664   // It should be writable again.
 665   waiter.Init();
 666   hss = HandleSignalsState();
 667   EXPECT_EQ(
 668       MOJO_RESULT_ALREADY_EXISTS,
 669       dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 3, &hss));
 670   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
 671   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
 672
 673   // And readable.
 674   waiter.Init();
 675   hss = HandleSignalsState();
 676   EXPECT_EQ(
 677       MOJO_RESULT_ALREADY_EXISTS,
 678       dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 4, &hss));
 679   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
 680   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 681
 682   // Start another two-phase write and check that it's readable even in the
 683   // middle of it.
 684   num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t));
 685   write_ptr = nullptr;
 686   EXPECT_EQ(
 687       MOJO_RESULT_OK,
 688       dp->ProducerBeginWriteData(
 689           MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
 690   EXPECT_TRUE(write_ptr);
 691   EXPECT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(int32_t)));
 692
 693   // It should be readable.
 694   waiter.Init();
 695   hss = HandleSignalsState();
 696   EXPECT_EQ(
 697       MOJO_RESULT_ALREADY_EXISTS,
 698       dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 5, &hss));
 699   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
 700   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 701
 702   // End the two-phase write without writing anything.
 703   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(0u));
 704
 705   // Start a two-phase read.
 706   num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t));
 707   const void* read_ptr = nullptr;
 708   EXPECT_EQ(
 709       MOJO_RESULT_OK,
 710       dp->ConsumerBeginReadData(
 711           MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false));
 712   EXPECT_TRUE(read_ptr);
 713   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(int32_t)), num_bytes);
 714
 715   // At this point, it should still be writable.
 716   waiter.Init();
 717   hss = HandleSignalsState();
 718   EXPECT_EQ(
 719       MOJO_RESULT_ALREADY_EXISTS,
 720       dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 6, &hss));
 721   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
 722   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
 723
 724   // But not readable.
 725   waiter.Init();
 726   ASSERT_EQ(
 727       MOJO_RESULT_OK,
 728       dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 7, nullptr));
 729   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
 730   hss = HandleSignalsState();
 731   dp->ConsumerRemoveWaiter(&waiter, &hss);
 732   EXPECT_EQ(0u, hss.satisfied_signals);
 733   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 734
 735   // End the two-phase read without reading anything.
 736   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(0u));
 737
 738   // It should be readable again.
 739   waiter.Init();
 740   hss = HandleSignalsState();
 741   EXPECT_EQ(
 742       MOJO_RESULT_ALREADY_EXISTS,
 743       dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 8, &hss));
 744   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
 745   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 746
 747   dp->ProducerClose();
 748   dp->ConsumerClose();
 749 }
 750
 751 // Test that a "may discard" data pipe is writable even when it's full.
 752 TEST(LocalDataPipeTest, BasicMayDiscardWaiting) {
 753   const MojoCreateDataPipeOptions options = {
 754       kSizeOfOptions,                                  // |struct_size|.
 755       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD,  // |flags|.
 756       static_cast<uint32_t>(sizeof(int32_t)),          // |element_num_bytes|.
 757       1 * sizeof(int32_t)                              // |capacity_num_bytes|.
 758   };
 759   MojoCreateDataPipeOptions validated_options = {0};
 760   EXPECT_EQ(MOJO_RESULT_OK,
 761             DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
 762                                             &validated_options));
 763
 764   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 765   Waiter waiter;
 766   HandleSignalsState hss;
 767
 768   // Writable.
 769   waiter.Init();
 770   hss = HandleSignalsState();
 771   EXPECT_EQ(
 772       MOJO_RESULT_ALREADY_EXISTS,
 773       dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss));
 774   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
 775   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
 776
 777   // Not readable.
 778   waiter.Init();
 779   ASSERT_EQ(
 780       MOJO_RESULT_OK,
 781       dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 1, nullptr));
 782   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
 783   hss = HandleSignalsState();
 784   dp->ConsumerRemoveWaiter(&waiter, &hss);
 785   EXPECT_EQ(0u, hss.satisfied_signals);
 786   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 787
 788   uint32_t num_bytes = static_cast<uint32_t>(sizeof(int32_t));
 789   int32_t element = 123;
 790   EXPECT_EQ(MOJO_RESULT_OK,
 791             dp->ProducerWriteData(UserPointer<const void>(&element),
 792                                   MakeUserPointer(&num_bytes),
 793                                   false));
 794   EXPECT_EQ(static_cast<uint32_t>(sizeof(int32_t)), num_bytes);
 795
 796   // Still writable (even though it's full).
 797   waiter.Init();
 798   hss = HandleSignalsState();
 799   EXPECT_EQ(
 800       MOJO_RESULT_ALREADY_EXISTS,
 801       dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 2, &hss));
 802   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
 803   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
 804
 805   // Now readable.
 806   waiter.Init();
 807   hss = HandleSignalsState();
 808   EXPECT_EQ(
 809       MOJO_RESULT_ALREADY_EXISTS,
 810       dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 3, &hss));
 811   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
 812   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 813
 814   // Overwrite that element.
 815   num_bytes = static_cast<uint32_t>(sizeof(int32_t));
 816   element = 456;
 817   EXPECT_EQ(MOJO_RESULT_OK,
 818             dp->ProducerWriteData(UserPointer<const void>(&element),
 819                                   MakeUserPointer(&num_bytes),
 820                                   false));
 821   EXPECT_EQ(static_cast<uint32_t>(sizeof(int32_t)), num_bytes);
 822
 823   // Still writable.
 824   waiter.Init();
 825   hss = HandleSignalsState();
 826   EXPECT_EQ(
 827       MOJO_RESULT_ALREADY_EXISTS,
 828       dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 4, &hss));
 829   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
 830   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
 831
 832   // And still readable.
 833   waiter.Init();
 834   hss = HandleSignalsState();
 835   EXPECT_EQ(
 836       MOJO_RESULT_ALREADY_EXISTS,
 837       dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 5, &hss));
 838   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
 839   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 840
 841   // Read that element.
 842   num_bytes = static_cast<uint32_t>(sizeof(int32_t));
 843   element = 0;
 844   EXPECT_EQ(
 845       MOJO_RESULT_OK,
 846       dp->ConsumerReadData(
 847           UserPointer<void>(&element), MakeUserPointer(&num_bytes), false));
 848   EXPECT_EQ(static_cast<uint32_t>(sizeof(int32_t)), num_bytes);
 849   EXPECT_EQ(456, element);
 850
 851   // Still writable.
 852   waiter.Init();
 853   hss = HandleSignalsState();
 854   EXPECT_EQ(
 855       MOJO_RESULT_ALREADY_EXISTS,
 856       dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 6, &hss));
 857   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
 858   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
 859
 860   // No longer readable.
 861   waiter.Init();
 862   ASSERT_EQ(
 863       MOJO_RESULT_OK,
 864       dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 7, nullptr));
 865   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
 866   hss = HandleSignalsState();
 867   dp->ConsumerRemoveWaiter(&waiter, &hss);
 868   EXPECT_EQ(0u, hss.satisfied_signals);
 869   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 870
 871   dp->ProducerClose();
 872   dp->ConsumerClose();
 873 }
 874
 875 void Seq(int32_t start, size_t count, int32_t* out) {
 876   for (size_t i = 0; i < count; i++)
 877     out[i] = start + static_cast<int32_t>(i);
 878 }
 879
 880 TEST(LocalDataPipeTest, MayDiscard) {
 881   const MojoCreateDataPipeOptions options = {
 882       kSizeOfOptions,                                  // |struct_size|.
 883       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD,  // |flags|.
 884       static_cast<uint32_t>(sizeof(int32_t)),          // |element_num_bytes|.
 885       10 * sizeof(int32_t)                             // |capacity_num_bytes|.
 886   };
 887   MojoCreateDataPipeOptions validated_options = {0};
 888   EXPECT_EQ(MOJO_RESULT_OK,
 889             DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
 890                                             &validated_options));
 891
 892   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 893
 894   int32_t buffer[100] = {0};
 895   uint32_t num_bytes = 0;
 896
 897   num_bytes = 20u * sizeof(int32_t);
 898   Seq(0, arraysize(buffer), buffer);
 899   // Try writing more than capacity. (This test relies on the implementation
 900   // enforcing the capacity strictly.)
 901   EXPECT_EQ(
 902       MOJO_RESULT_OK,
 903       dp->ProducerWriteData(
 904           UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), false));
 905   EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
 906
 907   // Read half of what we wrote.
 908   num_bytes = 5u * sizeof(int32_t);
 909   memset(buffer, 0xab, sizeof(buffer));
 910   EXPECT_EQ(MOJO_RESULT_OK,
 911             dp->ConsumerReadData(
 912                 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), false));
 913   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
 914   int32_t expected_buffer[100];
 915   memset(expected_buffer, 0xab, sizeof(expected_buffer));
 916   Seq(0, 5u, expected_buffer);
 917   EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
 918   // Internally, a circular buffer would now look like:
 919   //   -, -, -, -, -, 5, 6, 7, 8, 9
 920
 921   // Write a bit more than the space that's available.
 922   num_bytes = 8u * sizeof(int32_t);
 923   Seq(100, arraysize(buffer), buffer);
 924   EXPECT_EQ(
 925       MOJO_RESULT_OK,
 926       dp->ProducerWriteData(
 927           UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), false));
 928   EXPECT_EQ(8u * sizeof(int32_t), num_bytes);
 929   // Internally, a circular buffer would now look like:
 930   //   100, 101, 102, 103, 104, 105, 106, 107, 8, 9
 931
 932   // Read half of what's available.
 933   num_bytes = 5u * sizeof(int32_t);
 934   memset(buffer, 0xab, sizeof(buffer));
 935   EXPECT_EQ(MOJO_RESULT_OK,
 936             dp->ConsumerReadData(
 937                 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), false));
 938   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
 939   memset(expected_buffer, 0xab, sizeof(expected_buffer));
 940   expected_buffer[0] = 8;
 941   expected_buffer[1] = 9;
 942   expected_buffer[2] = 100;
 943   expected_buffer[3] = 101;
 944   expected_buffer[4] = 102;
 945   EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
 946   // Internally, a circular buffer would now look like:
 947   //   -, -, -, 103, 104, 105, 106, 107, -, -
 948
 949   // Write one integer.
 950   num_bytes = 1u * sizeof(int32_t);
 951   Seq(200, arraysize(buffer), buffer);
 952   EXPECT_EQ(
 953       MOJO_RESULT_OK,
 954       dp->ProducerWriteData(
 955           UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), false));
 956   EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
 957   // Internally, a circular buffer would now look like:
 958   //   -, -, -, 103, 104, 105, 106, 107, 200, -
 959
 960   // Write five more.
 961   num_bytes = 5u * sizeof(int32_t);
 962   Seq(300, arraysize(buffer), buffer);
 963   EXPECT_EQ(
 964       MOJO_RESULT_OK,
 965       dp->ProducerWriteData(
 966           UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), false));
 967   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
 968   // Internally, a circular buffer would now look like:
 969   //   301, 302, 303, 304, 104, 105, 106, 107, 200, 300
 970
 971   // Read it all.
 972   num_bytes = sizeof(buffer);
 973   memset(buffer, 0xab, sizeof(buffer));
 974   EXPECT_EQ(MOJO_RESULT_OK,
 975             dp->ConsumerReadData(
 976                 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), false));
 977   EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
 978   memset(expected_buffer, 0xab, sizeof(expected_buffer));
 979   expected_buffer[0] = 104;
 980   expected_buffer[1] = 105;
 981   expected_buffer[2] = 106;
 982   expected_buffer[3] = 107;
 983   expected_buffer[4] = 200;
 984   expected_buffer[5] = 300;
 985   expected_buffer[6] = 301;
 986   expected_buffer[7] = 302;
 987   expected_buffer[8] = 303;
 988   expected_buffer[9] = 304;
 989   EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
 990
 991   // Test two-phase writes, including in all-or-none mode.
 992   // Note: Again, the following depends on an implementation detail -- namely
 993   // that the write pointer will point at the 5th element of the buffer (and the
 994   // buffer has exactly the capacity requested).
 995
 996   num_bytes = 0u;
 997   void* write_ptr = nullptr;
 998   EXPECT_EQ(
 999       MOJO_RESULT_OK,
1000       dp->ProducerBeginWriteData(
1001           MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
1002   EXPECT_TRUE(write_ptr);
1003   EXPECT_EQ(6u * sizeof(int32_t), num_bytes);
1004   Seq(400, 6, static_cast<int32_t*>(write_ptr));
1005   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(6u * sizeof(int32_t)));
1006   // Internally, a circular buffer would now look like:
1007   //   -, -, -, -, 400, 401, 402, 403, 404, 405
1008
1009   // |ProducerBeginWriteData()| ignores |*num_bytes| except in "all-or-none"
1010   // mode.
1011   num_bytes = 6u * sizeof(int32_t);
1012   write_ptr = nullptr;
1013   EXPECT_EQ(
1014       MOJO_RESULT_OK,
1015       dp->ProducerBeginWriteData(
1016           MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
1017   EXPECT_EQ(4u * sizeof(int32_t), num_bytes);
1018   static_cast<int32_t*>(write_ptr)[0] = 500;
1019   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(1u * sizeof(int32_t)));
1020   // Internally, a circular buffer would now look like:
1021   //   500, -, -, -, 400, 401, 402, 403, 404, 405
1022
1023   // Requesting a 10-element buffer in all-or-none mode fails at this point.
1024   num_bytes = 10u * sizeof(int32_t);
1025   write_ptr = nullptr;
1026   EXPECT_EQ(
1027       MOJO_RESULT_OUT_OF_RANGE,
1028       dp->ProducerBeginWriteData(
1029           MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
1030
1031   // But requesting, say, a 5-element (up to 9, really) buffer should be okay.
1032   // It will discard two elements.
1033   num_bytes = 5u * sizeof(int32_t);
1034   write_ptr = nullptr;
1035   EXPECT_EQ(
1036       MOJO_RESULT_OK,
1037       dp->ProducerBeginWriteData(
1038           MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
1039   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
1040   // Only write 4 elements though.
1041   Seq(600, 4, static_cast<int32_t*>(write_ptr));
1042   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(4u * sizeof(int32_t)));
1043   // Internally, a circular buffer would now look like:
1044   //   500, 600, 601, 602, 603, -, 402, 403, 404, 405
1045
1046   // Do this again. Make sure we can get a buffer all the way out to the end of
1047   // the internal buffer.
1048   num_bytes = 5u * sizeof(int32_t);
1049   write_ptr = nullptr;
1050   EXPECT_EQ(
1051       MOJO_RESULT_OK,
1052       dp->ProducerBeginWriteData(
1053           MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
1054   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
1055   // Only write 3 elements though.
1056   Seq(700, 3, static_cast<int32_t*>(write_ptr));
1057   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(3u * sizeof(int32_t)));
1058   // Internally, a circular buffer would now look like:
1059   //   500, 600, 601, 602, 603, 700, 701, 702, -, -
1060
1061   // Read everything.
1062   num_bytes = sizeof(buffer);
1063   memset(buffer, 0xab, sizeof(buffer));
1064   EXPECT_EQ(MOJO_RESULT_OK,
1065             dp->ConsumerReadData(
1066                 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), false));
1067   EXPECT_EQ(8u * sizeof(int32_t), num_bytes);
1068   memset(expected_buffer, 0xab, sizeof(expected_buffer));
1069   expected_buffer[0] = 500;
1070   expected_buffer[1] = 600;
1071   expected_buffer[2] = 601;
1072   expected_buffer[3] = 602;
1073   expected_buffer[4] = 603;
1074   expected_buffer[5] = 700;
1075   expected_buffer[6] = 701;
1076   expected_buffer[7] = 702;
1077   EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
1078
1079   dp->ProducerClose();
1080   dp->ConsumerClose();
1081 }
1082
1083 TEST(LocalDataPipeTest, AllOrNone) {
1084   const MojoCreateDataPipeOptions options = {
1085       kSizeOfOptions,                           // |struct_size|.
1086       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
1087       static_cast<uint32_t>(sizeof(int32_t)),   // |element_num_bytes|.
1088       10 * sizeof(int32_t)                      // |capacity_num_bytes|.
1089   };
1090   MojoCreateDataPipeOptions validated_options = {0};
1091   EXPECT_EQ(MOJO_RESULT_OK,
1092             DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
1093                                             &validated_options));
1094
1095   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
1096
1097   // Try writing way too much.
1098   uint32_t num_bytes = 20u * sizeof(int32_t);
1099   int32_t buffer[100];
1100   Seq(0, arraysize(buffer), buffer);
1101   EXPECT_EQ(
1102       MOJO_RESULT_OUT_OF_RANGE,
1103       dp->ProducerWriteData(
1104           UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
1105
1106   // Should still be empty.
1107   num_bytes = ~0u;
1108   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1109   EXPECT_EQ(0u, num_bytes);
1110
1111   // Write some data.
1112   num_bytes = 5u * sizeof(int32_t);
1113   Seq(100, arraysize(buffer), buffer);
1114   EXPECT_EQ(
1115       MOJO_RESULT_OK,
1116       dp->ProducerWriteData(
1117           UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
1118   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
1119
1120   // Half full.
1121   num_bytes = 0u;
1122   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1123   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
1124
1125   // Too much.
1126   num_bytes = 6u * sizeof(int32_t);
1127   Seq(200, arraysize(buffer), buffer);
1128   EXPECT_EQ(
1129       MOJO_RESULT_OUT_OF_RANGE,
1130       dp->ProducerWriteData(
1131           UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
1132
1133   // Try reading too much.
1134   num_bytes = 11u * sizeof(int32_t);
1135   memset(buffer, 0xab, sizeof(buffer));
1136   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
1137             dp->ConsumerReadData(
1138                 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true));
1139   int32_t expected_buffer[100];
1140   memset(expected_buffer, 0xab, sizeof(expected_buffer));
1141   EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
1142
1143   // Try discarding too much.
1144   num_bytes = 11u * sizeof(int32_t);
1145   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
1146             dp->ConsumerDiscardData(MakeUserPointer(&num_bytes), true));
1147
1148   // Just a little.
1149   num_bytes = 2u * sizeof(int32_t);
1150   Seq(300, arraysize(buffer), buffer);
1151   EXPECT_EQ(
1152       MOJO_RESULT_OK,
1153       dp->ProducerWriteData(
1154           UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
1155   EXPECT_EQ(2u * sizeof(int32_t), num_bytes);
1156
1157   // Just right.
1158   num_bytes = 3u * sizeof(int32_t);
1159   Seq(400, arraysize(buffer), buffer);
1160   EXPECT_EQ(
1161       MOJO_RESULT_OK,
1162       dp->ProducerWriteData(
1163           UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
1164   EXPECT_EQ(3u * sizeof(int32_t), num_bytes);
1165
1166   // Exactly full.
1167   num_bytes = 0u;
1168   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1169   EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
1170
1171   // Read half.
1172   num_bytes = 5u * sizeof(int32_t);
1173   memset(buffer, 0xab, sizeof(buffer));
1174   EXPECT_EQ(MOJO_RESULT_OK,
1175             dp->ConsumerReadData(
1176                 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true));
1177   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
1178   memset(expected_buffer, 0xab, sizeof(expected_buffer));
1179   Seq(100, 5, expected_buffer);
1180   EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
1181
1182   // Try reading too much again.
1183   num_bytes = 6u * sizeof(int32_t);
1184   memset(buffer, 0xab, sizeof(buffer));
1185   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
1186             dp->ConsumerReadData(
1187                 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true));
1188   memset(expected_buffer, 0xab, sizeof(expected_buffer));
1189   EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
1190
1191   // Try discarding too much again.
1192   num_bytes = 6u * sizeof(int32_t);
1193   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
1194             dp->ConsumerDiscardData(MakeUserPointer(&num_bytes), true));
1195
1196   // Discard a little.
1197   num_bytes = 2u * sizeof(int32_t);
1198   EXPECT_EQ(MOJO_RESULT_OK,
1199             dp->ConsumerDiscardData(MakeUserPointer(&num_bytes), true));
1200   EXPECT_EQ(2u * sizeof(int32_t), num_bytes);
1201
1202   // Three left.
1203   num_bytes = 0u;
1204   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1205   EXPECT_EQ(3u * sizeof(int32_t), num_bytes);
1206
1207   // Close the producer, then test producer-closed cases.
1208   dp->ProducerClose();
1209
1210   // Try reading too much; "failed precondition" since the producer is closed.
1211   num_bytes = 4u * sizeof(int32_t);
1212   memset(buffer, 0xab, sizeof(buffer));
1213   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
1214             dp->ConsumerReadData(
1215                 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true));
1216   memset(expected_buffer, 0xab, sizeof(expected_buffer));
1217   EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
1218
1219   // Try discarding too much; "failed precondition" again.
1220   num_bytes = 4u * sizeof(int32_t);
1221   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
1222             dp->ConsumerDiscardData(MakeUserPointer(&num_bytes), true));
1223
1224   // Read a little.
1225   num_bytes = 2u * sizeof(int32_t);
1226   memset(buffer, 0xab, sizeof(buffer));
1227   EXPECT_EQ(MOJO_RESULT_OK,
1228             dp->ConsumerReadData(
1229                 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true));
1230   EXPECT_EQ(2u * sizeof(int32_t), num_bytes);
1231   memset(expected_buffer, 0xab, sizeof(expected_buffer));
1232   Seq(400, 2, expected_buffer);
1233   EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
1234
1235   // Discard the remaining element.
1236   num_bytes = 1u * sizeof(int32_t);
1237   EXPECT_EQ(MOJO_RESULT_OK,
1238             dp->ConsumerDiscardData(MakeUserPointer(&num_bytes), true));
1239   EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
1240
1241   // Empty again.
1242   num_bytes = ~0u;
1243   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1244   EXPECT_EQ(0u, num_bytes);
1245
1246   dp->ConsumerClose();
1247 }
1248
1249 TEST(LocalDataPipeTest, AllOrNoneMayDiscard) {
1250   const MojoCreateDataPipeOptions options = {
1251       kSizeOfOptions,                                  // |struct_size|.
1252       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD,  // |flags|.
1253       static_cast<uint32_t>(sizeof(int32_t)),          // |element_num_bytes|.
1254       10 * sizeof(int32_t)                             // |capacity_num_bytes|.
1255   };
1256   MojoCreateDataPipeOptions validated_options = {0};
1257   EXPECT_EQ(MOJO_RESULT_OK,
1258             DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
1259                                             &validated_options));
1260
1261   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
1262
1263   // Try writing way too much.
1264   uint32_t num_bytes = 20u * sizeof(int32_t);
1265   int32_t buffer[100];
1266   Seq(0, arraysize(buffer), buffer);
1267   EXPECT_EQ(
1268       MOJO_RESULT_OUT_OF_RANGE,
1269       dp->ProducerWriteData(
1270           UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
1271
1272   // Write some stuff.
1273   num_bytes = 5u * sizeof(int32_t);
1274   Seq(100, arraysize(buffer), buffer);
1275   EXPECT_EQ(
1276       MOJO_RESULT_OK,
1277       dp->ProducerWriteData(
1278           UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
1279   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
1280
1281   // Write lots of stuff (discarding all but "104").
1282   num_bytes = 9u * sizeof(int32_t);
1283   Seq(200, arraysize(buffer), buffer);
1284   EXPECT_EQ(
1285       MOJO_RESULT_OK,
1286       dp->ProducerWriteData(
1287           UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
1288   EXPECT_EQ(9u * sizeof(int32_t), num_bytes);
1289
1290   // Read one.
1291   num_bytes = 1u * sizeof(int32_t);
1292   memset(buffer, 0xab, sizeof(buffer));
1293   EXPECT_EQ(MOJO_RESULT_OK,
1294             dp->ConsumerReadData(
1295                 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true));
1296   EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
1297   int32_t expected_buffer[100];
1298   memset(expected_buffer, 0xab, sizeof(expected_buffer));
1299   expected_buffer[0] = 104;
1300   EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
1301
1302   // Try reading too many.
1303   num_bytes = 10u * sizeof(int32_t);
1304   memset(buffer, 0xab, sizeof(buffer));
1305   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
1306             dp->ConsumerReadData(
1307                 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true));
1308   memset(expected_buffer, 0xab, sizeof(expected_buffer));
1309   EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
1310
1311   // Try discarding too many.
1312   num_bytes = 10u * sizeof(int32_t);
1313   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
1314             dp->ConsumerDiscardData(MakeUserPointer(&num_bytes), true));
1315
1316   // Discard a bunch.
1317   num_bytes = 4u * sizeof(int32_t);
1318   EXPECT_EQ(MOJO_RESULT_OK,
1319             dp->ConsumerDiscardData(MakeUserPointer(&num_bytes), true));
1320
1321   // Half full.
1322   num_bytes = 0u;
1323   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1324   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
1325
1326   // Write as much as possible.
1327   num_bytes = 10u * sizeof(int32_t);
1328   Seq(300, arraysize(buffer), buffer);
1329   EXPECT_EQ(
1330       MOJO_RESULT_OK,
1331       dp->ProducerWriteData(
1332           UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
1333   EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
1334
1335   // Read everything.
1336   num_bytes = 10u * sizeof(int32_t);
1337   memset(buffer, 0xab, sizeof(buffer));
1338   EXPECT_EQ(MOJO_RESULT_OK,
1339             dp->ConsumerReadData(
1340                 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true));
1341   memset(expected_buffer, 0xab, sizeof(expected_buffer));
1342   EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
1343   Seq(300, 10, expected_buffer);
1344   EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
1345
1346   // Note: All-or-none two-phase writes on a "may discard" data pipe are tested
1347   // in LocalDataPipeTest.MayDiscard.
1348
1349   dp->ProducerClose();
1350   dp->ConsumerClose();
1351 }
1352
1353 TEST(LocalDataPipeTest, TwoPhaseAllOrNone) {
1354   const MojoCreateDataPipeOptions options = {
1355       kSizeOfOptions,                           // |struct_size|.
1356       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
1357       static_cast<uint32_t>(sizeof(int32_t)),   // |element_num_bytes|.
1358       10 * sizeof(int32_t)                      // |capacity_num_bytes|.
1359   };
1360   MojoCreateDataPipeOptions validated_options = {0};
1361   EXPECT_EQ(MOJO_RESULT_OK,
1362             DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
1363                                             &validated_options));
1364
1365   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
1366
1367   // Try writing way too much (two-phase).
1368   uint32_t num_bytes = 20u * sizeof(int32_t);
1369   void* write_ptr = nullptr;
1370   EXPECT_EQ(
1371       MOJO_RESULT_OUT_OF_RANGE,
1372       dp->ProducerBeginWriteData(
1373           MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
1374
1375   // Try writing an amount which isn't a multiple of the element size
1376   // (two-phase).
1377   static_assert(sizeof(int32_t) > 1u, "Wow! int32_t's have size 1");
1378   num_bytes = 1u;
1379   write_ptr = nullptr;
1380   EXPECT_EQ(
1381       MOJO_RESULT_INVALID_ARGUMENT,
1382       dp->ProducerBeginWriteData(
1383           MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
1384
1385   // Try reading way too much (two-phase).
1386   num_bytes = 20u * sizeof(int32_t);
1387   const void* read_ptr = nullptr;
1388   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
1389             dp->ConsumerBeginReadData(
1390                 MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
1391
1392   // Write half (two-phase).
1393   num_bytes = 5u * sizeof(int32_t);
1394   write_ptr = nullptr;
1395   EXPECT_EQ(
1396       MOJO_RESULT_OK,
1397       dp->ProducerBeginWriteData(
1398           MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
1399   // May provide more space than requested.
1400   EXPECT_GE(num_bytes, 5u * sizeof(int32_t));
1401   EXPECT_TRUE(write_ptr);
1402   Seq(0, 5, static_cast<int32_t*>(write_ptr));
1403   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(5u * sizeof(int32_t)));
1404
1405   // Try reading an amount which isn't a multiple of the element size
1406   // (two-phase).
1407   num_bytes = 1u;
1408   read_ptr = nullptr;
1409   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
1410             dp->ConsumerBeginReadData(
1411                 MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
1412
1413   // Read one (two-phase).
1414   num_bytes = 1u * sizeof(int32_t);
1415   read_ptr = nullptr;
1416   EXPECT_EQ(MOJO_RESULT_OK,
1417             dp->ConsumerBeginReadData(
1418                 MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
1419   EXPECT_GE(num_bytes, 1u * sizeof(int32_t));
1420   EXPECT_EQ(0, static_cast<const int32_t*>(read_ptr)[0]);
1421   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(1u * sizeof(int32_t)));
1422
1423   // We should have four left, leaving room for six.
1424   num_bytes = 0u;
1425   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1426   EXPECT_EQ(4u * sizeof(int32_t), num_bytes);
1427
1428   // Assuming a tight circular buffer of the specified capacity, we can't do a
1429   // two-phase write of six now.
1430   num_bytes = 6u * sizeof(int32_t);
1431   write_ptr = nullptr;
1432   EXPECT_EQ(
1433       MOJO_RESULT_OUT_OF_RANGE,
1434       dp->ProducerBeginWriteData(
1435           MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
1436
1437   // Write six elements (simple), filling the buffer.
1438   num_bytes = 6u * sizeof(int32_t);
1439   int32_t buffer[100];
1440   Seq(100, 6, buffer);
1441   EXPECT_EQ(
1442       MOJO_RESULT_OK,
1443       dp->ProducerWriteData(
1444           UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
1445   EXPECT_EQ(6u * sizeof(int32_t), num_bytes);
1446
1447   // We have ten.
1448   num_bytes = 0u;
1449   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1450   EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
1451
1452   // But a two-phase read of ten should fail.
1453   num_bytes = 10u * sizeof(int32_t);
1454   read_ptr = nullptr;
1455   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
1456             dp->ConsumerBeginReadData(
1457                 MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
1458
1459   // Close the producer.
1460   dp->ProducerClose();
1461
1462   // A two-phase read of nine should work.
1463   num_bytes = 9u * sizeof(int32_t);
1464   read_ptr = nullptr;
1465   EXPECT_EQ(MOJO_RESULT_OK,
1466             dp->ConsumerBeginReadData(
1467                 MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
1468   EXPECT_GE(num_bytes, 9u * sizeof(int32_t));
1469   EXPECT_EQ(1, static_cast<const int32_t*>(read_ptr)[0]);
1470   EXPECT_EQ(2, static_cast<const int32_t*>(read_ptr)[1]);
1471   EXPECT_EQ(3, static_cast<const int32_t*>(read_ptr)[2]);
1472   EXPECT_EQ(4, static_cast<const int32_t*>(read_ptr)[3]);
1473   EXPECT_EQ(100, static_cast<const int32_t*>(read_ptr)[4]);
1474   EXPECT_EQ(101, static_cast<const int32_t*>(read_ptr)[5]);
1475   EXPECT_EQ(102, static_cast<const int32_t*>(read_ptr)[6]);
1476   EXPECT_EQ(103, static_cast<const int32_t*>(read_ptr)[7]);
1477   EXPECT_EQ(104, static_cast<const int32_t*>(read_ptr)[8]);
1478   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(9u * sizeof(int32_t)));
1479
1480   // A two-phase read of two should fail, with "failed precondition".
1481   num_bytes = 2u * sizeof(int32_t);
1482   read_ptr = nullptr;
1483   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
1484             dp->ConsumerBeginReadData(
1485                 MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
1486
1487   dp->ConsumerClose();
1488 }
1489
1490 // Tests that |ProducerWriteData()| and |ConsumerReadData()| writes and reads,
1491 // respectively, as much as possible, even if it has to "wrap around" the
1492 // internal circular buffer. (Note that the two-phase write and read do not do
1493 // this.)
1494 TEST(LocalDataPipeTest, WrapAround) {
1495   unsigned char test_data[1000];
1496   for (size_t i = 0; i < arraysize(test_data); i++)
1497     test_data[i] = static_cast<unsigned char>(i);
1498
1499   const MojoCreateDataPipeOptions options = {
1500       kSizeOfOptions,                           // |struct_size|.
1501       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
1502       1u,                                       // |element_num_bytes|.
1503       100u                                      // |capacity_num_bytes|.
1504   };
1505   MojoCreateDataPipeOptions validated_options = {0};
1506   EXPECT_EQ(MOJO_RESULT_OK,
1507             DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
1508                                             &validated_options));
1509   // This test won't be valid if |ValidateCreateOptions()| decides to give the
1510   // pipe more space.
1511   ASSERT_EQ(100u, validated_options.capacity_num_bytes);
1512
1513   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
1514
1515   // Write 20 bytes.
1516   uint32_t num_bytes = 20u;
1517   EXPECT_EQ(MOJO_RESULT_OK,
1518             dp->ProducerWriteData(UserPointer<const void>(&test_data[0]),
1519                                   MakeUserPointer(&num_bytes),
1520                                   false));
1521   EXPECT_EQ(20u, num_bytes);
1522
1523   // Read 10 bytes.
1524   unsigned char read_buffer[1000] = {0};
1525   num_bytes = 10u;
1526   EXPECT_EQ(
1527       MOJO_RESULT_OK,
1528       dp->ConsumerReadData(
1529           UserPointer<void>(read_buffer), MakeUserPointer(&num_bytes), false));
1530   EXPECT_EQ(10u, num_bytes);
1531   EXPECT_EQ(0, memcmp(read_buffer, &test_data[0], 10u));
1532
1533   // Check that a two-phase write can now only write (at most) 80 bytes. (This
1534   // checks an implementation detail; this behavior is not guaranteed, but we
1535   // need it for this test.)
1536   void* write_buffer_ptr = nullptr;
1537   num_bytes = 0u;
1538   EXPECT_EQ(MOJO_RESULT_OK,
1539             dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
1540                                        MakeUserPointer(&num_bytes),
1541                                        false));
1542   EXPECT_TRUE(write_buffer_ptr);
1543   EXPECT_EQ(80u, num_bytes);
1544   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(0u));
1545
1546   // Write as much data as we can (using |ProducerWriteData()|). We should write
1547   // 90 bytes.
1548   num_bytes = 200u;
1549   EXPECT_EQ(MOJO_RESULT_OK,
1550             dp->ProducerWriteData(UserPointer<const void>(&test_data[20]),
1551                                   MakeUserPointer(&num_bytes),
1552                                   false));
1553   EXPECT_EQ(90u, num_bytes);
1554
1555   // Check that a two-phase read can now only read (at most) 90 bytes. (This
1556   // checks an implementation detail; this behavior is not guaranteed, but we
1557   // need it for this test.)
1558   const void* read_buffer_ptr = nullptr;
1559   num_bytes = 0u;
1560   EXPECT_EQ(MOJO_RESULT_OK,
1561             dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
1562                                       MakeUserPointer(&num_bytes),
1563                                       false));
1564   EXPECT_TRUE(read_buffer_ptr);
1565   EXPECT_EQ(90u, num_bytes);
1566   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(0u));
1567
1568   // Read as much as possible (using |ConsumerReadData()|). We should read 100
1569   // bytes.
1570   num_bytes =
1571       static_cast<uint32_t>(arraysize(read_buffer) * sizeof(read_buffer[0]));
1572   memset(read_buffer, 0, num_bytes);
1573   EXPECT_EQ(
1574       MOJO_RESULT_OK,
1575       dp->ConsumerReadData(
1576           UserPointer<void>(read_buffer), MakeUserPointer(&num_bytes), false));
1577   EXPECT_EQ(100u, num_bytes);
1578   EXPECT_EQ(0, memcmp(read_buffer, &test_data[10], 100u));
1579
1580   dp->ProducerClose();
1581   dp->ConsumerClose();
1582 }
1583
1584 // Tests the behavior of closing the producer or consumer with respect to
1585 // writes and reads (simple and two-phase).
1586 TEST(LocalDataPipeTest, CloseWriteRead) {
1587   const char kTestData[] = "hello world";
1588   const uint32_t kTestDataSize = static_cast<uint32_t>(sizeof(kTestData));
1589
1590   const MojoCreateDataPipeOptions options = {
1591       kSizeOfOptions,                           // |struct_size|.
1592       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
1593       1u,                                       // |element_num_bytes|.
1594       1000u                                     // |capacity_num_bytes|.
1595   };
1596   MojoCreateDataPipeOptions validated_options = {0};
1597   EXPECT_EQ(MOJO_RESULT_OK,
1598             DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
1599                                             &validated_options));
1600
1601   // Close producer first, then consumer.
1602   {
1603     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
1604
1605     // Write some data, so we'll have something to read.
1606     uint32_t num_bytes = kTestDataSize;
1607     EXPECT_EQ(MOJO_RESULT_OK,
1608               dp->ProducerWriteData(UserPointer<const void>(kTestData),
1609                                     MakeUserPointer(&num_bytes),
1610                                     false));
1611     EXPECT_EQ(kTestDataSize, num_bytes);
1612
1613     // Write it again, so we'll have something left over.
1614     num_bytes = kTestDataSize;
1615     EXPECT_EQ(MOJO_RESULT_OK,
1616               dp->ProducerWriteData(UserPointer<const void>(kTestData),
1617                                     MakeUserPointer(&num_bytes),
1618                                     false));
1619     EXPECT_EQ(kTestDataSize, num_bytes);
1620
1621     // Start two-phase write.
1622     void* write_buffer_ptr = nullptr;
1623     num_bytes = 0u;
1624     EXPECT_EQ(MOJO_RESULT_OK,
1625               dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
1626                                          MakeUserPointer(&num_bytes),
1627                                          false));
1628     EXPECT_TRUE(write_buffer_ptr);
1629     EXPECT_GT(num_bytes, 0u);
1630
1631     // Start two-phase read.
1632     const void* read_buffer_ptr = nullptr;
1633     num_bytes = 0u;
1634     EXPECT_EQ(MOJO_RESULT_OK,
1635               dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
1636                                         MakeUserPointer(&num_bytes),
1637                                         false));
1638     EXPECT_TRUE(read_buffer_ptr);
1639     EXPECT_EQ(2u * kTestDataSize, num_bytes);
1640
1641     // Close the producer.
1642     dp->ProducerClose();
1643
1644     // The consumer can finish its two-phase read.
1645     EXPECT_EQ(0, memcmp(read_buffer_ptr, kTestData, kTestDataSize));
1646     EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(kTestDataSize));
1647
1648     // And start another.
1649     read_buffer_ptr = nullptr;
1650     num_bytes = 0u;
1651     EXPECT_EQ(MOJO_RESULT_OK,
1652               dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
1653                                         MakeUserPointer(&num_bytes),
1654                                         false));
1655     EXPECT_TRUE(read_buffer_ptr);
1656     EXPECT_EQ(kTestDataSize, num_bytes);
1657
1658     // Close the consumer, which cancels the two-phase read.
1659     dp->ConsumerClose();
1660   }
1661
1662   // Close consumer first, then producer.
1663   {
1664     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
1665
1666     // Write some data, so we'll have something to read.
1667     uint32_t num_bytes = kTestDataSize;
1668     EXPECT_EQ(MOJO_RESULT_OK,
1669               dp->ProducerWriteData(UserPointer<const void>(kTestData),
1670                                     MakeUserPointer(&num_bytes),
1671                                     false));
1672     EXPECT_EQ(kTestDataSize, num_bytes);
1673
1674     // Start two-phase write.
1675     void* write_buffer_ptr = nullptr;
1676     num_bytes = 0u;
1677     EXPECT_EQ(MOJO_RESULT_OK,
1678               dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
1679                                          MakeUserPointer(&num_bytes),
1680                                          false));
1681     EXPECT_TRUE(write_buffer_ptr);
1682     ASSERT_GT(num_bytes, kTestDataSize);
1683
1684     // Start two-phase read.
1685     const void* read_buffer_ptr = nullptr;
1686     num_bytes = 0u;
1687     EXPECT_EQ(MOJO_RESULT_OK,
1688               dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
1689                                         MakeUserPointer(&num_bytes),
1690                                         false));
1691     EXPECT_TRUE(read_buffer_ptr);
1692     EXPECT_EQ(kTestDataSize, num_bytes);
1693
1694     // Close the consumer.
1695     dp->ConsumerClose();
1696
1697     // Actually write some data. (Note: Premature freeing of the buffer would
1698     // probably only be detected under ASAN or similar.)
1699     memcpy(write_buffer_ptr, kTestData, kTestDataSize);
1700     // Note: Even though the consumer has been closed, ending the two-phase
1701     // write will report success.
1702     EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(kTestDataSize));
1703
1704     // But trying to write should result in failure.
1705     num_bytes = kTestDataSize;
1706     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
1707               dp->ProducerWriteData(UserPointer<const void>(kTestData),
1708                                     MakeUserPointer(&num_bytes),
1709                                     false));
1710
1711     // As will trying to start another two-phase write.
1712     write_buffer_ptr = nullptr;
1713     num_bytes = 0u;
1714     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
1715               dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
1716                                          MakeUserPointer(&num_bytes),
1717                                          false));
1718
1719     dp->ProducerClose();
1720   }
1721
1722   // Test closing the consumer first, then the producer, with an active
1723   // two-phase write.
1724   {
1725     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
1726
1727     // Start two-phase write.
1728     void* write_buffer_ptr = nullptr;
1729     uint32_t num_bytes = 0u;
1730     EXPECT_EQ(MOJO_RESULT_OK,
1731               dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
1732                                          MakeUserPointer(&num_bytes),
1733                                          false));
1734     EXPECT_TRUE(write_buffer_ptr);
1735     ASSERT_GT(num_bytes, kTestDataSize);
1736
1737     dp->ConsumerClose();
1738     dp->ProducerClose();
1739   }
1740
1741   // Test closing the producer and then trying to read (with no data).
1742   {
1743     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
1744
1745     // Write some data, so we'll have something to read.
1746     uint32_t num_bytes = kTestDataSize;
1747     EXPECT_EQ(MOJO_RESULT_OK,
1748               dp->ProducerWriteData(UserPointer<const void>(kTestData),
1749                                     MakeUserPointer(&num_bytes),
1750                                     false));
1751     EXPECT_EQ(kTestDataSize, num_bytes);
1752
1753     // Close the producer.
1754     dp->ProducerClose();
1755
1756     // Read that data.
1757     char buffer[1000];
1758     num_bytes = static_cast<uint32_t>(sizeof(buffer));
1759     EXPECT_EQ(
1760         MOJO_RESULT_OK,
1761         dp->ConsumerReadData(
1762             UserPointer<void>(buffer), MakeUserPointer(&num_bytes), false));
1763     EXPECT_EQ(kTestDataSize, num_bytes);
1764     EXPECT_EQ(0, memcmp(buffer, kTestData, kTestDataSize));
1765
1766     // A second read should fail.
1767     num_bytes = static_cast<uint32_t>(sizeof(buffer));
1768     EXPECT_EQ(
1769         MOJO_RESULT_FAILED_PRECONDITION,
1770         dp->ConsumerReadData(
1771             UserPointer<void>(buffer), MakeUserPointer(&num_bytes), false));
1772
1773     // A two-phase read should also fail.
1774     const void* read_buffer_ptr = nullptr;
1775     num_bytes = 0u;
1776     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
1777               dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
1778                                         MakeUserPointer(&num_bytes),
1779                                         false));
1780
1781     // Ditto for discard.
1782     num_bytes = 10u;
1783     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
1784               dp->ConsumerDiscardData(MakeUserPointer(&num_bytes), false));
1785
1786     dp->ConsumerClose();
1787   }
1788 }
1789
1790 TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) {
1791   const MojoCreateDataPipeOptions options = {
1792       kSizeOfOptions,                           // |struct_size|.
1793       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
1794       static_cast<uint32_t>(sizeof(int32_t)),   // |element_num_bytes|.
1795       10 * sizeof(int32_t)                      // |capacity_num_bytes|.
1796   };
1797   MojoCreateDataPipeOptions validated_options = {0};
1798   EXPECT_EQ(MOJO_RESULT_OK,
1799             DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
1800                                             &validated_options));
1801
1802   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
1803
1804   // No data.
1805   uint32_t num_bytes = 1000u;
1806   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1807   EXPECT_EQ(0u, num_bytes);
1808
1809   // Try "ending" a two-phase write when one isn't active.
1810   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
1811             dp->ProducerEndWriteData(1u * sizeof(int32_t)));
1812
1813   // Still no data.
1814   num_bytes = 1000u;
1815   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1816   EXPECT_EQ(0u, num_bytes);
1817
1818   // Try ending a two-phase write with an invalid amount (too much).
1819   num_bytes = 0u;
1820   void* write_ptr = nullptr;
1821   EXPECT_EQ(
1822       MOJO_RESULT_OK,
1823       dp->ProducerBeginWriteData(
1824           MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
1825   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
1826             dp->ProducerEndWriteData(num_bytes +
1827                                      static_cast<uint32_t>(sizeof(int32_t))));
1828
1829   // But the two-phase write still ended.
1830   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, dp->ProducerEndWriteData(0u));
1831
1832   // Still no data.
1833   num_bytes = 1000u;
1834   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1835   EXPECT_EQ(0u, num_bytes);
1836
1837   // Try ending a two-phase write with an invalid amount (not a multiple of the
1838   // element size).
1839   num_bytes = 0u;
1840   write_ptr = nullptr;
1841   EXPECT_EQ(
1842       MOJO_RESULT_OK,
1843       dp->ProducerBeginWriteData(
1844           MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
1845   EXPECT_GE(num_bytes, 1u);
1846   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dp->ProducerEndWriteData(1u));
1847
1848   // But the two-phase write still ended.
1849   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, dp->ProducerEndWriteData(0u));
1850
1851   // Still no data.
1852   num_bytes = 1000u;
1853   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1854   EXPECT_EQ(0u, num_bytes);
1855
1856   // Now write some data, so we'll be able to try reading.
1857   int32_t element = 123;
1858   num_bytes = 1u * sizeof(int32_t);
1859   EXPECT_EQ(MOJO_RESULT_OK,
1860             dp->ProducerWriteData(UserPointer<const void>(&element),
1861                                   MakeUserPointer(&num_bytes),
1862                                   false));
1863
1864   // One element available.
1865   num_bytes = 0u;
1866   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1867   EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
1868
1869   // Try "ending" a two-phase read when one isn't active.
1870   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
1871             dp->ConsumerEndReadData(1u * sizeof(int32_t)));
1872
1873   // Still one element available.
1874   num_bytes = 0u;
1875   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1876   EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
1877
1878   // Try ending a two-phase read with an invalid amount (too much).
1879   num_bytes = 0u;
1880   const void* read_ptr = nullptr;
1881   EXPECT_EQ(
1882       MOJO_RESULT_OK,
1883       dp->ConsumerBeginReadData(
1884           MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false));
1885   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
1886             dp->ConsumerEndReadData(num_bytes +
1887                                     static_cast<uint32_t>(sizeof(int32_t))));
1888
1889   // Still one element available.
1890   num_bytes = 0u;
1891   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1892   EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
1893
1894   // Try ending a two-phase read with an invalid amount (not a multiple of the
1895   // element size).
1896   num_bytes = 0u;
1897   read_ptr = nullptr;
1898   EXPECT_EQ(
1899       MOJO_RESULT_OK,
1900       dp->ConsumerBeginReadData(
1901           MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false));
1902   EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
1903   EXPECT_EQ(123, static_cast<const int32_t*>(read_ptr)[0]);
1904   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dp->ConsumerEndReadData(1u));
1905
1906   // Still one element available.
1907   num_bytes = 0u;
1908   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1909   EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
1910
1911   dp->ProducerClose();
1912   dp->ConsumerClose();
1913 }
1914
1915 // Tests that even with "may discard", the data won't change under a two-phase
1916 // read.
1917 // TODO(vtl): crbug.com/348644: We currently don't pass this. (There are two
1918 // related issues: First, we don't recognize that the data given to
1919 // |ConsumerBeginReadData()| isn't discardable until |ConsumerEndReadData()|,
1920 // and thus we erroneously allow |ProducerWriteData()| to succeed. Second, the
1921 // |ProducerWriteData()| then changes the data underneath the two-phase read.)
1922 TEST(LocalDataPipeTest, DISABLED_MayDiscardTwoPhaseConsistent) {
1923   const MojoCreateDataPipeOptions options = {
1924       kSizeOfOptions,                                  // |struct_size|.
1925       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD,  // |flags|.
1926       1,                                               // |element_num_bytes|.
1927       2                                                // |capacity_num_bytes|.
1928   };
1929   MojoCreateDataPipeOptions validated_options = {0};
1930   EXPECT_EQ(MOJO_RESULT_OK,
1931             DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
1932                                             &validated_options));
1933
1934   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
1935
1936   // Write some elements.
1937   char elements[2] = {'a', 'b'};
1938   uint32_t num_bytes = 2u;
1939   EXPECT_EQ(MOJO_RESULT_OK,
1940             dp->ProducerWriteData(UserPointer<const void>(elements),
1941                                   MakeUserPointer(&num_bytes),
1942                                   false));
1943   EXPECT_EQ(2u, num_bytes);
1944
1945   // Begin reading.
1946   const void* read_ptr = nullptr;
1947   num_bytes = 2u;
1948   EXPECT_EQ(
1949       MOJO_RESULT_OK,
1950       dp->ConsumerBeginReadData(
1951           MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false));
1952   EXPECT_EQ(2u, num_bytes);
1953   EXPECT_EQ('a', static_cast<const char*>(read_ptr)[0]);
1954   EXPECT_EQ('b', static_cast<const char*>(read_ptr)[1]);
1955
1956   // Try to write some more. But nothing should be discardable right now.
1957   elements[0] = 'x';
1958   elements[1] = 'y';
1959   num_bytes = 2u;
1960   // TODO(vtl): This should be:
1961   //  EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
1962   //            dp->ProducerWriteData(elements, &num_bytes, false));
1963   // but we incorrectly think that the bytes being read are discardable. Letting
1964   // this through reveals the significant consequence.
1965   EXPECT_EQ(MOJO_RESULT_OK,
1966             dp->ProducerWriteData(UserPointer<const void>(elements),
1967                                   MakeUserPointer(&num_bytes),
1968                                   false));
1969
1970   // Check that our read buffer hasn't changed underneath us.
1971   EXPECT_EQ('a', static_cast<const char*>(read_ptr)[0]);
1972   EXPECT_EQ('b', static_cast<const char*>(read_ptr)[1]);
1973
1974   // End reading.
1975   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(2u));
1976
1977   // Now writing should succeed.
1978   EXPECT_EQ(MOJO_RESULT_OK,
1979             dp->ProducerWriteData(UserPointer<const void>(elements),
1980                                   MakeUserPointer(&num_bytes),
1981                                   false));
1982
1983   // And if we read, we should get the new values.
1984   read_ptr = nullptr;
1985   num_bytes = 2u;
1986   EXPECT_EQ(
1987       MOJO_RESULT_OK,
1988       dp->ConsumerBeginReadData(
1989           MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false));
1990   EXPECT_EQ(2u, num_bytes);
1991   EXPECT_EQ('x', static_cast<const char*>(read_ptr)[0]);
1992   EXPECT_EQ('y', static_cast<const char*>(read_ptr)[1]);
1993
1994   // End reading.
1995   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(2u));
1996
1997   dp->ProducerClose();
1998   dp->ConsumerClose();
1999 }
2000
2001 }  // namespace
2002 }  // namespace system
2003 }  // namespace mojo