| 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/message_pipe.h" | |
| 6 | |
| 7 #include "base/memory/ref_counted.h" | |
| 8 #include "base/threading/platform_thread.h" // For |Sleep()|. | |
| 9 #include "base/time/time.h" | |
| 10 #include "mojo/system/waiter.h" | |
| 11 #include "mojo/system/waiter_test_utils.h" | |
| 12 #include "testing/gtest/include/gtest/gtest.h" | |
| 13 | |
| 14 namespace mojo { | |
| 15 namespace system { | |
| 16 namespace { | |
| 17 | |
| 18 // Tests: | |
| 19 // - only default flags | |
| 20 // - reading messages from a port | |
| 21 // - when there are no/one/two messages available for that port | |
| 22 // - with buffer size 0 (and null buffer) -- should get size | |
| 23 // - with too-small buffer -- should get size | |
| 24 // - also verify that buffers aren't modified when/where they shouldn't be | |
| 25 // - writing messages to a port | |
| 26 // - in the obvious scenarios (as above) | |
| 27 // - to a port that's been closed | |
| 28 // - writing a message to a port, closing the other (would be the source) port, | |
| 29 // and reading it | |
| 30 TEST(MessagePipeTest, Basic) { | |
| 31 scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal()); | |
| 32 | |
| 33 int32_t buffer[2]; | |
| 34 const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer)); | |
| 35 uint32_t buffer_size; | |
| 36 | |
| 37 // Nothing to read yet on port 0. | |
| 38 buffer[0] = 123; | |
| 39 buffer[1] = 456; | |
| 40 buffer_size = kBufferSize; | |
| 41 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, | |
| 42 mp->ReadMessage(0, | |
| 43 UserPointer<void>(buffer), | |
| 44 MakeUserPointer(&buffer_size), | |
| 45 0, | |
| 46 nullptr, | |
| 47 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 48 EXPECT_EQ(kBufferSize, buffer_size); | |
| 49 EXPECT_EQ(123, buffer[0]); | |
| 50 EXPECT_EQ(456, buffer[1]); | |
| 51 | |
| 52 // Ditto for port 1. | |
| 53 buffer[0] = 123; | |
| 54 buffer[1] = 456; | |
| 55 buffer_size = kBufferSize; | |
| 56 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, | |
| 57 mp->ReadMessage(1, | |
| 58 UserPointer<void>(buffer), | |
| 59 MakeUserPointer(&buffer_size), | |
| 60 0, | |
| 61 nullptr, | |
| 62 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 63 | |
| 64 // Write from port 1 (to port 0). | |
| 65 buffer[0] = 789012345; | |
| 66 buffer[1] = 0; | |
| 67 EXPECT_EQ(MOJO_RESULT_OK, | |
| 68 mp->WriteMessage(1, | |
| 69 UserPointer<const void>(buffer), | |
| 70 static_cast<uint32_t>(sizeof(buffer[0])), | |
| 71 nullptr, | |
| 72 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 73 | |
| 74 // Read from port 0. | |
| 75 buffer[0] = 123; | |
| 76 buffer[1] = 456; | |
| 77 buffer_size = kBufferSize; | |
| 78 EXPECT_EQ(MOJO_RESULT_OK, | |
| 79 mp->ReadMessage(0, | |
| 80 UserPointer<void>(buffer), | |
| 81 MakeUserPointer(&buffer_size), | |
| 82 0, | |
| 83 nullptr, | |
| 84 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 85 EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); | |
| 86 EXPECT_EQ(789012345, buffer[0]); | |
| 87 EXPECT_EQ(456, buffer[1]); | |
| 88 | |
| 89 // Read again from port 0 -- it should be empty. | |
| 90 buffer_size = kBufferSize; | |
| 91 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, | |
| 92 mp->ReadMessage(0, | |
| 93 UserPointer<void>(buffer), | |
| 94 MakeUserPointer(&buffer_size), | |
| 95 0, | |
| 96 nullptr, | |
| 97 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 98 | |
| 99 // Write two messages from port 0 (to port 1). | |
| 100 buffer[0] = 123456789; | |
| 101 buffer[1] = 0; | |
| 102 EXPECT_EQ(MOJO_RESULT_OK, | |
| 103 mp->WriteMessage(0, | |
| 104 UserPointer<const void>(buffer), | |
| 105 static_cast<uint32_t>(sizeof(buffer[0])), | |
| 106 nullptr, | |
| 107 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 108 buffer[0] = 234567890; | |
| 109 buffer[1] = 0; | |
| 110 EXPECT_EQ(MOJO_RESULT_OK, | |
| 111 mp->WriteMessage(0, | |
| 112 UserPointer<const void>(buffer), | |
| 113 static_cast<uint32_t>(sizeof(buffer[0])), | |
| 114 nullptr, | |
| 115 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 116 | |
| 117 // Read from port 1 with buffer size 0 (should get the size of next message). | |
| 118 // Also test that giving a null buffer is okay when the buffer size is 0. | |
| 119 buffer_size = 0; | |
| 120 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, | |
| 121 mp->ReadMessage(1, | |
| 122 NullUserPointer(), | |
| 123 MakeUserPointer(&buffer_size), | |
| 124 0, | |
| 125 nullptr, | |
| 126 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 127 EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); | |
| 128 | |
| 129 // Read from port 1 with buffer size 1 (too small; should get the size of next | |
| 130 // message). | |
| 131 buffer[0] = 123; | |
| 132 buffer[1] = 456; | |
| 133 buffer_size = 1; | |
| 134 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, | |
| 135 mp->ReadMessage(1, | |
| 136 UserPointer<void>(buffer), | |
| 137 MakeUserPointer(&buffer_size), | |
| 138 0, | |
| 139 nullptr, | |
| 140 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 141 EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); | |
| 142 EXPECT_EQ(123, buffer[0]); | |
| 143 EXPECT_EQ(456, buffer[1]); | |
| 144 | |
| 145 // Read from port 1. | |
| 146 buffer[0] = 123; | |
| 147 buffer[1] = 456; | |
| 148 buffer_size = kBufferSize; | |
| 149 EXPECT_EQ(MOJO_RESULT_OK, | |
| 150 mp->ReadMessage(1, | |
| 151 UserPointer<void>(buffer), | |
| 152 MakeUserPointer(&buffer_size), | |
| 153 0, | |
| 154 nullptr, | |
| 155 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 156 EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); | |
| 157 EXPECT_EQ(123456789, buffer[0]); | |
| 158 EXPECT_EQ(456, buffer[1]); | |
| 159 | |
| 160 // Read again from port 1. | |
| 161 buffer[0] = 123; | |
| 162 buffer[1] = 456; | |
| 163 buffer_size = kBufferSize; | |
| 164 EXPECT_EQ(MOJO_RESULT_OK, | |
| 165 mp->ReadMessage(1, | |
| 166 UserPointer<void>(buffer), | |
| 167 MakeUserPointer(&buffer_size), | |
| 168 0, | |
| 169 nullptr, | |
| 170 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 171 EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); | |
| 172 EXPECT_EQ(234567890, buffer[0]); | |
| 173 EXPECT_EQ(456, buffer[1]); | |
| 174 | |
| 175 // Read again from port 1 -- it should be empty. | |
| 176 buffer_size = kBufferSize; | |
| 177 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, | |
| 178 mp->ReadMessage(1, | |
| 179 UserPointer<void>(buffer), | |
| 180 MakeUserPointer(&buffer_size), | |
| 181 0, | |
| 182 nullptr, | |
| 183 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 184 | |
| 185 // Write from port 0 (to port 1). | |
| 186 buffer[0] = 345678901; | |
| 187 buffer[1] = 0; | |
| 188 EXPECT_EQ(MOJO_RESULT_OK, | |
| 189 mp->WriteMessage(0, | |
| 190 UserPointer<const void>(buffer), | |
| 191 static_cast<uint32_t>(sizeof(buffer[0])), | |
| 192 nullptr, | |
| 193 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 194 | |
| 195 // Close port 0. | |
| 196 mp->Close(0); | |
| 197 | |
| 198 // Try to write from port 1 (to port 0). | |
| 199 buffer[0] = 456789012; | |
| 200 buffer[1] = 0; | |
| 201 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | |
| 202 mp->WriteMessage(1, | |
| 203 UserPointer<const void>(buffer), | |
| 204 static_cast<uint32_t>(sizeof(buffer[0])), | |
| 205 nullptr, | |
| 206 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 207 | |
| 208 // Read from port 1; should still get message (even though port 0 was closed). | |
| 209 buffer[0] = 123; | |
| 210 buffer[1] = 456; | |
| 211 buffer_size = kBufferSize; | |
| 212 EXPECT_EQ(MOJO_RESULT_OK, | |
| 213 mp->ReadMessage(1, | |
| 214 UserPointer<void>(buffer), | |
| 215 MakeUserPointer(&buffer_size), | |
| 216 0, | |
| 217 nullptr, | |
| 218 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 219 EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); | |
| 220 EXPECT_EQ(345678901, buffer[0]); | |
| 221 EXPECT_EQ(456, buffer[1]); | |
| 222 | |
| 223 // Read again from port 1 -- it should be empty (and port 0 is closed). | |
| 224 buffer_size = kBufferSize; | |
| 225 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | |
| 226 mp->ReadMessage(1, | |
| 227 UserPointer<void>(buffer), | |
| 228 MakeUserPointer(&buffer_size), | |
| 229 0, | |
| 230 nullptr, | |
| 231 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 232 | |
| 233 mp->Close(1); | |
| 234 } | |
| 235 | |
| 236 TEST(MessagePipeTest, CloseWithQueuedIncomingMessages) { | |
| 237 scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal()); | |
| 238 | |
| 239 int32_t buffer[1]; | |
| 240 const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer)); | |
| 241 uint32_t buffer_size; | |
| 242 | |
| 243 // Write some messages from port 1 (to port 0). | |
| 244 for (int32_t i = 0; i < 5; i++) { | |
| 245 buffer[0] = i; | |
| 246 EXPECT_EQ(MOJO_RESULT_OK, | |
| 247 mp->WriteMessage(1, | |
| 248 UserPointer<const void>(buffer), | |
| 249 kBufferSize, | |
| 250 nullptr, | |
| 251 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 252 } | |
| 253 | |
| 254 // Port 0 shouldn't be empty. | |
| 255 buffer_size = 0; | |
| 256 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, | |
| 257 mp->ReadMessage(0, | |
| 258 NullUserPointer(), | |
| 259 MakeUserPointer(&buffer_size), | |
| 260 0, | |
| 261 nullptr, | |
| 262 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 263 EXPECT_EQ(kBufferSize, buffer_size); | |
| 264 | |
| 265 // Close port 0 first, which should have outstanding (incoming) messages. | |
| 266 mp->Close(0); | |
| 267 mp->Close(1); | |
| 268 } | |
| 269 | |
| 270 TEST(MessagePipeTest, DiscardMode) { | |
| 271 scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal()); | |
| 272 | |
| 273 int32_t buffer[2]; | |
| 274 const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer)); | |
| 275 uint32_t buffer_size; | |
| 276 | |
| 277 // Write from port 1 (to port 0). | |
| 278 buffer[0] = 789012345; | |
| 279 buffer[1] = 0; | |
| 280 EXPECT_EQ(MOJO_RESULT_OK, | |
| 281 mp->WriteMessage(1, | |
| 282 UserPointer<const void>(buffer), | |
| 283 static_cast<uint32_t>(sizeof(buffer[0])), | |
| 284 nullptr, | |
| 285 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 286 | |
| 287 // Read/discard from port 0 (no buffer); get size. | |
| 288 buffer_size = 0; | |
| 289 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, | |
| 290 mp->ReadMessage(0, | |
| 291 NullUserPointer(), | |
| 292 MakeUserPointer(&buffer_size), | |
| 293 0, | |
| 294 nullptr, | |
| 295 MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); | |
| 296 EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); | |
| 297 | |
| 298 // Read again from port 0 -- it should be empty. | |
| 299 buffer_size = kBufferSize; | |
| 300 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, | |
| 301 mp->ReadMessage(0, | |
| 302 UserPointer<void>(buffer), | |
| 303 MakeUserPointer(&buffer_size), | |
| 304 0, | |
| 305 nullptr, | |
| 306 MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); | |
| 307 | |
| 308 // Write from port 1 (to port 0). | |
| 309 buffer[0] = 890123456; | |
| 310 buffer[1] = 0; | |
| 311 EXPECT_EQ(MOJO_RESULT_OK, | |
| 312 mp->WriteMessage(1, | |
| 313 UserPointer<const void>(buffer), | |
| 314 static_cast<uint32_t>(sizeof(buffer[0])), | |
| 315 nullptr, | |
| 316 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 317 | |
| 318 // Read from port 0 (buffer big enough). | |
| 319 buffer[0] = 123; | |
| 320 buffer[1] = 456; | |
| 321 buffer_size = kBufferSize; | |
| 322 EXPECT_EQ(MOJO_RESULT_OK, | |
| 323 mp->ReadMessage(0, | |
| 324 UserPointer<void>(buffer), | |
| 325 MakeUserPointer(&buffer_size), | |
| 326 0, | |
| 327 nullptr, | |
| 328 MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); | |
| 329 EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); | |
| 330 EXPECT_EQ(890123456, buffer[0]); | |
| 331 EXPECT_EQ(456, buffer[1]); | |
| 332 | |
| 333 // Read again from port 0 -- it should be empty. | |
| 334 buffer_size = kBufferSize; | |
| 335 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, | |
| 336 mp->ReadMessage(0, | |
| 337 UserPointer<void>(buffer), | |
| 338 MakeUserPointer(&buffer_size), | |
| 339 0, | |
| 340 nullptr, | |
| 341 MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); | |
| 342 | |
| 343 // Write from port 1 (to port 0). | |
| 344 buffer[0] = 901234567; | |
| 345 buffer[1] = 0; | |
| 346 EXPECT_EQ(MOJO_RESULT_OK, | |
| 347 mp->WriteMessage(1, | |
| 348 UserPointer<const void>(buffer), | |
| 349 static_cast<uint32_t>(sizeof(buffer[0])), | |
| 350 nullptr, | |
| 351 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 352 | |
| 353 // Read/discard from port 0 (buffer too small); get size. | |
| 354 buffer_size = 1; | |
| 355 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, | |
| 356 mp->ReadMessage(0, | |
| 357 UserPointer<void>(buffer), | |
| 358 MakeUserPointer(&buffer_size), | |
| 359 0, | |
| 360 nullptr, | |
| 361 MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); | |
| 362 EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); | |
| 363 | |
| 364 // Read again from port 0 -- it should be empty. | |
| 365 buffer_size = kBufferSize; | |
| 366 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, | |
| 367 mp->ReadMessage(0, | |
| 368 UserPointer<void>(buffer), | |
| 369 MakeUserPointer(&buffer_size), | |
| 370 0, | |
| 371 nullptr, | |
| 372 MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); | |
| 373 | |
| 374 // Write from port 1 (to port 0). | |
| 375 buffer[0] = 123456789; | |
| 376 buffer[1] = 0; | |
| 377 EXPECT_EQ(MOJO_RESULT_OK, | |
| 378 mp->WriteMessage(1, | |
| 379 UserPointer<const void>(buffer), | |
| 380 static_cast<uint32_t>(sizeof(buffer[0])), | |
| 381 nullptr, | |
| 382 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 383 | |
| 384 // Discard from port 0. | |
| 385 buffer_size = 1; | |
| 386 EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, | |
| 387 mp->ReadMessage(0, | |
| 388 NullUserPointer(), | |
| 389 NullUserPointer(), | |
| 390 0, | |
| 391 nullptr, | |
| 392 MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); | |
| 393 | |
| 394 // Read again from port 0 -- it should be empty. | |
| 395 buffer_size = kBufferSize; | |
| 396 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, | |
| 397 mp->ReadMessage(0, | |
| 398 UserPointer<void>(buffer), | |
| 399 MakeUserPointer(&buffer_size), | |
| 400 0, | |
| 401 nullptr, | |
| 402 MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); | |
| 403 | |
| 404 mp->Close(0); | |
| 405 mp->Close(1); | |
| 406 } | |
| 407 | |
| 408 TEST(MessagePipeTest, BasicWaiting) { | |
| 409 scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal()); | |
| 410 Waiter waiter; | |
| 411 HandleSignalsState hss; | |
| 412 | |
| 413 int32_t buffer[1]; | |
| 414 const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer)); | |
| 415 uint32_t buffer_size; | |
| 416 | |
| 417 // Always writable (until the other port is closed). | |
| 418 waiter.Init(); | |
| 419 hss = HandleSignalsState(); | |
| 420 EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, | |
| 421 mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss)); | |
| 422 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); | |
| 423 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | |
| 424 hss.satisfiable_signals); | |
| 425 waiter.Init(); | |
| 426 hss = HandleSignalsState(); | |
| 427 EXPECT_EQ( | |
| 428 MOJO_RESULT_ALREADY_EXISTS, | |
| 429 mp->AddWaiter(0, | |
| 430 &waiter, | |
| 431 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | |
| 432 0, | |
| 433 &hss)); | |
| 434 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); | |
| 435 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | |
| 436 hss.satisfiable_signals); | |
| 437 | |
| 438 // Not yet readable. | |
| 439 waiter.Init(); | |
| 440 ASSERT_EQ(MOJO_RESULT_OK, | |
| 441 mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 1, nullptr)); | |
| 442 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr)); | |
| 443 hss = HandleSignalsState(); | |
| 444 mp->RemoveWaiter(0, &waiter, &hss); | |
| 445 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); | |
| 446 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | |
| 447 hss.satisfiable_signals); | |
| 448 | |
| 449 // Write from port 0 (to port 1), to make port 1 readable. | |
| 450 buffer[0] = 123456789; | |
| 451 EXPECT_EQ(MOJO_RESULT_OK, | |
| 452 mp->WriteMessage(0, | |
| 453 UserPointer<const void>(buffer), | |
| 454 kBufferSize, | |
| 455 nullptr, | |
| 456 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 457 | |
| 458 // Port 1 should already be readable now. | |
| 459 waiter.Init(); | |
| 460 hss = HandleSignalsState(); | |
| 461 EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, | |
| 462 mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 2, &hss)); | |
| 463 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | |
| 464 hss.satisfied_signals); | |
| 465 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | |
| 466 hss.satisfiable_signals); | |
| 467 waiter.Init(); | |
| 468 hss = HandleSignalsState(); | |
| 469 EXPECT_EQ( | |
| 470 MOJO_RESULT_ALREADY_EXISTS, | |
| 471 mp->AddWaiter(1, | |
| 472 &waiter, | |
| 473 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | |
| 474 0, | |
| 475 &hss)); | |
| 476 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | |
| 477 hss.satisfied_signals); | |
| 478 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | |
| 479 hss.satisfiable_signals); | |
| 480 // ... and still writable. | |
| 481 waiter.Init(); | |
| 482 hss = HandleSignalsState(); | |
| 483 EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, | |
| 484 mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 3, &hss)); | |
| 485 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | |
| 486 hss.satisfied_signals); | |
| 487 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | |
| 488 hss.satisfiable_signals); | |
| 489 | |
| 490 // Close port 0. | |
| 491 mp->Close(0); | |
| 492 | |
| 493 // Now port 1 should not be writable. | |
| 494 waiter.Init(); | |
| 495 hss = HandleSignalsState(); | |
| 496 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | |
| 497 mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 4, &hss)); | |
| 498 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); | |
| 499 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals); | |
| 500 | |
| 501 // But it should still be readable. | |
| 502 waiter.Init(); | |
| 503 hss = HandleSignalsState(); | |
| 504 EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, | |
| 505 mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 5, &hss)); | |
| 506 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); | |
| 507 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals); | |
| 508 | |
| 509 // Read from port 1. | |
| 510 buffer[0] = 0; | |
| 511 buffer_size = kBufferSize; | |
| 512 EXPECT_EQ(MOJO_RESULT_OK, | |
| 513 mp->ReadMessage(1, | |
| 514 UserPointer<void>(buffer), | |
| 515 MakeUserPointer(&buffer_size), | |
| 516 0, | |
| 517 nullptr, | |
| 518 MOJO_READ_MESSAGE_FLAG_NONE)); | |
| 519 EXPECT_EQ(123456789, buffer[0]); | |
| 520 | |
| 521 // Now port 1 should no longer be readable. | |
| 522 waiter.Init(); | |
| 523 hss = HandleSignalsState(); | |
| 524 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | |
| 525 mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 6, nullptr)); | |
| 526 EXPECT_EQ(0u, hss.satisfied_signals); | |
| 527 EXPECT_EQ(0u, hss.satisfiable_signals); | |
| 528 | |
| 529 mp->Close(1); | |
| 530 } | |
| 531 | |
| 532 TEST(MessagePipeTest, ThreadedWaiting) { | |
| 533 int32_t buffer[1]; | |
| 534 const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer)); | |
| 535 | |
| 536 MojoResult result; | |
| 537 uint32_t context; | |
| 538 | |
| 539 // Write to wake up waiter waiting for read. | |
| 540 { | |
| 541 scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal()); | |
| 542 test::SimpleWaiterThread thread(&result, &context); | |
| 543 | |
| 544 thread.waiter()->Init(); | |
| 545 ASSERT_EQ(MOJO_RESULT_OK, | |
| 546 mp->AddWaiter( | |
| 547 1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1, nullptr)); | |
| 548 thread.Start(); | |
| 549 | |
| 550 buffer[0] = 123456789; | |
| 551 // Write from port 0 (to port 1), which should wake up the waiter. | |
| 552 EXPECT_EQ(MOJO_RESULT_OK, | |
| 553 mp->WriteMessage(0, | |
| 554 UserPointer<const void>(buffer), | |
| 555 kBufferSize, | |
| 556 nullptr, | |
| 557 MOJO_WRITE_MESSAGE_FLAG_NONE)); | |
| 558 | |
| 559 HandleSignalsState hss; | |
| 560 mp->RemoveWaiter(1, thread.waiter(), &hss); | |
| 561 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | |
| 562 hss.satisfied_signals); | |
| 563 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | |
| 564 hss.satisfiable_signals); | |
| 565 | |
| 566 mp->Close(0); | |
| 567 mp->Close(1); | |
| 568 } // Joins |thread|. | |
| 569 // The waiter should have woken up successfully. | |
| 570 EXPECT_EQ(MOJO_RESULT_OK, result); | |
| 571 EXPECT_EQ(1u, context); | |
| 572 | |
| 573 // Close to cancel waiter. | |
| 574 { | |
| 575 scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal()); | |
| 576 test::SimpleWaiterThread thread(&result, &context); | |
| 577 | |
| 578 thread.waiter()->Init(); | |
| 579 ASSERT_EQ(MOJO_RESULT_OK, | |
| 580 mp->AddWaiter( | |
| 581 1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 2, nullptr)); | |
| 582 thread.Start(); | |
| 583 | |
| 584 // Close port 1 first -- this should result in the waiter being cancelled. | |
| 585 mp->CancelAllWaiters(1); | |
| 586 mp->Close(1); | |
| 587 | |
| 588 // Port 1 is closed, so |Dispatcher::RemoveWaiter()| wouldn't call into the | |
| 589 // |MessagePipe| to remove any waiter. | |
| 590 | |
| 591 mp->Close(0); | |
| 592 } // Joins |thread|. | |
| 593 EXPECT_EQ(MOJO_RESULT_CANCELLED, result); | |
| 594 EXPECT_EQ(2u, context); | |
| 595 | |
| 596 // Close to make waiter un-wake-up-able. | |
| 597 { | |
| 598 scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalLocal()); | |
| 599 test::SimpleWaiterThread thread(&result, &context); | |
| 600 | |
| 601 thread.waiter()->Init(); | |
| 602 ASSERT_EQ(MOJO_RESULT_OK, | |
| 603 mp->AddWaiter( | |
| 604 1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3, nullptr)); | |
| 605 thread.Start(); | |
| 606 | |
| 607 // Close port 0 first -- this should wake the waiter up, since port 1 will | |
| 608 // never be readable. | |
| 609 mp->CancelAllWaiters(0); | |
| 610 mp->Close(0); | |
| 611 | |
| 612 HandleSignalsState hss; | |
| 613 mp->RemoveWaiter(1, thread.waiter(), &hss); | |
| 614 EXPECT_EQ(0u, hss.satisfied_signals); | |
| 615 EXPECT_EQ(0u, hss.satisfiable_signals); | |
| 616 | |
| 617 mp->CancelAllWaiters(1); | |
| 618 mp->Close(1); | |
| 619 } // Joins |thread|. | |
| 620 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result); | |
| 621 EXPECT_EQ(3u, context); | |
| 622 } | |
| 623 | |
| 624 } // namespace | |
| 625 } // namespace system | |
| 626 } // namespace mojo | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 621153003:
Move mojo edk into mojo/edk (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master