EDK: Add Core::GetRights().

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 26 matching lines @@
 }
 
 TEST_F(CoreTest, Basic) {
   MockHandleInfo info;
 
   EXPECT_EQ(0u, info.GetCtorCallCount());
   MojoHandle h = CreateMockHandle(&info);
   EXPECT_EQ(1u, info.GetCtorCallCount());
   EXPECT_NE(h, MOJO_HANDLE_INVALID);
 
+  MojoHandleRights rights = 0;
+  EXPECT_EQ(MOJO_RESULT_OK, core()->GetRights(h, MakeUserPointer(&rights)));
+  EXPECT_EQ(kDefaultMockHandleRights, rights);
+
   EXPECT_EQ(0u, info.GetWriteMessageCallCount());
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->WriteMessage(h, NullUserPointer(), 0, NullUserPointer(), 0,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   EXPECT_EQ(1u, info.GetWriteMessageCallCount());
 
   EXPECT_EQ(0u, info.GetReadMessageCallCount());
   uint32_t num_bytes = 0;
   EXPECT_EQ(
       MOJO_RESULT_OK,
@@ skipping 140 matching lines @@
 
     // Test a double-close.
     MockHandleInfo info;
     MojoHandle h = CreateMockHandle(&info);
     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
     EXPECT_EQ(1u, info.GetCloseCallCount());
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(h));
     EXPECT_EQ(1u, info.GetCloseCallCount());
   }
 
+  // |GetRights()|:
+  {
+    MojoHandleRights rights = 0;
+    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+              core()->GetRights(MOJO_HANDLE_INVALID, MakeUserPointer(&rights)));
+    EXPECT_EQ(0u, rights);
+    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+              core()->GetRights(10, MakeUserPointer(&rights)));
+    EXPECT_EQ(0u, rights);
+  }
+
   // |Wait()|:
   {
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->Wait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE,
                            MOJO_DEADLINE_INDEFINITE, NullUserPointer()));
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               core()->Wait(10, ~MOJO_HANDLE_SIGNAL_NONE,
                            MOJO_DEADLINE_INDEFINITE, NullUserPointer()));
 
     MojoHandleSignalsState hss = kFullMojoHandleSignalsState;
@@ skipping 332 matching lines @@
 
 // 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";
 
+  // |GetRights()|:
+  {
+    MockHandleInfo info;
+    MojoHandle h = CreateMockHandle(&info);
+    EXPECT_DEATH_IF_SUPPORTED(core()->GetRights(h, NullUserPointer()),
+                              kMemoryCheckFailedRegex);
+
+    EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
+  }
+
   // |WaitMany()|:
   {
     MojoHandle handle = MOJO_HANDLE_INVALID;
     MojoHandleSignals signals = ~MOJO_HANDLE_SIGNAL_NONE;
     EXPECT_DEATH_IF_SUPPORTED(
         core()->WaitMany(NullUserPointer(), MakeUserPointer(&signals), 1,
                          MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
                          NullUserPointer()),
         kMemoryCheckFailedRegex);
     EXPECT_DEATH_IF_SUPPORTED(
@@ skipping 56 matching lines @@
   }
 
   // TODO(vtl): Missing a bunch here.
 }
 
 // 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];
+  MojoHandle h[2] = {MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID};
   MojoHandleSignalsState hss[2];
   uint32_t result_index;
 
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->CreateMessagePipe(NullUserPointer(), MakeUserPointer(&h[0]),
                                       MakeUserPointer(&h[1])));
   // Should get two distinct, valid handles.
   EXPECT_NE(h[0], MOJO_HANDLE_INVALID);
   EXPECT_NE(h[1], MOJO_HANDLE_INVALID);
   EXPECT_NE(h[0], h[1]);
 
+  // Both should have the correct rights.
+  static const MojoHandleRights kMessagePipeHandleRights =
+      MOJO_HANDLE_RIGHT_TRANSFER | MOJO_HANDLE_RIGHT_READ |
+      MOJO_HANDLE_RIGHT_WRITE | MOJO_HANDLE_RIGHT_GET_OPTIONS |
+      MOJO_HANDLE_RIGHT_SET_OPTIONS;
+  MojoHandleRights rights = MOJO_HANDLE_RIGHT_NONE;
+  EXPECT_EQ(MOJO_RESULT_OK, core()->GetRights(h[0], MakeUserPointer(&rights)));
+  EXPECT_EQ(kMessagePipeHandleRights, rights);
+  rights = MOJO_HANDLE_RIGHT_NONE;
+  EXPECT_EQ(MOJO_RESULT_OK, core()->GetRights(h[1], MakeUserPointer(&rights)));
+  EXPECT_EQ(kMessagePipeHandleRights, rights);
+
   // Neither should be readable.
   MojoHandleSignals signals[2] = {MOJO_HANDLE_SIGNAL_READABLE,
                                   MOJO_HANDLE_SIGNAL_READABLE};
   result_index = static_cast<uint32_t>(-1);
   hss[0] = kEmptyMojoHandleSignalsState;
   hss[1] = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(
       MOJO_RESULT_DEADLINE_EXCEEDED,
       core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2, 0,
                        MakeUserPointer(&result_index), MakeUserPointer(hss)));
@@ skipping 312 matching lines @@
   EXPECT_STREQ(kHello, buffer);
   EXPECT_EQ(0u, num_handles);
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[0]));
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[1]));
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passed[0]));
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_received));
 }
 
 TEST_F(CoreTest, DataPipe) {
-  MojoHandle ph, ch;  // p is for producer and c is for consumer.
+  // p is for producer and c is for consumer.
+  MojoHandle ph = MOJO_HANDLE_INVALID;
+  MojoHandle ch = MOJO_HANDLE_INVALID;
   MojoHandleSignalsState hss;
 
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->CreateDataPipe(NullUserPointer(), MakeUserPointer(&ph),
                                    MakeUserPointer(&ch)));
   // Should get two distinct, valid handles.
   EXPECT_NE(ph, MOJO_HANDLE_INVALID);
   EXPECT_NE(ch, MOJO_HANDLE_INVALID);
   EXPECT_NE(ph, ch);
 
+  // Both should have the correct rights.
+  static const MojoHandleRights kDataPipeProducerHandleRights =
+      MOJO_HANDLE_RIGHT_TRANSFER | MOJO_HANDLE_RIGHT_WRITE |
+      MOJO_HANDLE_RIGHT_GET_OPTIONS | MOJO_HANDLE_RIGHT_SET_OPTIONS;
+  static const MojoHandleRights kDataPipeConsumerHandleRights =
+      MOJO_HANDLE_RIGHT_TRANSFER | MOJO_HANDLE_RIGHT_READ |
+      MOJO_HANDLE_RIGHT_GET_OPTIONS | MOJO_HANDLE_RIGHT_SET_OPTIONS;
+  MojoHandleRights rights = MOJO_HANDLE_RIGHT_NONE;
+  EXPECT_EQ(MOJO_RESULT_OK, core()->GetRights(ph, MakeUserPointer(&rights)));
+  EXPECT_EQ(kDataPipeProducerHandleRights, rights);
+  rights = MOJO_HANDLE_RIGHT_NONE;
+  EXPECT_EQ(MOJO_RESULT_OK, core()->GetRights(ch, MakeUserPointer(&rights)));
+  EXPECT_EQ(kDataPipeConsumerHandleRights, rights);
+
   // Producer should be never-readable, but already writable.
   hss = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(
       MOJO_RESULT_FAILED_PRECONDITION,
       core()->Wait(ph, MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss)));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
             hss.satisfiable_signals);
@@ skipping 674 matching lines @@
                                                 waiter.Awake(result);
                                               }));
   EXPECT_EQ(1u, info.GetAddedAwakableSize());
 
   EXPECT_FALSE(info.GetAddedAwakableAt(0)->Awake(MOJO_RESULT_BUSY, 0));
   EXPECT_EQ(MOJO_RESULT_BUSY, waiter.result);
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
 }
 
-// TODO(vtl): Test |DuplicateBufferHandle()| and |MapBuffer()|.
+// TODO(vtl): Test |CreateSharedBuffer()|, |DuplicateBufferHandle()|, and
+// |MapBuffer()|.
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo