Add Core methods for wait set.

mojo/edk/system/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.
 
 #include "mojo/edk/system/core.h"
 
 #include <stdint.h>
 
 #include <limits>
 
@@ skipping 135 matching lines @@
   EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
             core()->GetBufferInformation(h, NullUserPointer(), 0));
   EXPECT_EQ(1u, info.GetGetBufferInformationCallCount());
 
   EXPECT_EQ(0u, info.GetMapBufferCallCount());
   EXPECT_EQ(
       MOJO_RESULT_UNIMPLEMENTED,
       core()->MapBuffer(h, 0, 0, NullUserPointer(), MOJO_MAP_BUFFER_FLAG_NONE));
   EXPECT_EQ(1u, info.GetMapBufferCallCount());
 
+  EXPECT_EQ(0u, info.GetWaitSetAddCallCount());
+  EXPECT_EQ(
+      MOJO_RESULT_UNIMPLEMENTED,
+      core()->WaitSetAdd(h, h, MOJO_HANDLE_SIGNAL_NONE, 0, NullUserPointer()));
+  EXPECT_EQ(1u, info.GetWaitSetAddCallCount());
+
+  EXPECT_EQ(0u, info.GetWaitSetRemoveCallCount());
+  EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, core()->WaitSetRemove(h, 0));
+  EXPECT_EQ(1u, info.GetWaitSetRemoveCallCount());
+
+  EXPECT_EQ(0u, info.GetWaitSetWaitCallCount());
+  EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
+            core()->WaitSetWait(h, MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
+                                NullUserPointer(), NullUserPointer()));
+  EXPECT_EQ(1u, info.GetWaitSetWaitCallCount());
+
   EXPECT_EQ(0u, info.GetAddAwakableCallCount());
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE,
                          NullUserPointer()));
   EXPECT_EQ(1u, info.GetAddAwakableCallCount());
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 0, NullUserPointer()));
   EXPECT_EQ(2u, info.GetAddAwakableCallCount());
   MojoHandleSignalsState hss = kFullMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
@@ skipping 471 matching lines @@
       core()->GetBufferInformation(MOJO_HANDLE_INVALID, NullUserPointer(), 0u));
 
   // |MapBuffer()|:
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             core()->MapBuffer(MOJO_HANDLE_INVALID, 0u, 0u, NullUserPointer(),
                               MOJO_MAP_BUFFER_FLAG_NONE));
 
   // |UnmapBuffer()|:
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             core()->UnmapBuffer(NullUserPointer()));
+
+  // |WaitSetAdd()|:
+  {
+    MockHandleInfo info;
+    MojoHandle h = CreateMockHandle(&info);
+
+    EXPECT_EQ(
+        MOJO_RESULT_INVALID_ARGUMENT,
+        core()->WaitSetAdd(MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID,
+                           MOJO_HANDLE_SIGNAL_NONE, 0, NullUserPointer()));
+    EXPECT_EQ(
+        MOJO_RESULT_INVALID_ARGUMENT,
+        core()->WaitSetAdd(MOJO_HANDLE_INVALID, h, MOJO_HANDLE_SIGNAL_NONE, 0,
+                           NullUserPointer()));
+    EXPECT_EQ(
+        MOJO_RESULT_INVALID_ARGUMENT,
+        core()->WaitSetAdd(h, MOJO_HANDLE_INVALID, MOJO_HANDLE_SIGNAL_NONE, 0,
+                           NullUserPointer()));
+
+    EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
+  }
+
+  // |WaitSetRemove()|:
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            core()->WaitSetRemove(MOJO_HANDLE_INVALID, 0));
+
+  // |WaitSetWait()|:
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            core()->WaitSetWait(MOJO_HANDLE_INVALID, MOJO_DEADLINE_INDEFINITE,
+                                NullUserPointer(), NullUserPointer(),
+                                NullUserPointer()));
 }
 
 // These test invalid arguments that should cause death if we're being paranoid
 // about checking arguments (which we would want to do if, e.g., we were in a
 // true "kernel" situation, but we might not want to do otherwise for
 // performance reasons). Probably blatant errors like passing in null pointers
 // (for required pointer arguments) will still cause death, but perhaps not
 // predictably.
 TEST_F(CoreTest, InvalidArgumentsDeath) {
   const char kMemoryCheckFailedRegex[] = "Check failed";
@@ skipping 92 matching lines @@
     EXPECT_DEATH_IF_SUPPORTED(
         core()->ReadMessage(h, NullUserPointer(), NullUserPointer(),
                             NullUserPointer(), MakeUserPointer(&handle_count),
                             MOJO_READ_MESSAGE_FLAG_NONE),
         kMemoryCheckFailedRegex);
 
     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
   }
 
   // TODO(vtl): Missing a bunch here.
+
+  // |CreateWaitSet()|:
+  {
+    EXPECT_DEATH_IF_SUPPORTED(
+        core()->CreateWaitSet(NullUserPointer(), NullUserPointer()),
+        kMemoryCheckFailedRegex);
+  }
 }
 
 // TODO(vtl): test |Wait()| and |WaitMany()| properly
 //  - including |WaitMany()| with the same handle more than once (with
 //    same/different signals)
 
 TEST_F(CoreTest, MessagePipe) {
   MojoHandle h[2] = {MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID};
   MojoHandleSignalsState hss[2];
   uint32_t result_index;
@@ skipping 1187 matching lines @@
   info.GetAddedAwakableAt(0)->Awake(0, Awakable::AwakeReason::UNSATISFIABLE,
                                     HandleSignalsState());
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, waiter.result);
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
 }
 
 // TODO(vtl): Test |CreateSharedBuffer()|, |DuplicateBufferHandle()|, and
 // |MapBuffer()|.
 
+TEST_F(CoreTest, WaitSet) {
+  MojoHandle h = MOJO_HANDLE_INVALID;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            core()->CreateWaitSet(NullUserPointer(), MakeUserPointer(&h)));
+  EXPECT_NE(h, MOJO_HANDLE_INVALID);
+
+  MockHandleInfo info;
+  info.AllowAddAwakable(true);
+  MojoHandle h_member = CreateMockHandle(&info);
+
+  EXPECT_EQ(0u, info.GetAddAwakableCallCount());
+  EXPECT_EQ(MOJO_RESULT_OK,
+            core()->WaitSetAdd(h, h_member, MOJO_HANDLE_SIGNAL_READABLE, 123,
+                               NullUserPointer()));
+  EXPECT_EQ(1u, info.GetAddAwakableCallCount());
+
+  EXPECT_EQ(0u, info.GetRemoveAwakableCallCount());
+  EXPECT_EQ(MOJO_RESULT_OK, core()->WaitSetRemove(h, 123));
+  EXPECT_EQ(1u, info.GetRemoveAwakableCallCount());
+
+  EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_member));
+
+  uint32_t num_results = 5;
+  MojoWaitSetResult results[5] = {};
+  EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
+            core()->WaitSetWait(h, static_cast<MojoDeadline>(0),
+                                MakeUserPointer(&num_results),
+                                MakeUserPointer(results), NullUserPointer()));
+
+  EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
+}
+
 }  // namespace
 }  // namespace system
 }  // namespace mojo