src/mojo/system/core_impl_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/core_impl.h"
   6
   7 #include "mojo/system/core_test_base.h"
   8
   9 namespace mojo {
  10 namespace system {
  11 namespace {
  12
  13 class CoreImplTest : public test::CoreTestBase {
  14 };
  15
  16 TEST_F(CoreImplTest, Basic) {
  17   MockHandleInfo info;
  18
  19   EXPECT_EQ(0u, info.GetCtorCallCount());
  20   MojoHandle h = CreateMockHandle(&info);
  21   EXPECT_EQ(1u, info.GetCtorCallCount());
  22   EXPECT_NE(h, MOJO_HANDLE_INVALID);
  23
  24   EXPECT_EQ(0u, info.GetWriteMessageCallCount());
  25   EXPECT_EQ(MOJO_RESULT_OK,
  26             core()->WriteMessage(h, NULL, 0, NULL, 0,
  27                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
  28   EXPECT_EQ(1u, info.GetWriteMessageCallCount());
  29   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  30             core()->WriteMessage(h, NULL, 1, NULL, 0,
  31                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
  32   EXPECT_EQ(2u, info.GetWriteMessageCallCount());
  33
  34   EXPECT_EQ(0u, info.GetReadMessageCallCount());
  35   uint32_t num_bytes = 0;
  36   EXPECT_EQ(MOJO_RESULT_OK,
  37             core()->ReadMessage(h, NULL, &num_bytes, NULL, NULL,
  38                                 MOJO_READ_MESSAGE_FLAG_NONE));
  39   EXPECT_EQ(1u, info.GetReadMessageCallCount());
  40   num_bytes = 1;
  41   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  42             core()->ReadMessage(h, NULL, &num_bytes, NULL, NULL,
  43                                 MOJO_READ_MESSAGE_FLAG_NONE));
  44   EXPECT_EQ(2u, info.GetReadMessageCallCount());
  45
  46   EXPECT_EQ(0u, info.GetAddWaiterCallCount());
  47   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
  48             core()->Wait(h, MOJO_WAIT_FLAG_EVERYTHING,
  49                          MOJO_DEADLINE_INDEFINITE));
  50   EXPECT_EQ(1u, info.GetAddWaiterCallCount());
  51   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
  52             core()->Wait(h, MOJO_WAIT_FLAG_EVERYTHING, 0));
  53   EXPECT_EQ(2u, info.GetAddWaiterCallCount());
  54   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
  55             core()->Wait(h, MOJO_WAIT_FLAG_EVERYTHING, 10 * 1000));
  56   EXPECT_EQ(3u, info.GetAddWaiterCallCount());
  57   MojoWaitFlags wait_flags = MOJO_WAIT_FLAG_EVERYTHING;
  58   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
  59             core()->WaitMany(&h, &wait_flags, 1, MOJO_DEADLINE_INDEFINITE));
  60   EXPECT_EQ(4u, info.GetAddWaiterCallCount());
  61
  62   EXPECT_EQ(0u, info.GetDtorCallCount());
  63   EXPECT_EQ(0u, info.GetCloseCallCount());
  64   EXPECT_EQ(0u, info.GetCancelAllWaitersCallCount());
  65   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
  66   EXPECT_EQ(1u, info.GetCancelAllWaitersCallCount());
  67   EXPECT_EQ(1u, info.GetCloseCallCount());
  68   EXPECT_EQ(1u, info.GetDtorCallCount());
  69
  70   // No waiters should ever have ever been added.
  71   EXPECT_EQ(0u, info.GetRemoveWaiterCallCount());
  72 }
  73
  74 TEST_F(CoreImplTest, InvalidArguments) {
  75   // |Close()|:
  76   {
  77     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(MOJO_HANDLE_INVALID));
  78     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(10));
  79     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(1000000000));
  80
  81     // Test a double-close.
  82     MockHandleInfo info;
  83     MojoHandle h = CreateMockHandle(&info);
  84     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h));
  85     EXPECT_EQ(1u, info.GetCloseCallCount());
  86     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(h));
  87     EXPECT_EQ(1u, info.GetCloseCallCount());
  88   }
  89
  90   // |Wait()|:
  91   {
  92     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  93               core()->Wait(MOJO_HANDLE_INVALID, MOJO_WAIT_FLAG_EVERYTHING,
  94                            MOJO_DEADLINE_INDEFINITE));
  95     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  96               core()->Wait(10, MOJO_WAIT_FLAG_EVERYTHING,
  97                            MOJO_DEADLINE_INDEFINITE));
  98   }
  99
 100   // |WaitMany()|:
 101   {
 102     MojoHandle handles[2] = { MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID };
 103     MojoWaitFlags flags[2] = { MOJO_WAIT_FLAG_EVERYTHING,
 104                                MOJO_WAIT_FLAG_EVERYTHING };
 105     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 106               core()->WaitMany(handles, flags, 0, MOJO_DEADLINE_INDEFINITE));
 107     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 108               core()->WaitMany(NULL, flags, 0, MOJO_DEADLINE_INDEFINITE));
 109     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 110               core()->WaitMany(handles, NULL, 0, MOJO_DEADLINE_INDEFINITE));
 111
 112     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 113               core()->WaitMany(NULL, flags, 1, MOJO_DEADLINE_INDEFINITE));
 114     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 115               core()->WaitMany(handles, NULL, 1, MOJO_DEADLINE_INDEFINITE));
 116     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 117               core()->WaitMany(handles, flags, 1, MOJO_DEADLINE_INDEFINITE));
 118
 119     MockHandleInfo info[2];
 120     handles[0] = CreateMockHandle(&info[0]);
 121
 122     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 123               core()->WaitMany(handles, flags, 1, MOJO_DEADLINE_INDEFINITE));
 124     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 125               core()->WaitMany(handles, flags, 2, MOJO_DEADLINE_INDEFINITE));
 126     handles[1] = handles[0] + 1;  // Invalid handle.
 127     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 128               core()->WaitMany(handles, flags, 2, MOJO_DEADLINE_INDEFINITE));
 129     handles[1] = CreateMockHandle(&info[1]);
 130     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 131               core()->WaitMany(handles, flags, 2, MOJO_DEADLINE_INDEFINITE));
 132
 133     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(handles[0]));
 134     EXPECT_EQ(MOJO_RESULT_OK, core()->Close(handles[1]));
 135   }
 136 }
 137
 138 // TODO(vtl): test |Wait()| and |WaitMany()| properly
 139 //  - including |WaitMany()| with the same handle more than once (with
 140 //    same/different flags)
 141
 142 TEST_F(CoreImplTest, MessagePipe) {
 143   MojoHandle h[2];
 144
 145   EXPECT_EQ(MOJO_RESULT_OK, core()->CreateMessagePipe(&h[0], &h[1]));
 146   // Should get two distinct, valid handles.
 147   EXPECT_NE(h[0], MOJO_HANDLE_INVALID);
 148   EXPECT_NE(h[1], MOJO_HANDLE_INVALID);
 149   EXPECT_NE(h[0], h[1]);
 150
 151   // Neither should be readable.
 152   MojoWaitFlags flags[2] = { MOJO_WAIT_FLAG_READABLE, MOJO_WAIT_FLAG_READABLE };
 153   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
 154             core()->WaitMany(h, flags, 2, 0));
 155
 156   // Try to read anyway.
 157   char buffer[1] = { 'a' };
 158   uint32_t buffer_size = 1;
 159   EXPECT_EQ(MOJO_RESULT_NOT_FOUND,
 160             core()->ReadMessage(h[0], buffer, &buffer_size, NULL, NULL,
 161                                 MOJO_READ_MESSAGE_FLAG_NONE));
 162   // Check that it left its inputs alone.
 163   EXPECT_EQ('a', buffer[0]);
 164   EXPECT_EQ(1u, buffer_size);
 165
 166   // Both should be writable.
 167   EXPECT_EQ(MOJO_RESULT_OK,
 168             core()->Wait(h[0], MOJO_WAIT_FLAG_WRITABLE, 1000000000));
 169   EXPECT_EQ(MOJO_RESULT_OK,
 170             core()->Wait(h[1], MOJO_WAIT_FLAG_WRITABLE, 1000000000));
 171
 172   // Also check that |h[1]| is writable using |WaitMany()|.
 173   flags[0] = MOJO_WAIT_FLAG_READABLE;
 174   flags[1] = MOJO_WAIT_FLAG_WRITABLE;
 175   EXPECT_EQ(1, core()->WaitMany(h, flags, 2, MOJO_DEADLINE_INDEFINITE));
 176
 177   // Write to |h[1]|.
 178   buffer[0] = 'b';
 179   EXPECT_EQ(MOJO_RESULT_OK,
 180             core()->WriteMessage(h[1], buffer, 1, NULL, 0,
 181                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 182
 183   // Check that |h[0]| is now readable.
 184   flags[0] = MOJO_WAIT_FLAG_READABLE;
 185   flags[1] = MOJO_WAIT_FLAG_READABLE;
 186   EXPECT_EQ(0, core()->WaitMany(h, flags, 2, MOJO_DEADLINE_INDEFINITE));
 187
 188   // Read from |h[0]|.
 189   // First, get only the size.
 190   buffer_size = 0;
 191   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
 192             core()->ReadMessage(h[0], NULL, &buffer_size, NULL, NULL,
 193                                 MOJO_READ_MESSAGE_FLAG_NONE));
 194   EXPECT_EQ(1u, buffer_size);
 195   // Then actually read it.
 196   buffer[0] = 'c';
 197   buffer_size = 1;
 198   EXPECT_EQ(MOJO_RESULT_OK,
 199             core()->ReadMessage(h[0], buffer, &buffer_size, NULL, NULL,
 200                                 MOJO_READ_MESSAGE_FLAG_NONE));
 201   EXPECT_EQ('b', buffer[0]);
 202   EXPECT_EQ(1u, buffer_size);
 203
 204   // |h[0]| should no longer be readable.
 205   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
 206             core()->Wait(h[0], MOJO_WAIT_FLAG_READABLE, 0));
 207
 208   // Write to |h[0]|.
 209   buffer[0] = 'd';
 210   EXPECT_EQ(MOJO_RESULT_OK,
 211             core()->WriteMessage(h[0], buffer, 1, NULL, 0,
 212                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 213
 214   // Close |h[0]|.
 215   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[0]));
 216
 217   // Check that |h[1]| is no longer writable (and will never be).
 218   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 219             core()->Wait(h[1], MOJO_WAIT_FLAG_WRITABLE, 1000000000));
 220
 221   // Check that |h[1]| is still readable (for the moment).
 222   EXPECT_EQ(MOJO_RESULT_OK,
 223             core()->Wait(h[1], MOJO_WAIT_FLAG_READABLE, 1000000000));
 224
 225   // Discard a message from |h[1]|.
 226   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
 227             core()->ReadMessage(h[1], NULL, NULL, NULL, NULL,
 228                                 MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
 229
 230   // |h[1]| is no longer readable (and will never be).
 231   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 232             core()->Wait(h[1], MOJO_WAIT_FLAG_READABLE, 1000000000));
 233
 234   // Try writing to |h[1]|.
 235   buffer[0] = 'e';
 236   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
 237             core()->WriteMessage(h[1], buffer, 1, NULL, 0,
 238                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 239
 240   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[1]));
 241 }
 242
 243 }  // namespace
 244 }  // namespace system
 245 }  // namespace mojo