[mojo-edk] Add explicit message object APIs

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 309 matching lines @@
     // Note: This may return either |MOJO_RESULT_INVALID_ARGUMENT| or
     // |MOJO_RESULT_RESOURCE_EXHAUSTED|, depending on whether it's plausible or
     // not.
     ASSERT_NE(
         MOJO_RESULT_OK,
         core()->WriteMessage(h, nullptr, 0, handles,
                              std::numeric_limits<uint32_t>::max(),
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
     ASSERT_EQ(0u, info.GetWriteMessageCallCount());
 
+    // Null |bytes| with non-zero message size.
+    ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+              core()->WriteMessage(h, nullptr, 1, nullptr, 0,
+                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
+    ASSERT_EQ(0u, info.GetWriteMessageCallCount());
+
+    // Null |handles| with non-zero handle count.
+    ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+              core()->WriteMessage(h, nullptr, 0, nullptr, 1,
+                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
+    ASSERT_EQ(0u, info.GetWriteMessageCallCount());
+
     // Huge handle count (plausibly big).
     ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
               core()->WriteMessage(
                   h, nullptr, 0, handles,
                   std::numeric_limits<uint32_t>::max() / sizeof(handles[0]),
                   MOJO_WRITE_MESSAGE_FLAG_NONE));
     ASSERT_EQ(0u, info.GetWriteMessageCallCount());
 
     // Invalid handle in |handles|.
     ASSERT_EQ(
         MOJO_RESULT_INVALID_ARGUMENT,
         core()->WriteMessage(h, nullptr, 0, handles, 1,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
     ASSERT_EQ(0u, info.GetWriteMessageCallCount());
 
     // Two invalid handles in |handles|.
     ASSERT_EQ(
         MOJO_RESULT_INVALID_ARGUMENT,
         core()->WriteMessage(h, nullptr, 0, handles, 2,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
     ASSERT_EQ(0u, info.GetWriteMessageCallCount());
 
-    // Can't send a handle over itself.
+    // Can't send a handle over itself. Note that this will also cause |h| to be
+    // closed.
     handles[0] = h;
     ASSERT_EQ(
-        MOJO_RESULT_BUSY,
+        MOJO_RESULT_INVALID_ARGUMENT,
         core()->WriteMessage(h, nullptr, 0, handles, 1,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
     ASSERT_EQ(0u, info.GetWriteMessageCallCount());
 
+    h = CreateMockHandle(&info);
+
     MockHandleInfo info2;
-    MojoHandle h2 = CreateMockHandle(&info2);
 
     // This is "okay", but |MockDispatcher| doesn't implement it.
-    handles[0] = h2;
+    handles[0] = CreateMockHandle(&info2);
     ASSERT_EQ(
         MOJO_RESULT_UNIMPLEMENTED,
         core()->WriteMessage(h, nullptr, 0, handles, 1,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
     ASSERT_EQ(1u, info.GetWriteMessageCallCount());
 
     // One of the |handles| is still invalid.
+    handles[0] = CreateMockHandle(&info2);
     ASSERT_EQ(
         MOJO_RESULT_INVALID_ARGUMENT,
         core()->WriteMessage(h, nullptr, 0, handles, 2,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
     ASSERT_EQ(1u, info.GetWriteMessageCallCount());
 
-    // One of the |handles| is the same as |handle|.
+    // One of the |handles| is the same as |h|. Both handles are closed.
+    handles[0] = CreateMockHandle(&info2);
     handles[1] = h;
     ASSERT_EQ(
+        MOJO_RESULT_INVALID_ARGUMENT,
+        core()->WriteMessage(h, nullptr, 0, handles, 2,
+                             MOJO_WRITE_MESSAGE_FLAG_NONE));
+    ASSERT_EQ(1u, info.GetWriteMessageCallCount());
+
+    h = CreateMockHandle(&info);
+
+    // Can't send a handle twice in the same message.
+    handles[0] = CreateMockHandle(&info2);
+    handles[1] = handles[0];
+    ASSERT_EQ(
         MOJO_RESULT_BUSY,
         core()->WriteMessage(h, nullptr, 0, handles, 2,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
     ASSERT_EQ(1u, info.GetWriteMessageCallCount());
 
-    // Can't send a handle twice in the same message.
-    handles[1] = h2;
-    ASSERT_EQ(
-        MOJO_RESULT_BUSY,
-        core()->WriteMessage(h, nullptr, 0, handles, 2,
-                             MOJO_WRITE_MESSAGE_FLAG_NONE));
-    ASSERT_EQ(1u, info.GetWriteMessageCallCount());
-
-    // Note: Since we never successfully sent anything with it, |h2| should
-    // still be valid.
-    ASSERT_EQ(MOJO_RESULT_OK, core()->Close(h2));
-
     ASSERT_EQ(MOJO_RESULT_OK, core()->Close(h));
   }
 
   // |ReadMessage()|:
   // Only check arguments checked by |Core|, namely |handle|, |handles|, and
   // |num_handles|.
   {
     ASSERT_EQ(
         MOJO_RESULT_INVALID_ARGUMENT,
         core()->ReadMessage(MOJO_HANDLE_INVALID, nullptr, nullptr, nullptr,
@@ skipping 47 matching lines @@
         core()->CreateMessagePipe(nullptr, nullptr, nullptr),
         kMemoryCheckFailedRegex);
     ASSERT_DEATH_IF_SUPPORTED(
         core()->CreateMessagePipe(nullptr, &h, nullptr),
         kMemoryCheckFailedRegex);
     ASSERT_DEATH_IF_SUPPORTED(
         core()->CreateMessagePipe(nullptr, nullptr, &h),
         kMemoryCheckFailedRegex);
   }
 
-  // |WriteMessage()|:
-  // Only check arguments checked by |Core|, namely |handle|, |handles|, and
-  // |num_handles|.
-  {
-    MockHandleInfo info;
-    MojoHandle h = CreateMockHandle(&info);
-
-    // Null |handles| with nonzero |num_handles|.
-    ASSERT_DEATH_IF_SUPPORTED(
-        core()->WriteMessage(h, nullptr, 0, nullptr, 1,
-                             MOJO_WRITE_MESSAGE_FLAG_NONE),
-        kMemoryCheckFailedRegex);
-
-    ASSERT_EQ(MOJO_RESULT_OK, core()->Close(h));
-  }
-
   // |ReadMessage()|:
   // Only check arguments checked by |Core|, namely |handle|, |handles|, and
   // |num_handles|.
   {
     MockHandleInfo info;
     MojoHandle h = CreateMockHandle(&info);
 
     uint32_t handle_count = 1;
     ASSERT_DEATH_IF_SUPPORTED(
         core()->ReadMessage(h, nullptr, nullptr, nullptr, &handle_count,
@@ skipping 213 matching lines @@
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->ReadMessage(
                 h_passing[1], buffer, &num_bytes, handles, &num_handles,
                 MOJO_READ_MESSAGE_FLAG_NONE));
   ASSERT_EQ(kHelloSize, num_bytes);
   ASSERT_STREQ(kHello, buffer);
   ASSERT_EQ(0u, num_handles);
 
   // Make sure that you can't pass either of the message pipe's handles over
   // itself.
-  ASSERT_EQ(MOJO_RESULT_BUSY,
+  ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             core()->WriteMessage(h_passing[0], kHello, kHelloSize,
                                  &h_passing[0], 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
+  ASSERT_EQ(MOJO_RESULT_OK,
+            core()->CreateMessagePipe(nullptr, &h_passing[0], &h_passing[1]));
+
   ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             core()->WriteMessage(h_passing[0], kHello, kHelloSize,
                                  &h_passing[1], 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
+  ASSERT_EQ(MOJO_RESULT_OK,
+            core()->CreateMessagePipe(nullptr, &h_passing[0], &h_passing[1]));
 
   MojoHandle h_passed[2];
   MojoCreateMessagePipeOptions options;
   options.struct_size = sizeof(MojoCreateMessagePipeOptions);
   options.flags = MOJO_CREATE_MESSAGE_PIPE_OPTIONS_FLAG_TRANSFERABLE;
   ASSERT_EQ(MOJO_RESULT_OK,
             core()->CreateMessagePipe(&options, &h_passed[0], &h_passed[1]));
 
   // Make sure that |h_passed[]| work properly.
   ASSERT_EQ(MOJO_RESULT_OK,
@@ skipping 528 matching lines @@
   ASSERT_EQ(MOJO_RESULT_BUSY, waiter.result);
 
   ASSERT_EQ(MOJO_RESULT_OK, core()->Close(h));
 }
 
 // TODO(vtl): Test |DuplicateBufferHandle()| and |MapBuffer()|.
 
 }  // namespace
 }  // namespace edk
 }  // namespace mojo