| OLD | NEW |
|---|
| (Empty) |
| 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 <limits> | |
| 8 | |
| 9 #include "base/basictypes.h" | |
| 10 #include "base/threading/platform_thread.h" | |
| 11 #include "base/time/time.h" | |
| 12 #include "mojo/system/core_test_base.h" | |
| 13 | |
| 14 namespace mojo { | |
| 15 namespace system { | |
| 16 namespace { | |
| 17 | |
| 18 typedef test::CoreTestBase CoreImplTest; | |
| 19 | |
| 20 TEST_F(CoreImplTest, GetTimeTicksNow) { | |
| 21 const MojoTimeTicks start = core()->GetTimeTicksNow(); | |
| 22 EXPECT_NE(static_cast<MojoTimeTicks>(0), start) | |
| 23 << "GetTimeTicksNow should return nonzero value"; | |
| 24 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(15)); | |
| 25 const MojoTimeTicks finish = core()->GetTimeTicksNow(); | |
| 26 // Allow for some fuzz in sleep. | |
| 27 EXPECT_GE((finish - start), static_cast<MojoTimeTicks>(8000)) | |
| 28 << "Sleeping should result in increasing time ticks"; | |
| 29 } | |
| 30 | |
| 31 TEST_F(CoreImplTest, Basic) { | |
| 32 MockHandleInfo info; | |
| 33 | |
| 34 EXPECT_EQ(0u, info.GetCtorCallCount()); | |
| 35 MojoHandle h = CreateMockHandle(&info); | |
| 36 EXPECT_EQ(1u, info.GetCtorCallCount()); | |
| 37 EXPECT_NE(h, MOJO_HANDLE_INVALID); | |
| 38 | |
| 39 EXPECT_EQ(0u, info.GetWriteMessageCallCount()); | |
| 40 EXPECT_EQ(MOJO_RESULT_OK, | |
| 41 core()->WriteMessage(h, NULL, 0, NULL, 0, | |
| 42 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 43 EXPECT_EQ(1u, info.GetWriteMessageCallCount()); | |
| 44 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 45 core()->WriteMessage(h, NULL, 1, NULL, 0, | |
| 46 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 47 EXPECT_EQ(2u, info.GetWriteMessageCallCount()); | |
| 48 | |
| 49 EXPECT_EQ(0u, info.GetReadMessageCallCount()); | |
| 50 uint32_t num_bytes = 0; | |
| 51 EXPECT_EQ(MOJO_RESULT_OK, | |
| 52 core()->ReadMessage(h, NULL, &num_bytes, NULL, NULL, | |
| 53 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 54 EXPECT_EQ(1u, info.GetReadMessageCallCount()); | |
| 55 num_bytes = 1; | |
| 56 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 57 core()->ReadMessage(h, NULL, &num_bytes, NULL, NULL, | |
| 58 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 59 EXPECT_EQ(2u, info.GetReadMessageCallCount()); | |
| 60 EXPECT_EQ(MOJO_RESULT_OK, | |
| 61 core()->ReadMessage(h, NULL, NULL, NULL, NULL, | |
| 62 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 63 EXPECT_EQ(3u, info.GetReadMessageCallCount()); | |
| 64 | |
| 65 EXPECT_EQ(0u, info.GetWriteDataCallCount()); | |
| 66 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, | |
| 67 core()->WriteData(h, NULL, NULL, MOJO_WRITE_DATA_FLAG_NONE)); | |
| 68 EXPECT_EQ(1u, info.GetWriteDataCallCount()); | |
| 69 | |
| 70 EXPECT_EQ(0u, info.GetBeginWriteDataCallCount()); | |
| 71 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, | |
| 72 core()->BeginWriteData(h, NULL, NULL, MOJO_WRITE_DATA_FLAG_NONE)); | |
| 73 EXPECT_EQ(1u, info.GetBeginWriteDataCallCount()); | |
| 74 | |
| 75 EXPECT_EQ(0u, info.GetEndWriteDataCallCount()); | |
| 76 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, | |
| 77 core()->EndWriteData(h, 0)); | |
| 78 EXPECT_EQ(1u, info.GetEndWriteDataCallCount()); | |
| 79 | |
| 80 EXPECT_EQ(0u, info.GetReadDataCallCount()); | |
| 81 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, | |
| 82 core()->ReadData(h, NULL, NULL, MOJO_READ_DATA_FLAG_NONE)); | |
| 83 EXPECT_EQ(1u, info.GetReadDataCallCount()); | |
| 84 | |
| 85 EXPECT_EQ(0u, info.GetBeginReadDataCallCount()); | |
| 86 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, | |
| 87 core()->BeginReadData(h, NULL, NULL, MOJO_READ_DATA_FLAG_NONE)); | |
| 88 EXPECT_EQ(1u, info.GetBeginReadDataCallCount()); | |
| 89 | |
| 90 EXPECT_EQ(0u, info.GetEndReadDataCallCount()); | |
| 91 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, | |
| 92 core()->EndReadData(h, 0)); | |
| 93 EXPECT_EQ(1u, info.GetEndReadDataCallCount()); | |
| 94 | |
| 95 EXPECT_EQ(0u, info.GetAddWaiterCallCount()); | |
| 96 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | |
| 97 core()->Wait(h, MOJO_WAIT_FLAG_EVERYTHING, | |
| 98 MOJO_DEADLINE_INDEFINITE)); | |
| 99 EXPECT_EQ(1u, info.GetAddWaiterCallCount()); | |
| 100 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | |
| 101 core()->Wait(h, MOJO_WAIT_FLAG_EVERYTHING, 0)); | |
| 102 EXPECT_EQ(2u, info.GetAddWaiterCallCount()); | |
| 103 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | |
| 104 core()->Wait(h, MOJO_WAIT_FLAG_EVERYTHING, 10 * 1000)); | |
| 105 EXPECT_EQ(3u, info.GetAddWaiterCallCount()); | |
| 106 MojoWaitFlags wait_flags = MOJO_WAIT_FLAG_EVERYTHING; | |
| 107 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | |
| 108 core()->WaitMany(&h, &wait_flags, 1, MOJO_DEADLINE_INDEFINITE)); | |
| 109 EXPECT_EQ(4u, info.GetAddWaiterCallCount()); | |
| 110 | |
| 111 EXPECT_EQ(0u, info.GetDtorCallCount()); | |
| 112 EXPECT_EQ(0u, info.GetCloseCallCount()); | |
| 113 EXPECT_EQ(0u, info.GetCancelAllWaitersCallCount()); | |
| 114 EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h)); | |
| 115 EXPECT_EQ(1u, info.GetCancelAllWaitersCallCount()); | |
| 116 EXPECT_EQ(1u, info.GetCloseCallCount()); | |
| 117 EXPECT_EQ(1u, info.GetDtorCallCount()); | |
| 118 | |
| 119 // No waiters should ever have ever been added. | |
| 120 EXPECT_EQ(0u, info.GetRemoveWaiterCallCount()); | |
| 121 } | |
| 122 | |
| 123 TEST_F(CoreImplTest, InvalidArguments) { | |
| 124 // |Close()|: | |
| 125 { | |
| 126 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(MOJO_HANDLE_INVALID)); | |
| 127 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(10)); | |
| 128 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(1000000000)); | |
| 129 | |
| 130 // Test a double-close. | |
| 131 MockHandleInfo info; | |
| 132 MojoHandle h = CreateMockHandle(&info); | |
| 133 EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h)); | |
| 134 EXPECT_EQ(1u, info.GetCloseCallCount()); | |
| 135 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(h)); | |
| 136 EXPECT_EQ(1u, info.GetCloseCallCount()); | |
| 137 } | |
| 138 | |
| 139 // |Wait()|: | |
| 140 { | |
| 141 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 142 core()->Wait(MOJO_HANDLE_INVALID, MOJO_WAIT_FLAG_EVERYTHING, | |
| 143 MOJO_DEADLINE_INDEFINITE)); | |
| 144 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 145 core()->Wait(10, MOJO_WAIT_FLAG_EVERYTHING, | |
| 146 MOJO_DEADLINE_INDEFINITE)); | |
| 147 } | |
| 148 | |
| 149 // |WaitMany()|: | |
| 150 { | |
| 151 MojoHandle handles[2] = { MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID }; | |
| 152 MojoWaitFlags flags[2] = { MOJO_WAIT_FLAG_EVERYTHING, | |
| 153 MOJO_WAIT_FLAG_EVERYTHING }; | |
| 154 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 155 core()->WaitMany(handles, flags, 0, MOJO_DEADLINE_INDEFINITE)); | |
| 156 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 157 core()->WaitMany(NULL, flags, 0, MOJO_DEADLINE_INDEFINITE)); | |
| 158 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 159 core()->WaitMany(handles, NULL, 0, MOJO_DEADLINE_INDEFINITE)); | |
| 160 | |
| 161 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 162 core()->WaitMany(NULL, flags, 1, MOJO_DEADLINE_INDEFINITE)); | |
| 163 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 164 core()->WaitMany(handles, NULL, 1, MOJO_DEADLINE_INDEFINITE)); | |
| 165 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 166 core()->WaitMany(handles, flags, 1, MOJO_DEADLINE_INDEFINITE)); | |
| 167 | |
| 168 MockHandleInfo info[2]; | |
| 169 handles[0] = CreateMockHandle(&info[0]); | |
| 170 | |
| 171 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | |
| 172 core()->WaitMany(handles, flags, 1, MOJO_DEADLINE_INDEFINITE)); | |
| 173 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 174 core()->WaitMany(handles, flags, 2, MOJO_DEADLINE_INDEFINITE)); | |
| 175 handles[1] = handles[0] + 1; // Invalid handle. | |
| 176 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 177 core()->WaitMany(handles, flags, 2, MOJO_DEADLINE_INDEFINITE)); | |
| 178 handles[1] = CreateMockHandle(&info[1]); | |
| 179 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | |
| 180 core()->WaitMany(handles, flags, 2, MOJO_DEADLINE_INDEFINITE)); | |
| 181 | |
| 182 EXPECT_EQ(MOJO_RESULT_OK, core()->Close(handles[0])); | |
| 183 EXPECT_EQ(MOJO_RESULT_OK, core()->Close(handles[1])); | |
| 184 } | |
| 185 | |
| 186 // |CreateMessagePipe()|: | |
| 187 { | |
| 188 MojoHandle h; | |
| 189 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 190 core()->CreateMessagePipe(NULL, NULL)); | |
| 191 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 192 core()->CreateMessagePipe(&h, NULL)); | |
| 193 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 194 core()->CreateMessagePipe(NULL, &h)); | |
| 195 } | |
| 196 | |
| 197 // |WriteMessage()|: | |
| 198 // Only check arguments checked by |CoreImpl|, namely |handle|, |handles|, and | |
| 199 // |num_handles|. | |
| 200 { | |
| 201 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 202 core()->WriteMessage(MOJO_HANDLE_INVALID, NULL, 0, NULL, 0, | |
| 203 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 204 | |
| 205 MockHandleInfo info; | |
| 206 MojoHandle h = CreateMockHandle(&info); | |
| 207 MojoHandle handles[2] = { MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID }; | |
| 208 | |
| 209 // Null |handles| with nonzero |num_handles|. | |
| 210 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 211 core()->WriteMessage(h, NULL, 0, NULL, 1, | |
| 212 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 213 // Checked by |CoreImpl|, shouldn't go through to the dispatcher. | |
| 214 EXPECT_EQ(0u, info.GetWriteMessageCallCount()); | |
| 215 | |
| 216 // Huge handle count (implausibly big on some systems -- more than can be | |
| 217 // stored in a 32-bit address space). | |
| 218 // Note: This may return either |MOJO_RESULT_INVALID_ARGUMENT| or | |
| 219 // |MOJO_RESULT_RESOURCE_EXHAUSTED|, depending on whether it's plausible or | |
| 220 // not. | |
| 221 EXPECT_NE(MOJO_RESULT_OK, | |
| 222 core()->WriteMessage(h, NULL, 0, handles, | |
| 223 std::numeric_limits<uint32_t>::max(), | |
| 224 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 225 EXPECT_EQ(0u, info.GetWriteMessageCallCount()); | |
| 226 | |
| 227 // Huge handle count (plausibly big). | |
| 228 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, | |
| 229 core()->WriteMessage(h, NULL, 0, handles, | |
| 230 std::numeric_limits<uint32_t>::max() / | |
| 231 sizeof(handles[0]), | |
| 232 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 233 EXPECT_EQ(0u, info.GetWriteMessageCallCount()); | |
| 234 | |
| 235 // Invalid handle in |handles|. | |
| 236 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 237 core()->WriteMessage(h, NULL, 0, handles, 1, | |
| 238 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 239 EXPECT_EQ(0u, info.GetWriteMessageCallCount()); | |
| 240 | |
| 241 // Two invalid handles in |handles|. | |
| 242 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 243 core()->WriteMessage(h, NULL, 0, handles, 2, | |
| 244 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 245 EXPECT_EQ(0u, info.GetWriteMessageCallCount()); | |
| 246 | |
| 247 // Can't send a handle over itself. | |
| 248 handles[0] = h; | |
| 249 EXPECT_EQ(MOJO_RESULT_BUSY, | |
| 250 core()->WriteMessage(h, NULL, 0, handles, 1, | |
| 251 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 252 EXPECT_EQ(0u, info.GetWriteMessageCallCount()); | |
| 253 | |
| 254 MockHandleInfo info2; | |
| 255 MojoHandle h2 = CreateMockHandle(&info2); | |
| 256 | |
| 257 // This is "okay", but |MockDispatcher| doesn't implement it. | |
| 258 handles[0] = h2; | |
| 259 EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, | |
| 260 core()->WriteMessage(h, NULL, 0, handles, 1, | |
| 261 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 262 EXPECT_EQ(1u, info.GetWriteMessageCallCount()); | |
| 263 | |
| 264 // One of the |handles| is still invalid. | |
| 265 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 266 core()->WriteMessage(h, NULL, 0, handles, 2, | |
| 267 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 268 EXPECT_EQ(1u, info.GetWriteMessageCallCount()); | |
| 269 | |
| 270 // One of the |handles| is the same as |handle|. | |
| 271 handles[1] = h; | |
| 272 EXPECT_EQ(MOJO_RESULT_BUSY, | |
| 273 core()->WriteMessage(h, NULL, 0, handles, 2, | |
| 274 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 275 EXPECT_EQ(1u, info.GetWriteMessageCallCount()); | |
| 276 | |
| 277 // Can't send a handle twice in the same message. | |
| 278 handles[1] = h2; | |
| 279 EXPECT_EQ(MOJO_RESULT_BUSY, | |
| 280 core()->WriteMessage(h, NULL, 0, handles, 2, | |
| 281 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 282 EXPECT_EQ(1u, info.GetWriteMessageCallCount()); | |
| 283 | |
| 284 // Note: Since we never successfully sent anything with it, |h2| should | |
| 285 // still be valid. | |
| 286 EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h2)); | |
| 287 | |
| 288 EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h)); | |
| 289 } | |
| 290 | |
| 291 // |ReadMessage()|: | |
| 292 // Only check arguments checked by |CoreImpl|, namely |handle|, |handles|, and | |
| 293 // |num_handles|. | |
| 294 { | |
| 295 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 296 core()->ReadMessage(MOJO_HANDLE_INVALID, NULL, NULL, NULL, NULL, | |
| 297 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 298 | |
| 299 MockHandleInfo info; | |
| 300 MojoHandle h = CreateMockHandle(&info); | |
| 301 | |
| 302 uint32_t handle_count = 1; | |
| 303 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 304 core()->ReadMessage(h, NULL, NULL, NULL, &handle_count, | |
| 305 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 306 // Checked by |CoreImpl|, shouldn't go through to the dispatcher. | |
| 307 EXPECT_EQ(0u, info.GetReadMessageCallCount()); | |
| 308 | |
| 309 // Okay. | |
| 310 handle_count = 0; | |
| 311 EXPECT_EQ(MOJO_RESULT_OK, | |
| 312 core()->ReadMessage(h, NULL, NULL, NULL, &handle_count, | |
| 313 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 314 // Checked by |CoreImpl|, shouldn't go through to the dispatcher. | |
| 315 EXPECT_EQ(1u, info.GetReadMessageCallCount()); | |
| 316 | |
| 317 EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h)); | |
| 318 } | |
| 319 } | |
| 320 | |
| 321 // TODO(vtl): test |Wait()| and |WaitMany()| properly | |
| 322 // - including |WaitMany()| with the same handle more than once (with | |
| 323 // same/different flags) | |
| 324 | |
| 325 TEST_F(CoreImplTest, MessagePipe) { | |
| 326 MojoHandle h[2]; | |
| 327 | |
| 328 EXPECT_EQ(MOJO_RESULT_OK, core()->CreateMessagePipe(&h[0], &h[1])); | |
| 329 // Should get two distinct, valid handles. | |
| 330 EXPECT_NE(h[0], MOJO_HANDLE_INVALID); | |
| 331 EXPECT_NE(h[1], MOJO_HANDLE_INVALID); | |
| 332 EXPECT_NE(h[0], h[1]); | |
| 333 | |
| 334 // Neither should be readable. | |
| 335 MojoWaitFlags flags[2] = { MOJO_WAIT_FLAG_READABLE, MOJO_WAIT_FLAG_READABLE }; | |
| 336 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, | |
| 337 core()->WaitMany(h, flags, 2, 0)); | |
| 338 | |
| 339 // Try to read anyway. | |
| 340 char buffer[1] = { 'a' }; | |
| 341 uint32_t buffer_size = 1; | |
| 342 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, | |
| 343 core()->ReadMessage(h[0], buffer, &buffer_size, NULL, NULL, | |
| 344 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 345 // Check that it left its inputs alone. | |
| 346 EXPECT_EQ('a', buffer[0]); | |
| 347 EXPECT_EQ(1u, buffer_size); | |
| 348 | |
| 349 // Both should be writable. | |
| 350 EXPECT_EQ(MOJO_RESULT_OK, | |
| 351 core()->Wait(h[0], MOJO_WAIT_FLAG_WRITABLE, 1000000000)); | |
| 352 EXPECT_EQ(MOJO_RESULT_OK, | |
| 353 core()->Wait(h[1], MOJO_WAIT_FLAG_WRITABLE, 1000000000)); | |
| 354 | |
| 355 // Also check that |h[1]| is writable using |WaitMany()|. | |
| 356 flags[0] = MOJO_WAIT_FLAG_READABLE; | |
| 357 flags[1] = MOJO_WAIT_FLAG_WRITABLE; | |
| 358 EXPECT_EQ(1, core()->WaitMany(h, flags, 2, MOJO_DEADLINE_INDEFINITE)); | |
| 359 | |
| 360 // Write to |h[1]|. | |
| 361 buffer[0] = 'b'; | |
| 362 EXPECT_EQ(MOJO_RESULT_OK, | |
| 363 core()->WriteMessage(h[1], buffer, 1, NULL, 0, | |
| 364 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 365 | |
| 366 // Check that |h[0]| is now readable. | |
| 367 flags[0] = MOJO_WAIT_FLAG_READABLE; | |
| 368 flags[1] = MOJO_WAIT_FLAG_READABLE; | |
| 369 EXPECT_EQ(0, core()->WaitMany(h, flags, 2, MOJO_DEADLINE_INDEFINITE)); | |
| 370 | |
| 371 // Read from |h[0]|. | |
| 372 // First, get only the size. | |
| 373 buffer_size = 0; | |
| 374 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, | |
| 375 core()->ReadMessage(h[0], NULL, &buffer_size, NULL, NULL, | |
| 376 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 377 EXPECT_EQ(1u, buffer_size); | |
| 378 // Then actually read it. | |
| 379 buffer[0] = 'c'; | |
| 380 buffer_size = 1; | |
| 381 EXPECT_EQ(MOJO_RESULT_OK, | |
| 382 core()->ReadMessage(h[0], buffer, &buffer_size, NULL, NULL, | |
| 383 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 384 EXPECT_EQ('b', buffer[0]); | |
| 385 EXPECT_EQ(1u, buffer_size); | |
| 386 | |
| 387 // |h[0]| should no longer be readable. | |
| 388 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, | |
| 389 core()->Wait(h[0], MOJO_WAIT_FLAG_READABLE, 0)); | |
| 390 | |
| 391 // Write to |h[0]|. | |
| 392 buffer[0] = 'd'; | |
| 393 EXPECT_EQ(MOJO_RESULT_OK, | |
| 394 core()->WriteMessage(h[0], buffer, 1, NULL, 0, | |
| 395 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 396 | |
| 397 // Close |h[0]|. | |
| 398 EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[0])); | |
| 399 | |
| 400 // Check that |h[1]| is no longer writable (and will never be). | |
| 401 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | |
| 402 core()->Wait(h[1], MOJO_WAIT_FLAG_WRITABLE, 1000000000)); | |
| 403 | |
| 404 // Check that |h[1]| is still readable (for the moment). | |
| 405 EXPECT_EQ(MOJO_RESULT_OK, | |
| 406 core()->Wait(h[1], MOJO_WAIT_FLAG_READABLE, 1000000000)); | |
| 407 | |
| 408 // Discard a message from |h[1]|. | |
| 409 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, | |
| 410 core()->ReadMessage(h[1], NULL, NULL, NULL, NULL, | |
| 411 MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); | |
| 412 | |
| 413 // |h[1]| is no longer readable (and will never be). | |
| 414 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | |
| 415 core()->Wait(h[1], MOJO_WAIT_FLAG_READABLE, 1000000000)); | |
| 416 | |
| 417 // Try writing to |h[1]|. | |
| 418 buffer[0] = 'e'; | |
| 419 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | |
| 420 core()->WriteMessage(h[1], buffer, 1, NULL, 0, | |
| 421 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 422 | |
| 423 EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[1])); | |
| 424 } | |
| 425 | |
| 426 // Tests passing a message pipe handle. | |
| 427 TEST_F(CoreImplTest, MessagePipeBasicLocalHandlePassing1) { | |
| 428 const char kHello[] = "hello"; | |
| 429 const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello)); | |
| 430 const char kWorld[] = "world!!!"; | |
| 431 const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld)); | |
| 432 char buffer[100]; | |
| 433 const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer)); | |
| 434 uint32_t num_bytes; | |
| 435 MojoHandle handles[10]; | |
| 436 uint32_t num_handles; | |
| 437 MojoHandle h_received; | |
| 438 | |
| 439 MojoHandle h_passing[2]; | |
| 440 EXPECT_EQ(MOJO_RESULT_OK, | |
| 441 core()->CreateMessagePipe(&h_passing[0], &h_passing[1])); | |
| 442 | |
| 443 // Make sure that |h_passing[]| work properly. | |
| 444 EXPECT_EQ(MOJO_RESULT_OK, | |
| 445 core()->WriteMessage(h_passing[0], | |
| 446 kHello, kHelloSize, | |
| 447 NULL, 0, | |
| 448 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 449 EXPECT_EQ(MOJO_RESULT_OK, | |
| 450 core()->Wait(h_passing[1], MOJO_WAIT_FLAG_READABLE, 1000000000)); | |
| 451 num_bytes = kBufferSize; | |
| 452 num_handles = arraysize(handles); | |
| 453 EXPECT_EQ(MOJO_RESULT_OK, | |
| 454 core()->ReadMessage(h_passing[1], | |
| 455 buffer, &num_bytes, | |
| 456 handles, &num_handles, | |
| 457 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 458 EXPECT_EQ(kHelloSize, num_bytes); | |
| 459 EXPECT_STREQ(kHello, buffer); | |
| 460 EXPECT_EQ(0u, num_handles); | |
| 461 | |
| 462 // Make sure that you can't pass either of the message pipe's handles over | |
| 463 // itself. | |
| 464 EXPECT_EQ(MOJO_RESULT_BUSY, | |
| 465 core()->WriteMessage(h_passing[0], | |
| 466 kHello, kHelloSize, | |
| 467 &h_passing[0], 1, | |
| 468 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 469 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | |
| 470 core()->WriteMessage(h_passing[0], | |
| 471 kHello, kHelloSize, | |
| 472 &h_passing[1], 1, | |
| 473 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 474 | |
| 475 MojoHandle h_passed[2]; | |
| 476 EXPECT_EQ(MOJO_RESULT_OK, | |
| 477 core()->CreateMessagePipe(&h_passed[0], &h_passed[1])); | |
| 478 | |
| 479 // Make sure that |h_passed[]| work properly. | |
| 480 EXPECT_EQ(MOJO_RESULT_OK, | |
| 481 core()->WriteMessage(h_passed[0], | |
| 482 kHello, kHelloSize, | |
| 483 NULL, 0, | |
| 484 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 485 EXPECT_EQ(MOJO_RESULT_OK, | |
| 486 core()->Wait(h_passed[1], MOJO_WAIT_FLAG_READABLE, 1000000000)); | |
| 487 num_bytes = kBufferSize; | |
| 488 num_handles = arraysize(handles); | |
| 489 EXPECT_EQ(MOJO_RESULT_OK, | |
| 490 core()->ReadMessage(h_passed[1], | |
| 491 buffer, &num_bytes, | |
| 492 handles, &num_handles, | |
| 493 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 494 EXPECT_EQ(kHelloSize, num_bytes); | |
| 495 EXPECT_STREQ(kHello, buffer); | |
| 496 EXPECT_EQ(0u, num_handles); | |
| 497 | |
| 498 // Send |h_passed[1]| from |h_passing[0]| to |h_passing[1]|. | |
| 499 EXPECT_EQ(MOJO_RESULT_OK, | |
| 500 core()->WriteMessage(h_passing[0], | |
| 501 kWorld, kWorldSize, | |
| 502 &h_passed[1], 1, | |
| 503 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 504 EXPECT_EQ(MOJO_RESULT_OK, | |
| 505 core()->Wait(h_passing[1], MOJO_WAIT_FLAG_READABLE, 1000000000)); | |
| 506 num_bytes = kBufferSize; | |
| 507 num_handles = arraysize(handles); | |
| 508 EXPECT_EQ(MOJO_RESULT_OK, | |
| 509 core()->ReadMessage(h_passing[1], | |
| 510 buffer, &num_bytes, | |
| 511 handles, &num_handles, | |
| 512 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 513 EXPECT_EQ(kWorldSize, num_bytes); | |
| 514 EXPECT_STREQ(kWorld, buffer); | |
| 515 EXPECT_EQ(1u, num_handles); | |
| 516 h_received = handles[0]; | |
| 517 EXPECT_NE(h_received, MOJO_HANDLE_INVALID); | |
| 518 EXPECT_NE(h_received, h_passing[0]); | |
| 519 EXPECT_NE(h_received, h_passing[1]); | |
| 520 EXPECT_NE(h_received, h_passed[0]); | |
| 521 | |
| 522 // Note: We rely on the Mojo system not re-using handle values very often. | |
| 523 EXPECT_NE(h_received, h_passed[1]); | |
| 524 | |
| 525 // |h_passed[1]| should no longer be valid; check that trying to close it | |
| 526 // fails. See above note. | |
| 527 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(h_passed[1])); | |
| 528 | |
| 529 // Write to |h_passed[0]|. Should receive on |h_received|. | |
| 530 EXPECT_EQ(MOJO_RESULT_OK, | |
| 531 core()->WriteMessage(h_passed[0], | |
| 532 kHello, kHelloSize, | |
| 533 NULL, 0, | |
| 534 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 535 EXPECT_EQ(MOJO_RESULT_OK, | |
| 536 core()->Wait(h_received, MOJO_WAIT_FLAG_READABLE, 1000000000)); | |
| 537 num_bytes = kBufferSize; | |
| 538 num_handles = arraysize(handles); | |
| 539 EXPECT_EQ(MOJO_RESULT_OK, | |
| 540 core()->ReadMessage(h_received, | |
| 541 buffer, &num_bytes, | |
| 542 handles, &num_handles, | |
| 543 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 544 EXPECT_EQ(kHelloSize, num_bytes); | |
| 545 EXPECT_STREQ(kHello, buffer); | |
| 546 EXPECT_EQ(0u, num_handles); | |
| 547 | |
| 548 EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[0])); | |
| 549 EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[1])); | |
| 550 EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passed[0])); | |
| 551 EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_received)); | |
| 552 } | |
| 553 | |
| 554 TEST_F(CoreImplTest, DataPipe) { | |
| 555 MojoHandle ph, ch; // p is for producer and c is for consumer. | |
| 556 | |
| 557 EXPECT_EQ(MOJO_RESULT_OK, core()->CreateDataPipe(NULL, &ph, &ch)); | |
| 558 // Should get two distinct, valid handles. | |
| 559 EXPECT_NE(ph, MOJO_HANDLE_INVALID); | |
| 560 EXPECT_NE(ch, MOJO_HANDLE_INVALID); | |
| 561 EXPECT_NE(ph, ch); | |
| 562 | |
| 563 // Producer should be never-readable, but already writable. | |
| 564 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | |
| 565 core()->Wait(ph, MOJO_WAIT_FLAG_READABLE, 0)); | |
| 566 EXPECT_EQ(MOJO_RESULT_OK, | |
| 567 core()->Wait(ph, MOJO_WAIT_FLAG_WRITABLE, 0)); | |
| 568 | |
| 569 // Consumer should be never-writable, and not yet readable. | |
| 570 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | |
| 571 core()->Wait(ch, MOJO_WAIT_FLAG_WRITABLE, 0)); | |
| 572 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, | |
| 573 core()->Wait(ch, MOJO_WAIT_FLAG_READABLE, 0)); | |
| 574 | |
| 575 // Write. | |
| 576 char elements[2] = { 'A', 'B' }; | |
| 577 uint32_t num_bytes = 2u; | |
| 578 EXPECT_EQ(MOJO_RESULT_OK, | |
| 579 core()->WriteData(ph, elements, &num_bytes, | |
| 580 MOJO_WRITE_DATA_FLAG_NONE)); | |
| 581 EXPECT_EQ(2u, num_bytes); | |
| 582 | |
| 583 // Consumer should now be readable. | |
| 584 EXPECT_EQ(MOJO_RESULT_OK, | |
| 585 core()->Wait(ch, MOJO_WAIT_FLAG_READABLE, 0)); | |
| 586 | |
| 587 // Read one character. | |
| 588 elements[0] = -1; | |
| 589 elements[1] = -1; | |
| 590 num_bytes = 1u; | |
| 591 EXPECT_EQ(MOJO_RESULT_OK, | |
| 592 core()->ReadData(ch, elements, &num_bytes, | |
| 593 MOJO_READ_DATA_FLAG_NONE)); | |
| 594 EXPECT_EQ('A', elements[0]); | |
| 595 EXPECT_EQ(-1, elements[1]); | |
| 596 | |
| 597 // Two-phase write. | |
| 598 void* write_ptr = NULL; | |
| 599 num_bytes = 0u; | |
| 600 ASSERT_EQ(MOJO_RESULT_OK, | |
| 601 core()->BeginWriteData(ph, &write_ptr, &num_bytes, | |
| 602 MOJO_WRITE_DATA_FLAG_NONE)); | |
| 603 // We count on the default options providing a decent buffer size. | |
| 604 ASSERT_GE(num_bytes, 3u); | |
| 605 | |
| 606 // Trying to do a normal write during a two-phase write should fail. | |
| 607 elements[0] = 'X'; | |
| 608 num_bytes = 1u; | |
| 609 EXPECT_EQ(MOJO_RESULT_BUSY, | |
| 610 core()->WriteData(ph, elements, &num_bytes, | |
| 611 MOJO_WRITE_DATA_FLAG_NONE)); | |
| 612 | |
| 613 // Actually write the data, and complete it now. | |
| 614 static_cast<char*>(write_ptr)[0] = 'C'; | |
| 615 static_cast<char*>(write_ptr)[1] = 'D'; | |
| 616 static_cast<char*>(write_ptr)[2] = 'E'; | |
| 617 EXPECT_EQ(MOJO_RESULT_OK, core()->EndWriteData(ph, 3u)); | |
| 618 | |
| 619 // Query how much data we have. | |
| 620 num_bytes = 0; | |
| 621 EXPECT_EQ(MOJO_RESULT_OK, | |
| 622 core()->ReadData(ch, NULL, &num_bytes, MOJO_READ_DATA_FLAG_QUERY)); | |
| 623 EXPECT_EQ(4u, num_bytes); | |
| 624 | |
| 625 // Try to discard ten characters, in all-or-none mode. Should fail. | |
| 626 num_bytes = 10; | |
| 627 EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, | |
| 628 core()->ReadData(ch, NULL, &num_bytes, | |
| 629 MOJO_READ_DATA_FLAG_DISCARD | | |
| 630 MOJO_READ_DATA_FLAG_ALL_OR_NONE)); | |
| 631 | |
| 632 // Discard two characters. | |
| 633 num_bytes = 2; | |
| 634 EXPECT_EQ(MOJO_RESULT_OK, | |
| 635 core()->ReadData(ch, NULL, &num_bytes, | |
| 636 MOJO_READ_DATA_FLAG_DISCARD | | |
| 637 MOJO_READ_DATA_FLAG_ALL_OR_NONE)); | |
| 638 | |
| 639 // Read the remaining two characters, in two-phase mode (all-or-none). | |
| 640 const void* read_ptr = NULL; | |
| 641 num_bytes = 2; | |
| 642 ASSERT_EQ(MOJO_RESULT_OK, | |
| 643 core()->BeginReadData(ch, &read_ptr, &num_bytes, | |
| 644 MOJO_READ_DATA_FLAG_ALL_OR_NONE)); | |
| 645 // Note: Count on still being able to do the contiguous read here. | |
| 646 ASSERT_EQ(2u, num_bytes); | |
| 647 | |
| 648 // Discarding right now should fail. | |
| 649 num_bytes = 1; | |
| 650 EXPECT_EQ(MOJO_RESULT_BUSY, | |
| 651 core()->ReadData(ch, NULL, &num_bytes, | |
| 652 MOJO_READ_DATA_FLAG_DISCARD)); | |
| 653 | |
| 654 // Actually check our data and end the two-phase read. | |
| 655 EXPECT_EQ('D', static_cast<const char*>(read_ptr)[0]); | |
| 656 EXPECT_EQ('E', static_cast<const char*>(read_ptr)[1]); | |
| 657 EXPECT_EQ(MOJO_RESULT_OK, core()->EndReadData(ch, 2u)); | |
| 658 | |
| 659 // Consumer should now be no longer readable. | |
| 660 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, | |
| 661 core()->Wait(ch, MOJO_WAIT_FLAG_READABLE, 0)); | |
| 662 | |
| 663 // TODO(vtl): More. | |
| 664 | |
| 665 // Close the producer. | |
| 666 EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ph)); | |
| 667 | |
| 668 // The consumer should now be never-readable. | |
| 669 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | |
| 670 core()->Wait(ch, MOJO_WAIT_FLAG_READABLE, 0)); | |
| 671 | |
| 672 EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ch)); | |
| 673 } | |
| 674 | |
| 675 // Tests passing data pipe producer and consumer handles. | |
| 676 TEST_F(CoreImplTest, MessagePipeBasicLocalHandlePassing2) { | |
| 677 const char kHello[] = "hello"; | |
| 678 const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello)); | |
| 679 const char kWorld[] = "world!!!"; | |
| 680 const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld)); | |
| 681 char buffer[100]; | |
| 682 const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer)); | |
| 683 uint32_t num_bytes; | |
| 684 MojoHandle handles[10]; | |
| 685 uint32_t num_handles; | |
| 686 | |
| 687 MojoHandle h_passing[2]; | |
| 688 EXPECT_EQ(MOJO_RESULT_OK, | |
| 689 core()->CreateMessagePipe(&h_passing[0], &h_passing[1])); | |
| 690 | |
| 691 MojoHandle ph, ch; | |
| 692 EXPECT_EQ(MOJO_RESULT_OK, | |
| 693 core()->CreateDataPipe(NULL, &ph, &ch)); | |
| 694 | |
| 695 // Send |ch| from |h_passing[0]| to |h_passing[1]|. | |
| 696 EXPECT_EQ(MOJO_RESULT_OK, | |
| 697 core()->WriteMessage(h_passing[0], | |
| 698 kHello, kHelloSize, | |
| 699 &ch, 1, | |
| 700 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 701 EXPECT_EQ(MOJO_RESULT_OK, | |
| 702 core()->Wait(h_passing[1], MOJO_WAIT_FLAG_READABLE, 1000000000)); | |
| 703 num_bytes = kBufferSize; | |
| 704 num_handles = arraysize(handles); | |
| 705 EXPECT_EQ(MOJO_RESULT_OK, | |
| 706 core()->ReadMessage(h_passing[1], | |
| 707 buffer, &num_bytes, | |
| 708 handles, &num_handles, | |
| 709 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 710 EXPECT_EQ(kHelloSize, num_bytes); | |
| 711 EXPECT_STREQ(kHello, buffer); | |
| 712 EXPECT_EQ(1u, num_handles); | |
| 713 MojoHandle ch_received = handles[0]; | |
| 714 EXPECT_NE(ch_received, MOJO_HANDLE_INVALID); | |
| 715 EXPECT_NE(ch_received, h_passing[0]); | |
| 716 EXPECT_NE(ch_received, h_passing[1]); | |
| 717 EXPECT_NE(ch_received, ph); | |
| 718 | |
| 719 // Note: We rely on the Mojo system not re-using handle values very often. | |
| 720 EXPECT_NE(ch_received, ch); | |
| 721 | |
| 722 // |ch| should no longer be valid; check that trying to close it fails. See | |
| 723 // above note. | |
| 724 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(ch)); | |
| 725 | |
| 726 // Write to |ph|. Should receive on |ch_received|. | |
| 727 num_bytes = kWorldSize; | |
| 728 EXPECT_EQ(MOJO_RESULT_OK, | |
| 729 core()->WriteData(ph, kWorld, &num_bytes, | |
| 730 MOJO_WRITE_DATA_FLAG_ALL_OR_NONE)); | |
| 731 EXPECT_EQ(MOJO_RESULT_OK, | |
| 732 core()->Wait(ch_received, MOJO_WAIT_FLAG_READABLE, 1000000000)); | |
| 733 num_bytes = kBufferSize; | |
| 734 EXPECT_EQ(MOJO_RESULT_OK, | |
| 735 core()->ReadData(ch_received, buffer, &num_bytes, | |
| 736 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 737 EXPECT_EQ(kWorldSize, num_bytes); | |
| 738 EXPECT_STREQ(kWorld, buffer); | |
| 739 | |
| 740 // Now pass |ph| in the same direction. | |
| 741 EXPECT_EQ(MOJO_RESULT_OK, | |
| 742 core()->WriteMessage(h_passing[0], | |
| 743 kWorld, kWorldSize, | |
| 744 &ph, 1, | |
| 745 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 746 EXPECT_EQ(MOJO_RESULT_OK, | |
| 747 core()->Wait(h_passing[1], MOJO_WAIT_FLAG_READABLE, 1000000000)); | |
| 748 num_bytes = kBufferSize; | |
| 749 num_handles = arraysize(handles); | |
| 750 EXPECT_EQ(MOJO_RESULT_OK, | |
| 751 core()->ReadMessage(h_passing[1], | |
| 752 buffer, &num_bytes, | |
| 753 handles, &num_handles, | |
| 754 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 755 EXPECT_EQ(kWorldSize, num_bytes); | |
| 756 EXPECT_STREQ(kWorld, buffer); | |
| 757 EXPECT_EQ(1u, num_handles); | |
| 758 MojoHandle ph_received = handles[0]; | |
| 759 EXPECT_NE(ph_received, MOJO_HANDLE_INVALID); | |
| 760 EXPECT_NE(ph_received, h_passing[0]); | |
| 761 EXPECT_NE(ph_received, h_passing[1]); | |
| 762 EXPECT_NE(ph_received, ch_received); | |
| 763 | |
| 764 // Again, rely on the Mojo system not re-using handle values very often. | |
| 765 EXPECT_NE(ph_received, ph); | |
| 766 | |
| 767 // |ph| should no longer be valid; check that trying to close it fails. See | |
| 768 // above note. | |
| 769 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(ph)); | |
| 770 | |
| 771 // Write to |ph_received|. Should receive on |ch_received|. | |
| 772 num_bytes = kHelloSize; | |
| 773 EXPECT_EQ(MOJO_RESULT_OK, | |
| 774 core()->WriteData(ph_received, kHello, &num_bytes, | |
| 775 MOJO_WRITE_DATA_FLAG_ALL_OR_NONE)); | |
| 776 EXPECT_EQ(MOJO_RESULT_OK, | |
| 777 core()->Wait(ch_received, MOJO_WAIT_FLAG_READABLE, 1000000000)); | |
| 778 num_bytes = kBufferSize; | |
| 779 EXPECT_EQ(MOJO_RESULT_OK, | |
| 780 core()->ReadData(ch_received, buffer, &num_bytes, | |
| 781 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 782 EXPECT_EQ(kHelloSize, num_bytes); | |
| 783 EXPECT_STREQ(kHello, buffer); | |
| 784 | |
| 785 ph = ph_received; | |
| 786 ph_received = MOJO_HANDLE_INVALID; | |
| 787 ch = ch_received; | |
| 788 ch_received = MOJO_HANDLE_INVALID; | |
| 789 | |
| 790 // Make sure that |ph| can't be sent if it's in a two-phase write. | |
| 791 void* write_ptr = NULL; | |
| 792 num_bytes = 0; | |
| 793 ASSERT_EQ(MOJO_RESULT_OK, | |
| 794 core()->BeginWriteData(ph, &write_ptr, &num_bytes, | |
| 795 MOJO_WRITE_DATA_FLAG_NONE)); | |
| 796 ASSERT_GE(num_bytes, 1u); | |
| 797 EXPECT_EQ(MOJO_RESULT_BUSY, | |
| 798 core()->WriteMessage(h_passing[0], | |
| 799 kHello, kHelloSize, | |
| 800 &ph, 1, | |
| 801 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 802 | |
| 803 // But |ch| can, even if |ph| is in a two-phase write. | |
| 804 EXPECT_EQ(MOJO_RESULT_OK, | |
| 805 core()->WriteMessage(h_passing[0], | |
| 806 kHello, kHelloSize, | |
| 807 &ch, 1, | |
| 808 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 809 ch = MOJO_HANDLE_INVALID; | |
| 810 EXPECT_EQ(MOJO_RESULT_OK, | |
| 811 core()->Wait(h_passing[1], MOJO_WAIT_FLAG_READABLE, 1000000000)); | |
| 812 num_bytes = kBufferSize; | |
| 813 num_handles = arraysize(handles); | |
| 814 EXPECT_EQ(MOJO_RESULT_OK, | |
| 815 core()->ReadMessage(h_passing[1], | |
| 816 buffer, &num_bytes, | |
| 817 handles, &num_handles, | |
| 818 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 819 EXPECT_EQ(kHelloSize, num_bytes); | |
| 820 EXPECT_STREQ(kHello, buffer); | |
| 821 EXPECT_EQ(1u, num_handles); | |
| 822 ch = handles[0]; | |
| 823 EXPECT_NE(ch, MOJO_HANDLE_INVALID); | |
| 824 | |
| 825 // Complete the two-phase write. | |
| 826 static_cast<char*>(write_ptr)[0] = 'x'; | |
| 827 EXPECT_EQ(MOJO_RESULT_OK, core()->EndWriteData(ph, 1)); | |
| 828 | |
| 829 // Wait for |ch| to be readable. | |
| 830 EXPECT_EQ(MOJO_RESULT_OK, | |
| 831 core()->Wait(ch, MOJO_WAIT_FLAG_READABLE, 1000000000)); | |
| 832 | |
| 833 // Make sure that |ch| can't be sent if it's in a two-phase read. | |
| 834 const void* read_ptr = NULL; | |
| 835 num_bytes = 1; | |
| 836 ASSERT_EQ(MOJO_RESULT_OK, | |
| 837 core()->BeginReadData(ch, &read_ptr, &num_bytes, | |
| 838 MOJO_READ_DATA_FLAG_ALL_OR_NONE)); | |
| 839 EXPECT_EQ(MOJO_RESULT_BUSY, | |
| 840 core()->WriteMessage(h_passing[0], | |
| 841 kHello, kHelloSize, | |
| 842 &ch, 1, | |
| 843 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 844 | |
| 845 // But |ph| can, even if |ch| is in a two-phase read. | |
| 846 EXPECT_EQ(MOJO_RESULT_OK, | |
| 847 core()->WriteMessage(h_passing[0], | |
| 848 kWorld, kWorldSize, | |
| 849 &ph, 1, | |
| 850 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 851 ph = MOJO_HANDLE_INVALID; | |
| 852 EXPECT_EQ(MOJO_RESULT_OK, | |
| 853 core()->Wait(h_passing[1], MOJO_WAIT_FLAG_READABLE, 1000000000)); | |
| 854 num_bytes = kBufferSize; | |
| 855 num_handles = arraysize(handles); | |
| 856 EXPECT_EQ(MOJO_RESULT_OK, | |
| 857 core()->ReadMessage(h_passing[1], | |
| 858 buffer, &num_bytes, | |
| 859 handles, &num_handles, | |
| 860 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 861 EXPECT_EQ(kWorldSize, num_bytes); | |
| 862 EXPECT_STREQ(kWorld, buffer); | |
| 863 EXPECT_EQ(1u, num_handles); | |
| 864 ph = handles[0]; | |
| 865 EXPECT_NE(ph, MOJO_HANDLE_INVALID); | |
| 866 | |
| 867 // Complete the two-phase read. | |
| 868 EXPECT_EQ('x', static_cast<const char*>(read_ptr)[0]); | |
| 869 EXPECT_EQ(MOJO_RESULT_OK, core()->EndReadData(ch, 1)); | |
| 870 | |
| 871 EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[0])); | |
| 872 EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h_passing[1])); | |
| 873 EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ph)); | |
| 874 EXPECT_EQ(MOJO_RESULT_OK, core()->Close(ch)); | |
| 875 } | |
| 876 | |
| 877 // TODO(vtl): Test |DuplicateBufferHandle()| and |MapBuffer()|. | |
| 878 | |
| 879 } // namespace | |
| 880 } // namespace system | |
| 881 } // namespace mojo | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 231353002:
Make mojo_system static and mojo_system_impl a component, never use both (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src