EDK: Add implementation of data pipe producer write threshold stuff.

mojo/public/c/system/tests/core_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file tests the C API.
 
 #include <string.h>
 
 #include "mojo/public/c/system/buffer.h"
 #include "mojo/public/c/system/data_pipe.h"
@@ skipping 212 matching lines @@
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
             MojoWait(hc, MOJO_HANDLE_SIGNAL_READABLE, 0, &state));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_NONE, state.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_READ_THRESHOLD,
             state.satisfiable_signals);
 
   // The producer |hp| should be writable.
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoWait(hp, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &state));
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, state.satisfied_signals);
-  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
+            state.satisfied_signals);
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
+                MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
             state.satisfiable_signals);
 
   // Try to read from |hc|.
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             MojoReadData(hc, buffer, &buffer_size, MOJO_READ_DATA_FLAG_NONE));
 
   // Try to begin a two-phase read from |hc|.
   read_pointer = nullptr;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
@@ skipping 63 matching lines @@
             MojoWait(hc, MOJO_HANDLE_SIGNAL_READABLE, 1000, &state));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals);
 
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(hc));
 
   // TODO(vtl): Test the other way around -- closing the consumer should make
   // the producer never-writable?
 }
 
+// TODO(vtl): Once thunks are in: TEST(CoreTest, DataPipeWriteThreshold) { ... }
+
 TEST(CoreTest, DataPipeReadThreshold) {
   MojoHandle hp = MOJO_HANDLE_INVALID;
   MojoHandle hc = MOJO_HANDLE_INVALID;
   EXPECT_EQ(MOJO_RESULT_OK, MojoCreateDataPipe(nullptr, &hp, &hc));
   EXPECT_NE(hp, MOJO_HANDLE_INVALID);
   EXPECT_NE(hc, MOJO_HANDLE_INVALID);
+  EXPECT_NE(hc, hp);
 
   MojoDataPipeConsumerOptions copts;
   static const uint32_t kCoptsSize = static_cast<uint32_t>(sizeof(copts));
 
   // Check the current read threshold; should be the default.
   memset(&copts, 255, kCoptsSize);
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoGetDataPipeConsumerOptions(hc, &copts, kCoptsSize));
   EXPECT_EQ(kCoptsSize, copts.struct_size);
   EXPECT_EQ(0u, copts.read_threshold_num_bytes);
@@ skipping 169 matching lines @@
 
 TEST(CoreTest, MinimalCppTest) {
   const char* failure = MinimalCppTest();
   EXPECT_FALSE(failure) << failure;
 }
 
 // TODO(vtl): Add multi-threaded tests.
 
 }  // namespace
 }  // namespace mojo