OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <stddef.h> | 5 #include <stddef.h> |
6 #include <stdint.h> | 6 #include <stdint.h> |
7 | 7 |
8 #include <memory> | 8 #include <memory> |
9 | 9 |
10 #include "base/bind.h" | 10 #include "base/bind.h" |
(...skipping 144 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
155 static_cast<uint32_t>(arraysize(elements) * sizeof(elements[0])); | 155 static_cast<uint32_t>(arraysize(elements) * sizeof(elements[0])); |
156 | 156 |
157 elements[0] = 123; | 157 elements[0] = 123; |
158 elements[1] = 456; | 158 elements[1] = 456; |
159 num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0])); | 159 num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0])); |
160 ASSERT_EQ(MOJO_RESULT_OK, WriteData(&elements[0], &num_bytes)); | 160 ASSERT_EQ(MOJO_RESULT_OK, WriteData(&elements[0], &num_bytes)); |
161 | 161 |
162 // Now wait for the other side to become readable. | 162 // Now wait for the other side to become readable. |
163 MojoHandleSignalsState state; | 163 MojoHandleSignalsState state; |
164 ASSERT_EQ(MOJO_RESULT_OK, | 164 ASSERT_EQ(MOJO_RESULT_OK, |
165 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &state)); | 165 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 166 MOJO_DEADLINE_INDEFINITE, &state)); |
166 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 167 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
167 state.satisfied_signals); | 168 state.satisfied_signals); |
168 | 169 |
169 elements[0] = -1; | 170 elements[0] = -1; |
170 elements[1] = -1; | 171 elements[1] = -1; |
171 ASSERT_EQ(MOJO_RESULT_OK, ReadData(&elements[0], &num_bytes)); | 172 ASSERT_EQ(MOJO_RESULT_OK, ReadData(&elements[0], &num_bytes)); |
172 ASSERT_EQ(static_cast<uint32_t>(2u * sizeof(elements[0])), num_bytes); | 173 ASSERT_EQ(static_cast<uint32_t>(2u * sizeof(elements[0])), num_bytes); |
173 ASSERT_EQ(elements[0], 123); | 174 ASSERT_EQ(elements[0], 123); |
174 ASSERT_EQ(elements[1], 456); | 175 ASSERT_EQ(elements[1], 456); |
175 } | 176 } |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
241 // Write two elements. | 242 // Write two elements. |
242 elements[0] = 123; | 243 elements[0] = 123; |
243 elements[1] = 456; | 244 elements[1] = 456; |
244 num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0])); | 245 num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0])); |
245 ASSERT_EQ(MOJO_RESULT_OK, WriteData(elements, &num_bytes)); | 246 ASSERT_EQ(MOJO_RESULT_OK, WriteData(elements, &num_bytes)); |
246 // It should have written everything (even without "all or none"). | 247 // It should have written everything (even without "all or none"). |
247 ASSERT_EQ(2u * sizeof(elements[0]), num_bytes); | 248 ASSERT_EQ(2u * sizeof(elements[0]), num_bytes); |
248 | 249 |
249 // Wait. | 250 // Wait. |
250 ASSERT_EQ(MOJO_RESULT_OK, | 251 ASSERT_EQ(MOJO_RESULT_OK, |
251 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 252 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 253 MOJO_DEADLINE_INDEFINITE, &hss)); |
252 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 254 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
253 hss.satisfied_signals); | 255 hss.satisfied_signals); |
254 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 256 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
255 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 257 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
256 hss.satisfiable_signals); | 258 hss.satisfiable_signals); |
257 | 259 |
258 // Query. | 260 // Query. |
259 // TODO(vtl): It's theoretically possible (though not with the current | 261 // TODO(vtl): It's theoretically possible (though not with the current |
260 // implementation/configured limits) that not all the data has arrived yet. | 262 // implementation/configured limits) that not all the data has arrived yet. |
261 // (The theoretically-correct assertion here is that |num_bytes| is |1 * ...| | 263 // (The theoretically-correct assertion here is that |num_bytes| is |1 * ...| |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
328 | 330 |
329 const MojoCreateDataPipeOptions options = { | 331 const MojoCreateDataPipeOptions options = { |
330 kSizeOfOptions, // |struct_size|. | 332 kSizeOfOptions, // |struct_size|. |
331 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. | 333 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. |
332 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. | 334 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. |
333 2 * sizeof(int32_t) // |capacity_num_bytes|. | 335 2 * sizeof(int32_t) // |capacity_num_bytes|. |
334 }; | 336 }; |
335 Create(&options); | 337 Create(&options); |
336 MojoHandleSignalsState hss; | 338 MojoHandleSignalsState hss; |
337 | 339 |
338 // Never readable. Already writable. | 340 // Never readable. |
339 hss = GetSignalsState(producer_); | 341 hss = MojoHandleSignalsState(); |
| 342 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
| 343 MojoWait(producer_, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss)); |
340 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); | 344 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); |
341 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 345 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
342 hss.satisfiable_signals); | 346 hss.satisfiable_signals); |
343 | 347 |
| 348 // Already writable. |
| 349 hss = MojoHandleSignalsState(); |
| 350 ASSERT_EQ(MOJO_RESULT_OK, |
| 351 MojoWait(producer_, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss)); |
| 352 |
344 // Write two elements. | 353 // Write two elements. |
345 int32_t elements[2] = {123, 456}; | 354 int32_t elements[2] = {123, 456}; |
346 uint32_t num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0])); | 355 uint32_t num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0])); |
347 ASSERT_EQ(MOJO_RESULT_OK, WriteData(elements, &num_bytes, true)); | 356 ASSERT_EQ(MOJO_RESULT_OK, WriteData(elements, &num_bytes, true)); |
348 ASSERT_EQ(static_cast<uint32_t>(2u * sizeof(elements[0])), num_bytes); | 357 ASSERT_EQ(static_cast<uint32_t>(2u * sizeof(elements[0])), num_bytes); |
349 | 358 |
350 // Wait for data to become available to the consumer. | 359 // Wait for data to become available to the consumer. |
351 ASSERT_EQ(MOJO_RESULT_OK, | 360 ASSERT_EQ(MOJO_RESULT_OK, |
352 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 361 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 362 MOJO_DEADLINE_INDEFINITE, &hss)); |
353 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 363 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
354 hss.satisfied_signals); | 364 hss.satisfied_signals); |
355 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 365 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
356 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 366 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
357 hss.satisfiable_signals); | 367 hss.satisfiable_signals); |
358 | 368 |
359 // Peek one element. | 369 // Peek one element. |
360 elements[0] = -1; | 370 elements[0] = -1; |
361 elements[1] = -1; | 371 elements[1] = -1; |
362 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); | 372 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
402 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); | 412 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); |
403 ASSERT_EQ(MOJO_RESULT_OK, WriteData(elements, &num_bytes)); | 413 ASSERT_EQ(MOJO_RESULT_OK, WriteData(elements, &num_bytes)); |
404 ASSERT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); | 414 ASSERT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); |
405 | 415 |
406 // Close the consumer. | 416 // Close the consumer. |
407 CloseConsumer(); | 417 CloseConsumer(); |
408 | 418 |
409 // It should now be never-writable. | 419 // It should now be never-writable. |
410 hss = MojoHandleSignalsState(); | 420 hss = MojoHandleSignalsState(); |
411 ASSERT_EQ(MOJO_RESULT_OK, | 421 ASSERT_EQ(MOJO_RESULT_OK, |
412 WaitForSignals(producer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, &hss)); | 422 MojoWait(producer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| 423 MOJO_DEADLINE_INDEFINITE, &hss)); |
| 424 hss = MojoHandleSignalsState(); |
| 425 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
| 426 MojoWait(producer_, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss)); |
413 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); | 427 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); |
414 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); | 428 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); |
415 } | 429 } |
416 | 430 |
417 TEST_F(DataPipeTest, PeerClosedProducerWaiting) { | 431 TEST_F(DataPipeTest, PeerClosedProducerWaiting) { |
418 const MojoCreateDataPipeOptions options = { | 432 const MojoCreateDataPipeOptions options = { |
419 kSizeOfOptions, // |struct_size|. | 433 kSizeOfOptions, // |struct_size|. |
420 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. | 434 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. |
421 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. | 435 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. |
422 2 * sizeof(int32_t) // |capacity_num_bytes|. | 436 2 * sizeof(int32_t) // |capacity_num_bytes|. |
423 }; | 437 }; |
424 ASSERT_EQ(MOJO_RESULT_OK, Create(&options)); | 438 ASSERT_EQ(MOJO_RESULT_OK, Create(&options)); |
425 MojoHandleSignalsState hss; | 439 MojoHandleSignalsState hss; |
426 | 440 |
427 // Close the consumer. | 441 // Close the consumer. |
428 CloseConsumer(); | 442 CloseConsumer(); |
429 | 443 |
430 // It should be signaled. | 444 // It should be signaled. |
431 hss = MojoHandleSignalsState(); | 445 hss = MojoHandleSignalsState(); |
432 ASSERT_EQ(MOJO_RESULT_OK, | 446 ASSERT_EQ(MOJO_RESULT_OK, |
433 WaitForSignals(producer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, &hss)); | 447 MojoWait(producer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| 448 MOJO_DEADLINE_INDEFINITE, &hss)); |
434 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); | 449 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); |
435 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); | 450 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); |
436 } | 451 } |
437 | 452 |
438 TEST_F(DataPipeTest, PeerClosedConsumerWaiting) { | 453 TEST_F(DataPipeTest, PeerClosedConsumerWaiting) { |
439 const MojoCreateDataPipeOptions options = { | 454 const MojoCreateDataPipeOptions options = { |
440 kSizeOfOptions, // |struct_size|. | 455 kSizeOfOptions, // |struct_size|. |
441 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. | 456 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. |
442 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. | 457 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. |
443 2 * sizeof(int32_t) // |capacity_num_bytes|. | 458 2 * sizeof(int32_t) // |capacity_num_bytes|. |
444 }; | 459 }; |
445 ASSERT_EQ(MOJO_RESULT_OK, Create(&options)); | 460 ASSERT_EQ(MOJO_RESULT_OK, Create(&options)); |
446 MojoHandleSignalsState hss; | 461 MojoHandleSignalsState hss; |
447 | 462 |
448 // Close the producer. | 463 // Close the producer. |
449 CloseProducer(); | 464 CloseProducer(); |
450 | 465 |
451 // It should be signaled. | 466 // It should be signaled. |
452 hss = MojoHandleSignalsState(); | 467 hss = MojoHandleSignalsState(); |
453 ASSERT_EQ(MOJO_RESULT_OK, | 468 ASSERT_EQ(MOJO_RESULT_OK, |
454 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, &hss)); | 469 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| 470 MOJO_DEADLINE_INDEFINITE, &hss)); |
455 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); | 471 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); |
456 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); | 472 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); |
457 } | 473 } |
458 | 474 |
459 TEST_F(DataPipeTest, BasicConsumerWaiting) { | 475 TEST_F(DataPipeTest, BasicConsumerWaiting) { |
460 const MojoCreateDataPipeOptions options = { | 476 const MojoCreateDataPipeOptions options = { |
461 kSizeOfOptions, // |struct_size|. | 477 kSizeOfOptions, // |struct_size|. |
462 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. | 478 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. |
463 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. | 479 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. |
464 1000 * sizeof(int32_t) // |capacity_num_bytes|. | 480 1000 * sizeof(int32_t) // |capacity_num_bytes|. |
465 }; | 481 }; |
466 ASSERT_EQ(MOJO_RESULT_OK, Create(&options)); | 482 ASSERT_EQ(MOJO_RESULT_OK, Create(&options)); |
467 MojoHandleSignalsState hss; | 483 MojoHandleSignalsState hss; |
468 | 484 |
469 // Never writable. | 485 // Never writable. |
470 hss = MojoHandleSignalsState(); | 486 hss = MojoHandleSignalsState(); |
471 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | 487 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
472 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_WRITABLE, &hss)); | 488 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_WRITABLE, |
| 489 MOJO_DEADLINE_INDEFINITE, &hss)); |
473 EXPECT_EQ(0u, hss.satisfied_signals); | 490 EXPECT_EQ(0u, hss.satisfied_signals); |
474 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 491 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
475 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 492 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
476 hss.satisfiable_signals); | 493 hss.satisfiable_signals); |
477 | 494 |
478 // Write two elements. | 495 // Write two elements. |
479 int32_t elements[2] = {123, 456}; | 496 int32_t elements[2] = {123, 456}; |
480 uint32_t num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0])); | 497 uint32_t num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0])); |
481 ASSERT_EQ(MOJO_RESULT_OK, WriteData(elements, &num_bytes, true)); | 498 ASSERT_EQ(MOJO_RESULT_OK, WriteData(elements, &num_bytes, true)); |
482 | 499 |
483 // Wait for readability. | 500 // Wait for readability. |
484 hss = MojoHandleSignalsState(); | 501 hss = MojoHandleSignalsState(); |
485 ASSERT_EQ(MOJO_RESULT_OK, | 502 ASSERT_EQ(MOJO_RESULT_OK, |
486 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 503 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 504 MOJO_DEADLINE_INDEFINITE, &hss)); |
487 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 505 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
488 hss.satisfied_signals); | 506 hss.satisfied_signals); |
489 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 507 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
490 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 508 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
491 hss.satisfiable_signals); | 509 hss.satisfiable_signals); |
492 | 510 |
493 // Discard one element. | 511 // Discard one element. |
494 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); | 512 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); |
495 ASSERT_EQ(MOJO_RESULT_OK, DiscardData(&num_bytes, true)); | 513 ASSERT_EQ(MOJO_RESULT_OK, DiscardData(&num_bytes, true)); |
496 ASSERT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); | 514 ASSERT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); |
497 | 515 |
498 // Should still be readable. | 516 // Should still be readable. |
499 hss = MojoHandleSignalsState(); | 517 hss = MojoHandleSignalsState(); |
500 ASSERT_EQ(MOJO_RESULT_OK, | 518 ASSERT_EQ(MOJO_RESULT_OK, |
501 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 519 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 520 MOJO_DEADLINE_INDEFINITE, &hss)); |
502 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); | 521 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); |
503 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 522 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
504 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 523 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
505 hss.satisfiable_signals); | 524 hss.satisfiable_signals); |
506 | 525 |
507 // Peek one element. | 526 // Peek one element. |
508 elements[0] = -1; | 527 elements[0] = -1; |
509 elements[1] = -1; | 528 elements[1] = -1; |
510 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); | 529 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); |
511 ASSERT_EQ(MOJO_RESULT_OK, ReadData(elements, &num_bytes, true, true)); | 530 ASSERT_EQ(MOJO_RESULT_OK, ReadData(elements, &num_bytes, true, true)); |
512 ASSERT_EQ(456, elements[0]); | 531 ASSERT_EQ(456, elements[0]); |
513 ASSERT_EQ(-1, elements[1]); | 532 ASSERT_EQ(-1, elements[1]); |
514 | 533 |
515 // Should still be readable. | 534 // Should still be readable. |
516 hss = MojoHandleSignalsState(); | 535 hss = MojoHandleSignalsState(); |
517 ASSERT_EQ(MOJO_RESULT_OK, | 536 ASSERT_EQ(MOJO_RESULT_OK, |
518 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 537 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 538 MOJO_DEADLINE_INDEFINITE, &hss)); |
519 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); | 539 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); |
520 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 540 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
521 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 541 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
522 hss.satisfiable_signals); | 542 hss.satisfiable_signals); |
523 | 543 |
524 // Read one element. | 544 // Read one element. |
525 elements[0] = -1; | 545 elements[0] = -1; |
526 elements[1] = -1; | 546 elements[1] = -1; |
527 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); | 547 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); |
528 ASSERT_EQ(MOJO_RESULT_OK, ReadData(elements, &num_bytes, true)); | 548 ASSERT_EQ(MOJO_RESULT_OK, ReadData(elements, &num_bytes, true)); |
529 ASSERT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); | 549 ASSERT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); |
530 ASSERT_EQ(456, elements[0]); | 550 ASSERT_EQ(456, elements[0]); |
531 ASSERT_EQ(-1, elements[1]); | 551 ASSERT_EQ(-1, elements[1]); |
532 | 552 |
533 // Write one element. | 553 // Write one element. |
534 elements[0] = 789; | 554 elements[0] = 789; |
535 elements[1] = -1; | 555 elements[1] = -1; |
536 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); | 556 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); |
537 ASSERT_EQ(MOJO_RESULT_OK, WriteData(elements, &num_bytes, true)); | 557 ASSERT_EQ(MOJO_RESULT_OK, WriteData(elements, &num_bytes, true)); |
538 | 558 |
539 // Waiting should now succeed. | 559 // Waiting should now succeed. |
540 hss = MojoHandleSignalsState(); | 560 hss = MojoHandleSignalsState(); |
541 ASSERT_EQ(MOJO_RESULT_OK, | 561 ASSERT_EQ(MOJO_RESULT_OK, |
542 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 562 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 563 MOJO_DEADLINE_INDEFINITE, &hss)); |
543 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 564 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
544 hss.satisfied_signals); | 565 hss.satisfied_signals); |
545 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 566 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
546 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 567 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
547 hss.satisfiable_signals); | 568 hss.satisfiable_signals); |
548 | 569 |
549 // Close the producer. | 570 // Close the producer. |
550 CloseProducer(); | 571 CloseProducer(); |
551 | 572 |
552 // Should still be readable. | 573 // Should still be readable. |
553 hss = MojoHandleSignalsState(); | 574 hss = MojoHandleSignalsState(); |
554 ASSERT_EQ(MOJO_RESULT_OK, | 575 ASSERT_EQ(MOJO_RESULT_OK, |
555 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 576 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 577 MOJO_DEADLINE_INDEFINITE, &hss)); |
556 EXPECT_TRUE(hss.satisfied_signals & (MOJO_HANDLE_SIGNAL_READABLE | | 578 EXPECT_TRUE(hss.satisfied_signals & (MOJO_HANDLE_SIGNAL_READABLE | |
557 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE)); | 579 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE)); |
558 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 580 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
559 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 581 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
560 hss.satisfiable_signals); | 582 hss.satisfiable_signals); |
561 | 583 |
562 // Wait for the peer closed signal. | 584 // Wait for the peer closed signal. |
563 hss = MojoHandleSignalsState(); | 585 hss = MojoHandleSignalsState(); |
564 ASSERT_EQ(MOJO_RESULT_OK, | 586 ASSERT_EQ(MOJO_RESULT_OK, |
565 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, &hss)); | 587 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| 588 MOJO_DEADLINE_INDEFINITE, &hss)); |
566 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE | | 589 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE | |
567 MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 590 MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
568 hss.satisfied_signals); | 591 hss.satisfied_signals); |
569 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 592 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
570 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 593 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
571 hss.satisfiable_signals); | 594 hss.satisfiable_signals); |
572 | 595 |
573 // Read one element. | 596 // Read one element. |
574 elements[0] = -1; | 597 elements[0] = -1; |
575 elements[1] = -1; | 598 elements[1] = -1; |
576 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); | 599 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); |
577 ASSERT_EQ(MOJO_RESULT_OK, ReadData(elements, &num_bytes, true)); | 600 ASSERT_EQ(MOJO_RESULT_OK, ReadData(elements, &num_bytes, true)); |
578 ASSERT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); | 601 ASSERT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); |
579 ASSERT_EQ(789, elements[0]); | 602 ASSERT_EQ(789, elements[0]); |
580 ASSERT_EQ(-1, elements[1]); | 603 ASSERT_EQ(-1, elements[1]); |
581 | 604 |
582 // Should be never-readable. | 605 // Should be never-readable. |
583 hss = MojoHandleSignalsState(); | 606 hss = MojoHandleSignalsState(); |
584 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | 607 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
585 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 608 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 609 MOJO_DEADLINE_INDEFINITE, &hss)); |
586 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); | 610 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); |
587 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); | 611 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); |
588 } | 612 } |
589 | 613 |
590 TEST_F(DataPipeTest, ConsumerNewDataReadable) { | 614 TEST_F(DataPipeTest, ConsumerNewDataReadable) { |
591 const MojoCreateDataPipeOptions options = { | 615 const MojoCreateDataPipeOptions options = { |
592 kSizeOfOptions, // |struct_size|. | 616 kSizeOfOptions, // |struct_size|. |
593 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. | 617 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. |
594 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. | 618 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. |
595 1000 * sizeof(int32_t) // |capacity_num_bytes|. | 619 1000 * sizeof(int32_t) // |capacity_num_bytes|. |
596 }; | 620 }; |
597 EXPECT_EQ(MOJO_RESULT_OK, Create(&options)); | 621 EXPECT_EQ(MOJO_RESULT_OK, Create(&options)); |
598 | 622 |
599 int32_t elements[2] = {123, 456}; | 623 int32_t elements[2] = {123, 456}; |
600 uint32_t num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0])); | 624 uint32_t num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0])); |
601 EXPECT_EQ(MOJO_RESULT_OK, WriteData(elements, &num_bytes, true)); | 625 EXPECT_EQ(MOJO_RESULT_OK, WriteData(elements, &num_bytes, true)); |
602 | 626 |
603 // The consumer handle should appear to be readable and have new data. | 627 // The consumer handle should appear to be readable and have new data. |
| 628 EXPECT_EQ(MOJO_RESULT_OK, MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 629 MOJO_DEADLINE_INDEFINITE, nullptr)); |
604 EXPECT_EQ(MOJO_RESULT_OK, | 630 EXPECT_EQ(MOJO_RESULT_OK, |
605 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE)); | 631 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
606 EXPECT_TRUE(GetSignalsState(consumer_).satisfied_signals & | 632 MOJO_DEADLINE_INDEFINITE, nullptr)); |
607 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE); | |
608 | 633 |
609 // Now try to read a minimum of 6 elements. | 634 // Now try to read a minimum of 6 elements. |
610 int32_t read_elements[6]; | 635 int32_t read_elements[6]; |
611 uint32_t num_read_bytes = sizeof(read_elements); | 636 uint32_t num_read_bytes = sizeof(read_elements); |
612 EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, | 637 EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, |
613 MojoReadData(consumer_, read_elements, &num_read_bytes, | 638 MojoReadData(consumer_, read_elements, &num_read_bytes, |
614 MOJO_READ_DATA_FLAG_ALL_OR_NONE)); | 639 MOJO_READ_DATA_FLAG_ALL_OR_NONE)); |
615 | 640 |
616 // The consumer should still appear to be readable but not with new data. | 641 // The consumer should still appear to be readable, but not with new data. |
617 EXPECT_TRUE(GetSignalsState(consumer_).satisfied_signals & | 642 EXPECT_EQ(MOJO_RESULT_OK, |
618 MOJO_HANDLE_SIGNAL_READABLE); | 643 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, 0, nullptr)); |
619 EXPECT_FALSE(GetSignalsState(consumer_).satisfied_signals & | 644 EXPECT_EQ( |
620 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE); | 645 MOJO_RESULT_DEADLINE_EXCEEDED, |
| 646 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, 0, nullptr)); |
621 | 647 |
622 // Write four more elements. | 648 // Write four more elements. |
623 EXPECT_EQ(MOJO_RESULT_OK, WriteData(elements, &num_bytes, true)); | 649 EXPECT_EQ(MOJO_RESULT_OK, WriteData(elements, &num_bytes, true)); |
624 EXPECT_EQ(MOJO_RESULT_OK, WriteData(elements, &num_bytes, true)); | 650 EXPECT_EQ(MOJO_RESULT_OK, WriteData(elements, &num_bytes, true)); |
625 | 651 |
626 // The consumer handle should once again appear to be readable. | 652 // The consumer handle should once again appear to be readable with new data. |
| 653 EXPECT_EQ(MOJO_RESULT_OK, MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 654 MOJO_DEADLINE_INDEFINITE, nullptr)); |
627 EXPECT_EQ(MOJO_RESULT_OK, | 655 EXPECT_EQ(MOJO_RESULT_OK, |
628 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE)); | 656 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
| 657 MOJO_DEADLINE_INDEFINITE, nullptr)); |
629 | 658 |
630 // Try again to read a minimum of 6 elements. Should succeed this time. | 659 // Read should succeed this time. |
631 EXPECT_EQ(MOJO_RESULT_OK, | 660 EXPECT_EQ(MOJO_RESULT_OK, |
632 MojoReadData(consumer_, read_elements, &num_read_bytes, | 661 MojoReadData(consumer_, read_elements, &num_read_bytes, |
633 MOJO_READ_DATA_FLAG_ALL_OR_NONE)); | 662 MOJO_READ_DATA_FLAG_ALL_OR_NONE)); |
634 | 663 |
635 // And now the consumer is unreadable. | 664 // And once again the consumer is unreadable. |
636 EXPECT_FALSE(GetSignalsState(consumer_).satisfied_signals & | 665 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, |
637 MOJO_HANDLE_SIGNAL_READABLE); | 666 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, 0, nullptr)); |
638 EXPECT_FALSE(GetSignalsState(consumer_).satisfied_signals & | 667 EXPECT_EQ( |
639 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE); | 668 MOJO_RESULT_DEADLINE_EXCEEDED, |
| 669 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, 0, nullptr)); |
640 } | 670 } |
641 | 671 |
642 // Test with two-phase APIs and also closing the producer with an active | 672 // Test with two-phase APIs and also closing the producer with an active |
643 // consumer waiter. | 673 // consumer waiter. |
644 TEST_F(DataPipeTest, ConsumerWaitingTwoPhase) { | 674 TEST_F(DataPipeTest, ConsumerWaitingTwoPhase) { |
645 const MojoCreateDataPipeOptions options = { | 675 const MojoCreateDataPipeOptions options = { |
646 kSizeOfOptions, // |struct_size|. | 676 kSizeOfOptions, // |struct_size|. |
647 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. | 677 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. |
648 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. | 678 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. |
649 1000 * sizeof(int32_t) // |capacity_num_bytes|. | 679 1000 * sizeof(int32_t) // |capacity_num_bytes|. |
(...skipping 10 matching lines...) Expand all Loading... |
660 EXPECT_TRUE(buffer); | 690 EXPECT_TRUE(buffer); |
661 EXPECT_GE(num_bytes, static_cast<uint32_t>(3u * sizeof(elements[0]))); | 691 EXPECT_GE(num_bytes, static_cast<uint32_t>(3u * sizeof(elements[0]))); |
662 elements = static_cast<int32_t*>(buffer); | 692 elements = static_cast<int32_t*>(buffer); |
663 elements[0] = 123; | 693 elements[0] = 123; |
664 elements[1] = 456; | 694 elements[1] = 456; |
665 ASSERT_EQ(MOJO_RESULT_OK, EndWriteData(2u * sizeof(elements[0]))); | 695 ASSERT_EQ(MOJO_RESULT_OK, EndWriteData(2u * sizeof(elements[0]))); |
666 | 696 |
667 // Wait for readability. | 697 // Wait for readability. |
668 hss = MojoHandleSignalsState(); | 698 hss = MojoHandleSignalsState(); |
669 ASSERT_EQ(MOJO_RESULT_OK, | 699 ASSERT_EQ(MOJO_RESULT_OK, |
670 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 700 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 701 MOJO_DEADLINE_INDEFINITE, &hss)); |
671 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 702 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
672 hss.satisfied_signals); | 703 hss.satisfied_signals); |
673 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 704 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
674 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 705 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
675 hss.satisfiable_signals); | 706 hss.satisfiable_signals); |
676 | 707 |
677 // Read one element. | 708 // Read one element. |
678 // Request two in all-or-none mode, but only read one. | 709 // Request two in all-or-none mode, but only read one. |
679 const void* read_buffer = nullptr; | 710 const void* read_buffer = nullptr; |
680 num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0])); | 711 num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0])); |
681 ASSERT_EQ(MOJO_RESULT_OK, BeginReadData(&read_buffer, &num_bytes, true)); | 712 ASSERT_EQ(MOJO_RESULT_OK, BeginReadData(&read_buffer, &num_bytes, true)); |
682 EXPECT_TRUE(read_buffer); | 713 EXPECT_TRUE(read_buffer); |
683 ASSERT_EQ(static_cast<uint32_t>(2u * sizeof(elements[0])), num_bytes); | 714 ASSERT_EQ(static_cast<uint32_t>(2u * sizeof(elements[0])), num_bytes); |
684 const int32_t* read_elements = static_cast<const int32_t*>(read_buffer); | 715 const int32_t* read_elements = static_cast<const int32_t*>(read_buffer); |
685 ASSERT_EQ(123, read_elements[0]); | 716 ASSERT_EQ(123, read_elements[0]); |
686 ASSERT_EQ(MOJO_RESULT_OK, EndReadData(1u * sizeof(elements[0]))); | 717 ASSERT_EQ(MOJO_RESULT_OK, EndReadData(1u * sizeof(elements[0]))); |
687 | 718 |
688 // Should still be readable. | 719 // Should still be readable. |
689 hss = MojoHandleSignalsState(); | 720 hss = MojoHandleSignalsState(); |
690 ASSERT_EQ(MOJO_RESULT_OK, | 721 ASSERT_EQ(MOJO_RESULT_OK, |
691 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 722 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 723 MOJO_DEADLINE_INDEFINITE, &hss)); |
692 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); | 724 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); |
693 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 725 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
694 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 726 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
695 hss.satisfiable_signals); | 727 hss.satisfiable_signals); |
696 | 728 |
697 // Read one element. | 729 // Read one element. |
698 // Request three, but not in all-or-none mode. | 730 // Request three, but not in all-or-none mode. |
699 read_buffer = nullptr; | 731 read_buffer = nullptr; |
700 num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0])); | 732 num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0])); |
701 ASSERT_EQ(MOJO_RESULT_OK, BeginReadData(&read_buffer, &num_bytes)); | 733 ASSERT_EQ(MOJO_RESULT_OK, BeginReadData(&read_buffer, &num_bytes)); |
702 EXPECT_TRUE(read_buffer); | 734 EXPECT_TRUE(read_buffer); |
703 ASSERT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); | 735 ASSERT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); |
704 read_elements = static_cast<const int32_t*>(read_buffer); | 736 read_elements = static_cast<const int32_t*>(read_buffer); |
705 ASSERT_EQ(456, read_elements[0]); | 737 ASSERT_EQ(456, read_elements[0]); |
706 ASSERT_EQ(MOJO_RESULT_OK, EndReadData(1u * sizeof(elements[0]))); | 738 ASSERT_EQ(MOJO_RESULT_OK, EndReadData(1u * sizeof(elements[0]))); |
707 | 739 |
708 // Close the producer. | 740 // Close the producer. |
709 CloseProducer(); | 741 CloseProducer(); |
710 | 742 |
711 // Should be never-readable. | 743 // Should be never-readable. |
712 hss = MojoHandleSignalsState(); | 744 hss = MojoHandleSignalsState(); |
713 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | 745 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
714 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 746 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 747 MOJO_DEADLINE_INDEFINITE, &hss)); |
715 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); | 748 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); |
716 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); | 749 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); |
717 } | 750 } |
718 | 751 |
719 // Tests that data pipes aren't writable/readable during two-phase writes/reads. | 752 // Tests that data pipes aren't writable/readable during two-phase writes/reads. |
720 TEST_F(DataPipeTest, BasicTwoPhaseWaiting) { | 753 TEST_F(DataPipeTest, BasicTwoPhaseWaiting) { |
721 const MojoCreateDataPipeOptions options = { | 754 const MojoCreateDataPipeOptions options = { |
722 kSizeOfOptions, // |struct_size|. | 755 kSizeOfOptions, // |struct_size|. |
723 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. | 756 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. |
724 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. | 757 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. |
725 1000 * sizeof(int32_t) // |capacity_num_bytes|. | 758 1000 * sizeof(int32_t) // |capacity_num_bytes|. |
726 }; | 759 }; |
727 ASSERT_EQ(MOJO_RESULT_OK, Create(&options)); | 760 ASSERT_EQ(MOJO_RESULT_OK, Create(&options)); |
728 MojoHandleSignalsState hss; | 761 MojoHandleSignalsState hss; |
729 | 762 |
730 // It should be writable. | 763 // It should be writable. |
731 hss = GetSignalsState(producer_); | 764 hss = MojoHandleSignalsState(); |
| 765 ASSERT_EQ(MOJO_RESULT_OK, |
| 766 MojoWait(producer_, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss)); |
732 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); | 767 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); |
733 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 768 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
734 hss.satisfiable_signals); | 769 hss.satisfiable_signals); |
735 | 770 |
736 uint32_t num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t)); | 771 uint32_t num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t)); |
737 void* write_ptr = nullptr; | 772 void* write_ptr = nullptr; |
738 ASSERT_EQ(MOJO_RESULT_OK, BeginWriteData(&write_ptr, &num_bytes)); | 773 ASSERT_EQ(MOJO_RESULT_OK, BeginWriteData(&write_ptr, &num_bytes)); |
739 EXPECT_TRUE(write_ptr); | 774 EXPECT_TRUE(write_ptr); |
740 EXPECT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(int32_t))); | 775 EXPECT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(int32_t))); |
741 | 776 |
742 // At this point, it shouldn't be writable. | 777 // At this point, it shouldn't be writable. |
743 hss = GetSignalsState(producer_); | 778 hss = MojoHandleSignalsState(); |
| 779 ASSERT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, |
| 780 MojoWait(producer_, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss)); |
744 ASSERT_EQ(0u, hss.satisfied_signals); | 781 ASSERT_EQ(0u, hss.satisfied_signals); |
745 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 782 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
746 hss.satisfiable_signals); | 783 hss.satisfiable_signals); |
747 | 784 |
748 // It shouldn't be readable yet either (we'll wait later). | 785 // It shouldn't be readable yet either (we'll wait later). |
749 hss = GetSignalsState(consumer_); | 786 hss = MojoHandleSignalsState(); |
| 787 ASSERT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, |
| 788 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss)); |
750 ASSERT_EQ(0u, hss.satisfied_signals); | 789 ASSERT_EQ(0u, hss.satisfied_signals); |
751 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 790 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
752 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 791 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
753 hss.satisfiable_signals); | 792 hss.satisfiable_signals); |
754 | 793 |
755 static_cast<int32_t*>(write_ptr)[0] = 123; | 794 static_cast<int32_t*>(write_ptr)[0] = 123; |
756 ASSERT_EQ(MOJO_RESULT_OK, EndWriteData(1u * sizeof(int32_t))); | 795 ASSERT_EQ(MOJO_RESULT_OK, EndWriteData(1u * sizeof(int32_t))); |
757 | 796 |
758 // It should immediately be writable again. | 797 // It should immediately be writable again. |
759 hss = GetSignalsState(producer_); | 798 hss = MojoHandleSignalsState(); |
| 799 ASSERT_EQ(MOJO_RESULT_OK, |
| 800 MojoWait(producer_, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss)); |
760 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); | 801 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); |
761 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 802 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
762 hss.satisfiable_signals); | 803 hss.satisfiable_signals); |
763 | 804 |
764 // It should become readable. | 805 // It should become readable. |
765 hss = MojoHandleSignalsState(); | 806 hss = MojoHandleSignalsState(); |
766 ASSERT_EQ(MOJO_RESULT_OK, | 807 ASSERT_EQ(MOJO_RESULT_OK, |
767 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 808 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 809 MOJO_DEADLINE_INDEFINITE, &hss)); |
768 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 810 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
769 hss.satisfied_signals); | 811 hss.satisfied_signals); |
770 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 812 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
771 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 813 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
772 hss.satisfiable_signals); | 814 hss.satisfiable_signals); |
773 | 815 |
774 // Start another two-phase write and check that it's readable even in the | 816 // Start another two-phase write and check that it's readable even in the |
775 // middle of it. | 817 // middle of it. |
776 num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t)); | 818 num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t)); |
777 write_ptr = nullptr; | 819 write_ptr = nullptr; |
778 ASSERT_EQ(MOJO_RESULT_OK, BeginWriteData(&write_ptr, &num_bytes)); | 820 ASSERT_EQ(MOJO_RESULT_OK, BeginWriteData(&write_ptr, &num_bytes)); |
779 EXPECT_TRUE(write_ptr); | 821 EXPECT_TRUE(write_ptr); |
780 EXPECT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(int32_t))); | 822 EXPECT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(int32_t))); |
781 | 823 |
782 // It should be readable. | 824 // It should be readable. |
783 hss = MojoHandleSignalsState(); | 825 hss = MojoHandleSignalsState(); |
784 ASSERT_EQ(MOJO_RESULT_OK, | 826 ASSERT_EQ(MOJO_RESULT_OK, |
785 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 827 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 828 MOJO_DEADLINE_INDEFINITE, &hss)); |
786 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 829 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
787 hss.satisfied_signals); | 830 hss.satisfied_signals); |
788 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 831 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
789 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 832 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
790 hss.satisfiable_signals); | 833 hss.satisfiable_signals); |
791 | 834 |
792 // End the two-phase write without writing anything. | 835 // End the two-phase write without writing anything. |
793 ASSERT_EQ(MOJO_RESULT_OK, EndWriteData(0u)); | 836 ASSERT_EQ(MOJO_RESULT_OK, EndWriteData(0u)); |
794 | 837 |
795 // Start a two-phase read. | 838 // Start a two-phase read. |
796 num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t)); | 839 num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t)); |
797 const void* read_ptr = nullptr; | 840 const void* read_ptr = nullptr; |
798 ASSERT_EQ(MOJO_RESULT_OK, BeginReadData(&read_ptr, &num_bytes)); | 841 ASSERT_EQ(MOJO_RESULT_OK, BeginReadData(&read_ptr, &num_bytes)); |
799 EXPECT_TRUE(read_ptr); | 842 EXPECT_TRUE(read_ptr); |
800 ASSERT_EQ(static_cast<uint32_t>(1u * sizeof(int32_t)), num_bytes); | 843 ASSERT_EQ(static_cast<uint32_t>(1u * sizeof(int32_t)), num_bytes); |
801 | 844 |
802 // At this point, it should still be writable. | 845 // At this point, it should still be writable. |
803 hss = GetSignalsState(producer_); | 846 hss = MojoHandleSignalsState(); |
| 847 ASSERT_EQ(MOJO_RESULT_OK, |
| 848 MojoWait(producer_, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss)); |
804 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); | 849 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); |
805 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 850 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
806 hss.satisfiable_signals); | 851 hss.satisfiable_signals); |
807 | 852 |
808 // But not readable. | 853 // But not readable. |
809 hss = GetSignalsState(consumer_); | 854 hss = MojoHandleSignalsState(); |
| 855 ASSERT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, |
| 856 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss)); |
810 ASSERT_EQ(0u, hss.satisfied_signals); | 857 ASSERT_EQ(0u, hss.satisfied_signals); |
811 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 858 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
812 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 859 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
813 hss.satisfiable_signals); | 860 hss.satisfiable_signals); |
814 | 861 |
815 // End the two-phase read without reading anything. | 862 // End the two-phase read without reading anything. |
816 ASSERT_EQ(MOJO_RESULT_OK, EndReadData(0u)); | 863 ASSERT_EQ(MOJO_RESULT_OK, EndReadData(0u)); |
817 | 864 |
818 // It should be readable again. | 865 // It should be readable again. |
819 hss = GetSignalsState(consumer_); | 866 hss = MojoHandleSignalsState(); |
| 867 ASSERT_EQ(MOJO_RESULT_OK, |
| 868 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss)); |
820 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); | 869 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); |
821 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 870 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
822 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 871 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
823 hss.satisfiable_signals); | 872 hss.satisfiable_signals); |
824 } | 873 } |
825 | 874 |
826 void Seq(int32_t start, size_t count, int32_t* out) { | 875 void Seq(int32_t start, size_t count, int32_t* out) { |
827 for (size_t i = 0; i < count; i++) | 876 for (size_t i = 0; i < count; i++) |
828 out[i] = start + static_cast<int32_t>(i); | 877 out[i] = start + static_cast<int32_t>(i); |
829 } | 878 } |
(...skipping 25 matching lines...) Expand all Loading... |
855 ASSERT_EQ(MOJO_RESULT_OK, WriteData(buffer, &num_bytes, true)); | 904 ASSERT_EQ(MOJO_RESULT_OK, WriteData(buffer, &num_bytes, true)); |
856 ASSERT_EQ(5u * sizeof(int32_t), num_bytes); | 905 ASSERT_EQ(5u * sizeof(int32_t), num_bytes); |
857 | 906 |
858 // Wait for data. | 907 // Wait for data. |
859 // TODO(vtl): There's no real guarantee that all the data will become | 908 // TODO(vtl): There's no real guarantee that all the data will become |
860 // available at once (except that in current implementations, with reasonable | 909 // available at once (except that in current implementations, with reasonable |
861 // limits, it will). Eventually, we'll be able to wait for a specified amount | 910 // limits, it will). Eventually, we'll be able to wait for a specified amount |
862 // of data to become available. | 911 // of data to become available. |
863 hss = MojoHandleSignalsState(); | 912 hss = MojoHandleSignalsState(); |
864 ASSERT_EQ(MOJO_RESULT_OK, | 913 ASSERT_EQ(MOJO_RESULT_OK, |
865 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 914 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 915 MOJO_DEADLINE_INDEFINITE, &hss)); |
866 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 916 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
867 hss.satisfied_signals); | 917 hss.satisfied_signals); |
868 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE | | 918 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE | |
869 MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 919 MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
870 hss.satisfiable_signals); | 920 hss.satisfiable_signals); |
871 | 921 |
872 // Half full. | 922 // Half full. |
873 num_bytes = 0u; | 923 num_bytes = 0u; |
874 ASSERT_EQ(MOJO_RESULT_OK, QueryData(&num_bytes)); | 924 ASSERT_EQ(MOJO_RESULT_OK, QueryData(&num_bytes)); |
875 ASSERT_EQ(5u * sizeof(int32_t), num_bytes); | 925 ASSERT_EQ(5u * sizeof(int32_t), num_bytes); |
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
945 num_bytes = 0u; | 995 num_bytes = 0u; |
946 ASSERT_EQ(MOJO_RESULT_OK, QueryData(&num_bytes)); | 996 ASSERT_EQ(MOJO_RESULT_OK, QueryData(&num_bytes)); |
947 ASSERT_EQ(3u * sizeof(int32_t), num_bytes); | 997 ASSERT_EQ(3u * sizeof(int32_t), num_bytes); |
948 | 998 |
949 // Close the producer, then test producer-closed cases. | 999 // Close the producer, then test producer-closed cases. |
950 CloseProducer(); | 1000 CloseProducer(); |
951 | 1001 |
952 // Wait. | 1002 // Wait. |
953 hss = MojoHandleSignalsState(); | 1003 hss = MojoHandleSignalsState(); |
954 ASSERT_EQ(MOJO_RESULT_OK, | 1004 ASSERT_EQ(MOJO_RESULT_OK, |
955 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, &hss)); | 1005 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| 1006 MOJO_DEADLINE_INDEFINITE, &hss)); |
956 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 1007 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
957 hss.satisfied_signals); | 1008 hss.satisfied_signals); |
958 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 1009 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
959 hss.satisfiable_signals); | 1010 hss.satisfiable_signals); |
960 | 1011 |
961 // Try reading too much; "failed precondition" since the producer is closed. | 1012 // Try reading too much; "failed precondition" since the producer is closed. |
962 num_bytes = 4u * sizeof(int32_t); | 1013 num_bytes = 4u * sizeof(int32_t); |
963 memset(buffer, 0xab, sizeof(buffer)); | 1014 memset(buffer, 0xab, sizeof(buffer)); |
964 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | 1015 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
965 ReadData(buffer, &num_bytes, true)); | 1016 ReadData(buffer, &num_bytes, true)); |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1009 ASSERT_EQ(MOJO_RESULT_OK, Create(&options)); | 1060 ASSERT_EQ(MOJO_RESULT_OK, Create(&options)); |
1010 MojoHandleSignalsState hss; | 1061 MojoHandleSignalsState hss; |
1011 | 1062 |
1012 // Write 20 bytes. | 1063 // Write 20 bytes. |
1013 uint32_t num_bytes = 20u; | 1064 uint32_t num_bytes = 20u; |
1014 ASSERT_EQ(MOJO_RESULT_OK, WriteData(&test_data[0], &num_bytes, true)); | 1065 ASSERT_EQ(MOJO_RESULT_OK, WriteData(&test_data[0], &num_bytes, true)); |
1015 ASSERT_EQ(20u, num_bytes); | 1066 ASSERT_EQ(20u, num_bytes); |
1016 | 1067 |
1017 // Wait for data. | 1068 // Wait for data. |
1018 ASSERT_EQ(MOJO_RESULT_OK, | 1069 ASSERT_EQ(MOJO_RESULT_OK, |
1019 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 1070 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 1071 MOJO_DEADLINE_INDEFINITE, &hss)); |
1020 EXPECT_TRUE(hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE); | 1072 EXPECT_TRUE(hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE); |
1021 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 1073 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
1022 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 1074 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
1023 hss.satisfiable_signals); | 1075 hss.satisfiable_signals); |
1024 | 1076 |
1025 // Read 10 bytes. | 1077 // Read 10 bytes. |
1026 unsigned char read_buffer[1000] = {0}; | 1078 unsigned char read_buffer[1000] = {0}; |
1027 num_bytes = 10u; | 1079 num_bytes = 10u; |
1028 ASSERT_EQ(MOJO_RESULT_OK, ReadData(read_buffer, &num_bytes, true)); | 1080 ASSERT_EQ(MOJO_RESULT_OK, ReadData(read_buffer, &num_bytes, true)); |
1029 ASSERT_EQ(10u, num_bytes); | 1081 ASSERT_EQ(10u, num_bytes); |
1030 ASSERT_EQ(0, memcmp(read_buffer, &test_data[0], 10u)); | 1082 ASSERT_EQ(0, memcmp(read_buffer, &test_data[0], 10u)); |
1031 | 1083 |
1032 // Check that a two-phase write can now only write (at most) 80 bytes. (This | 1084 // Check that a two-phase write can now only write (at most) 80 bytes. (This |
1033 // checks an implementation detail; this behavior is not guaranteed.) | 1085 // checks an implementation detail; this behavior is not guaranteed.) |
1034 void* write_buffer_ptr = nullptr; | 1086 void* write_buffer_ptr = nullptr; |
1035 num_bytes = 0u; | 1087 num_bytes = 0u; |
1036 ASSERT_EQ(MOJO_RESULT_OK, | 1088 ASSERT_EQ(MOJO_RESULT_OK, |
1037 BeginWriteData(&write_buffer_ptr, &num_bytes, false)); | 1089 BeginWriteData(&write_buffer_ptr, &num_bytes, false)); |
1038 EXPECT_TRUE(write_buffer_ptr); | 1090 EXPECT_TRUE(write_buffer_ptr); |
1039 ASSERT_EQ(80u, num_bytes); | 1091 ASSERT_EQ(80u, num_bytes); |
1040 ASSERT_EQ(MOJO_RESULT_OK, EndWriteData(0)); | 1092 ASSERT_EQ(MOJO_RESULT_OK, EndWriteData(0)); |
1041 | 1093 |
1042 size_t total_num_bytes = 0; | 1094 size_t total_num_bytes = 0; |
1043 while (total_num_bytes < 90) { | 1095 while (total_num_bytes < 90) { |
1044 // Wait to write. | 1096 // Wait to write. |
1045 ASSERT_EQ(MOJO_RESULT_OK, | 1097 ASSERT_EQ(MOJO_RESULT_OK, |
1046 WaitForSignals(producer_, MOJO_HANDLE_SIGNAL_WRITABLE, &hss)); | 1098 MojoWait(producer_, MOJO_HANDLE_SIGNAL_WRITABLE, |
| 1099 MOJO_DEADLINE_INDEFINITE, &hss)); |
1047 ASSERT_EQ(hss.satisfied_signals, MOJO_HANDLE_SIGNAL_WRITABLE); | 1100 ASSERT_EQ(hss.satisfied_signals, MOJO_HANDLE_SIGNAL_WRITABLE); |
1048 ASSERT_EQ(hss.satisfiable_signals, | 1101 ASSERT_EQ(hss.satisfiable_signals, |
1049 MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED); | 1102 MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED); |
1050 | 1103 |
1051 // Write as much as we can. | 1104 // Write as much as we can. |
1052 num_bytes = 100; | 1105 num_bytes = 100; |
1053 ASSERT_EQ(MOJO_RESULT_OK, | 1106 ASSERT_EQ(MOJO_RESULT_OK, |
1054 WriteData(&test_data[20 + total_num_bytes], &num_bytes, false)); | 1107 WriteData(&test_data[20 + total_num_bytes], &num_bytes, false)); |
1055 total_num_bytes += num_bytes; | 1108 total_num_bytes += num_bytes; |
1056 } | 1109 } |
(...skipping 114 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1171 void* write_buffer_ptr = nullptr; | 1224 void* write_buffer_ptr = nullptr; |
1172 num_bytes = 0u; | 1225 num_bytes = 0u; |
1173 ASSERT_EQ(MOJO_RESULT_OK, BeginWriteData(&write_buffer_ptr, &num_bytes)); | 1226 ASSERT_EQ(MOJO_RESULT_OK, BeginWriteData(&write_buffer_ptr, &num_bytes)); |
1174 EXPECT_TRUE(write_buffer_ptr); | 1227 EXPECT_TRUE(write_buffer_ptr); |
1175 ASSERT_GT(num_bytes, kTestDataSize); | 1228 ASSERT_GT(num_bytes, kTestDataSize); |
1176 | 1229 |
1177 // Wait for data. | 1230 // Wait for data. |
1178 // TODO(vtl): (See corresponding TODO in AllOrNone.) | 1231 // TODO(vtl): (See corresponding TODO in AllOrNone.) |
1179 hss = MojoHandleSignalsState(); | 1232 hss = MojoHandleSignalsState(); |
1180 ASSERT_EQ(MOJO_RESULT_OK, | 1233 ASSERT_EQ(MOJO_RESULT_OK, |
1181 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 1234 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 1235 MOJO_DEADLINE_INDEFINITE, &hss)); |
1182 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 1236 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
1183 hss.satisfied_signals); | 1237 hss.satisfied_signals); |
1184 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 1238 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
1185 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 1239 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
1186 hss.satisfiable_signals); | 1240 hss.satisfiable_signals); |
1187 | 1241 |
1188 // Start two-phase read. | 1242 // Start two-phase read. |
1189 const void* read_buffer_ptr = nullptr; | 1243 const void* read_buffer_ptr = nullptr; |
1190 num_bytes = 0u; | 1244 num_bytes = 0u; |
1191 ASSERT_EQ(MOJO_RESULT_OK, BeginReadData(&read_buffer_ptr, &num_bytes)); | 1245 ASSERT_EQ(MOJO_RESULT_OK, BeginReadData(&read_buffer_ptr, &num_bytes)); |
1192 EXPECT_TRUE(read_buffer_ptr); | 1246 EXPECT_TRUE(read_buffer_ptr); |
1193 ASSERT_EQ(kTestDataSize, num_bytes); | 1247 ASSERT_EQ(kTestDataSize, num_bytes); |
1194 | 1248 |
1195 // Close the consumer. | 1249 // Close the consumer. |
1196 CloseConsumer(); | 1250 CloseConsumer(); |
1197 | 1251 |
1198 // Wait for producer to know that the consumer is closed. | 1252 // Wait for producer to know that the consumer is closed. |
1199 hss = MojoHandleSignalsState(); | 1253 hss = MojoHandleSignalsState(); |
1200 ASSERT_EQ(MOJO_RESULT_OK, | 1254 ASSERT_EQ(MOJO_RESULT_OK, |
1201 WaitForSignals(producer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, &hss)); | 1255 MojoWait(producer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| 1256 MOJO_DEADLINE_INDEFINITE, &hss)); |
1202 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); | 1257 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); |
1203 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); | 1258 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); |
1204 | 1259 |
1205 // Actually write some data. (Note: Premature freeing of the buffer would | 1260 // Actually write some data. (Note: Premature freeing of the buffer would |
1206 // probably only be detected under ASAN or similar.) | 1261 // probably only be detected under ASAN or similar.) |
1207 memcpy(write_buffer_ptr, kTestData, kTestDataSize); | 1262 memcpy(write_buffer_ptr, kTestData, kTestDataSize); |
1208 // Note: Even though the consumer has been closed, ending the two-phase | 1263 // Note: Even though the consumer has been closed, ending the two-phase |
1209 // write will report success. | 1264 // write will report success. |
1210 ASSERT_EQ(MOJO_RESULT_OK, EndWriteData(kTestDataSize)); | 1265 ASSERT_EQ(MOJO_RESULT_OK, EndWriteData(kTestDataSize)); |
1211 | 1266 |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1261 ASSERT_EQ(MOJO_RESULT_OK, WriteData(kTestData, &num_bytes)); | 1316 ASSERT_EQ(MOJO_RESULT_OK, WriteData(kTestData, &num_bytes)); |
1262 ASSERT_EQ(kTestDataSize, num_bytes); | 1317 ASSERT_EQ(kTestDataSize, num_bytes); |
1263 | 1318 |
1264 // Close the producer. | 1319 // Close the producer. |
1265 CloseProducer(); | 1320 CloseProducer(); |
1266 | 1321 |
1267 // Wait. (Note that once the consumer knows that the producer is closed, it | 1322 // Wait. (Note that once the consumer knows that the producer is closed, it |
1268 // must also know about all the data that was sent.) | 1323 // must also know about all the data that was sent.) |
1269 hss = MojoHandleSignalsState(); | 1324 hss = MojoHandleSignalsState(); |
1270 ASSERT_EQ(MOJO_RESULT_OK, | 1325 ASSERT_EQ(MOJO_RESULT_OK, |
1271 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, &hss)); | 1326 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| 1327 MOJO_DEADLINE_INDEFINITE, &hss)); |
1272 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 1328 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
1273 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 1329 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
1274 hss.satisfied_signals); | 1330 hss.satisfied_signals); |
1275 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 1331 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
1276 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 1332 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
1277 hss.satisfiable_signals); | 1333 hss.satisfiable_signals); |
1278 | 1334 |
1279 // Peek that data. | 1335 // Peek that data. |
1280 char buffer[1000]; | 1336 char buffer[1000]; |
1281 num_bytes = static_cast<uint32_t>(sizeof(buffer)); | 1337 num_bytes = static_cast<uint32_t>(sizeof(buffer)); |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1321 MojoHandleSignalsState hss; | 1377 MojoHandleSignalsState hss; |
1322 | 1378 |
1323 // Write some data. | 1379 // Write some data. |
1324 uint32_t num_bytes = kTestDataSize; | 1380 uint32_t num_bytes = kTestDataSize; |
1325 ASSERT_EQ(MOJO_RESULT_OK, WriteData(kTestData, &num_bytes)); | 1381 ASSERT_EQ(MOJO_RESULT_OK, WriteData(kTestData, &num_bytes)); |
1326 ASSERT_EQ(kTestDataSize, num_bytes); | 1382 ASSERT_EQ(kTestDataSize, num_bytes); |
1327 | 1383 |
1328 // Wait for the data. | 1384 // Wait for the data. |
1329 hss = MojoHandleSignalsState(); | 1385 hss = MojoHandleSignalsState(); |
1330 ASSERT_EQ(MOJO_RESULT_OK, | 1386 ASSERT_EQ(MOJO_RESULT_OK, |
1331 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 1387 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 1388 MOJO_DEADLINE_INDEFINITE, &hss)); |
1332 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 1389 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
1333 hss.satisfied_signals); | 1390 hss.satisfied_signals); |
1334 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 1391 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
1335 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 1392 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
1336 hss.satisfiable_signals); | 1393 hss.satisfiable_signals); |
1337 | 1394 |
1338 // Begin a two-phase read. | 1395 // Begin a two-phase read. |
1339 const void* read_buffer_ptr = nullptr; | 1396 const void* read_buffer_ptr = nullptr; |
1340 uint32_t read_buffer_size = 0u; | 1397 uint32_t read_buffer_size = 0u; |
1341 ASSERT_EQ(MOJO_RESULT_OK, BeginReadData(&read_buffer_ptr, &read_buffer_size)); | 1398 ASSERT_EQ(MOJO_RESULT_OK, BeginReadData(&read_buffer_ptr, &read_buffer_size)); |
1342 | 1399 |
1343 // Write more data. | 1400 // Write more data. |
1344 const char kExtraData[] = "bye world"; | 1401 const char kExtraData[] = "bye world"; |
1345 const uint32_t kExtraDataSize = static_cast<uint32_t>(sizeof(kExtraData)); | 1402 const uint32_t kExtraDataSize = static_cast<uint32_t>(sizeof(kExtraData)); |
1346 num_bytes = kExtraDataSize; | 1403 num_bytes = kExtraDataSize; |
1347 ASSERT_EQ(MOJO_RESULT_OK, WriteData(kExtraData, &num_bytes)); | 1404 ASSERT_EQ(MOJO_RESULT_OK, WriteData(kExtraData, &num_bytes)); |
1348 ASSERT_EQ(kExtraDataSize, num_bytes); | 1405 ASSERT_EQ(kExtraDataSize, num_bytes); |
1349 | 1406 |
1350 // Close the producer. | 1407 // Close the producer. |
1351 CloseProducer(); | 1408 CloseProducer(); |
1352 | 1409 |
1353 // Wait. (Note that once the consumer knows that the producer is closed, it | 1410 // Wait. (Note that once the consumer knows that the producer is closed, it |
1354 // must also have received the extra data). | 1411 // must also have received the extra data). |
1355 hss = MojoHandleSignalsState(); | 1412 hss = MojoHandleSignalsState(); |
1356 ASSERT_EQ(MOJO_RESULT_OK, | 1413 ASSERT_EQ(MOJO_RESULT_OK, |
1357 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, &hss)); | 1414 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| 1415 MOJO_DEADLINE_INDEFINITE, &hss)); |
1358 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); | 1416 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); |
1359 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 1417 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
1360 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 1418 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
1361 hss.satisfiable_signals); | 1419 hss.satisfiable_signals); |
1362 | 1420 |
1363 // Read the two phase memory to check it's still valid. | 1421 // Read the two phase memory to check it's still valid. |
1364 ASSERT_EQ(0, memcmp(read_buffer_ptr, kTestData, kTestDataSize)); | 1422 ASSERT_EQ(0, memcmp(read_buffer_ptr, kTestData, kTestDataSize)); |
1365 EndReadData(read_buffer_size); | 1423 EndReadData(read_buffer_size); |
1366 } | 1424 } |
1367 | 1425 |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1434 | 1492 |
1435 // Now write some data, so we'll be able to try reading. | 1493 // Now write some data, so we'll be able to try reading. |
1436 int32_t element = 123; | 1494 int32_t element = 123; |
1437 num_bytes = 1u * sizeof(int32_t); | 1495 num_bytes = 1u * sizeof(int32_t); |
1438 ASSERT_EQ(MOJO_RESULT_OK, WriteData(&element, &num_bytes)); | 1496 ASSERT_EQ(MOJO_RESULT_OK, WriteData(&element, &num_bytes)); |
1439 | 1497 |
1440 // Wait for data. | 1498 // Wait for data. |
1441 // TODO(vtl): (See corresponding TODO in AllOrNone.) | 1499 // TODO(vtl): (See corresponding TODO in AllOrNone.) |
1442 hss = MojoHandleSignalsState(); | 1500 hss = MojoHandleSignalsState(); |
1443 ASSERT_EQ(MOJO_RESULT_OK, | 1501 ASSERT_EQ(MOJO_RESULT_OK, |
1444 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 1502 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 1503 MOJO_DEADLINE_INDEFINITE, &hss)); |
1445 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 1504 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
1446 hss.satisfied_signals); | 1505 hss.satisfied_signals); |
1447 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 1506 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
1448 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 1507 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
1449 hss.satisfiable_signals); | 1508 hss.satisfiable_signals); |
1450 | 1509 |
1451 // One element available. | 1510 // One element available. |
1452 num_bytes = 0u; | 1511 num_bytes = 0u; |
1453 ASSERT_EQ(MOJO_RESULT_OK, QueryData(&num_bytes)); | 1512 ASSERT_EQ(MOJO_RESULT_OK, QueryData(&num_bytes)); |
1454 ASSERT_EQ(1u * sizeof(int32_t), num_bytes); | 1513 ASSERT_EQ(1u * sizeof(int32_t), num_bytes); |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1503 MojoHandleSignalsState hss; | 1562 MojoHandleSignalsState hss; |
1504 | 1563 |
1505 // Write some data. | 1564 // Write some data. |
1506 uint32_t num_bytes = kTestDataSize; | 1565 uint32_t num_bytes = kTestDataSize; |
1507 ASSERT_EQ(MOJO_RESULT_OK, WriteData(kTestData, &num_bytes)); | 1566 ASSERT_EQ(MOJO_RESULT_OK, WriteData(kTestData, &num_bytes)); |
1508 ASSERT_EQ(kTestDataSize, num_bytes); | 1567 ASSERT_EQ(kTestDataSize, num_bytes); |
1509 | 1568 |
1510 // Wait for the data. | 1569 // Wait for the data. |
1511 hss = MojoHandleSignalsState(); | 1570 hss = MojoHandleSignalsState(); |
1512 ASSERT_EQ(MOJO_RESULT_OK, | 1571 ASSERT_EQ(MOJO_RESULT_OK, |
1513 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 1572 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 1573 MOJO_DEADLINE_INDEFINITE, &hss)); |
1514 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 1574 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
1515 hss.satisfied_signals); | 1575 hss.satisfied_signals); |
1516 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 1576 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
1517 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 1577 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
1518 hss.satisfiable_signals); | 1578 hss.satisfiable_signals); |
1519 | 1579 |
1520 // Check the data. | 1580 // Check the data. |
1521 const void* read_buffer = nullptr; | 1581 const void* read_buffer = nullptr; |
1522 num_bytes = 0u; | 1582 num_bytes = 0u; |
1523 ASSERT_EQ(MOJO_RESULT_OK, | 1583 ASSERT_EQ(MOJO_RESULT_OK, |
1524 BeginReadData(&read_buffer, &num_bytes, false)); | 1584 BeginReadData(&read_buffer, &num_bytes, false)); |
1525 ASSERT_EQ(0, memcmp(read_buffer, kTestData, kTestDataSize)); | 1585 ASSERT_EQ(0, memcmp(read_buffer, kTestData, kTestDataSize)); |
1526 EndReadData(num_bytes); | 1586 EndReadData(num_bytes); |
1527 | 1587 |
1528 // Now send the producer over a MP so that it's serialized. | 1588 // Now send the producer over a MP so that it's serialized. |
1529 MojoHandle pipe0, pipe1; | 1589 MojoHandle pipe0, pipe1; |
1530 ASSERT_EQ(MOJO_RESULT_OK, | 1590 ASSERT_EQ(MOJO_RESULT_OK, |
1531 MojoCreateMessagePipe(nullptr, &pipe0, &pipe1)); | 1591 MojoCreateMessagePipe(nullptr, &pipe0, &pipe1)); |
1532 | 1592 |
1533 ASSERT_EQ(MOJO_RESULT_OK, | 1593 ASSERT_EQ(MOJO_RESULT_OK, |
1534 MojoWriteMessage(pipe0, nullptr, 0, &producer_, 1, | 1594 MojoWriteMessage(pipe0, nullptr, 0, &producer_, 1, |
1535 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 1595 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
1536 producer_ = MOJO_HANDLE_INVALID; | 1596 producer_ = MOJO_HANDLE_INVALID; |
1537 ASSERT_EQ(MOJO_RESULT_OK, | 1597 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1, MOJO_HANDLE_SIGNAL_READABLE, |
1538 WaitForSignals(pipe1, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 1598 MOJO_DEADLINE_INDEFINITE, &hss)); |
1539 uint32_t num_handles = 1; | 1599 uint32_t num_handles = 1; |
1540 ASSERT_EQ(MOJO_RESULT_OK, | 1600 ASSERT_EQ(MOJO_RESULT_OK, |
1541 MojoReadMessage(pipe1, nullptr, 0, &producer_, &num_handles, | 1601 MojoReadMessage(pipe1, nullptr, 0, &producer_, &num_handles, |
1542 MOJO_READ_MESSAGE_FLAG_NONE)); | 1602 MOJO_READ_MESSAGE_FLAG_NONE)); |
1543 ASSERT_EQ(num_handles, 1u); | 1603 ASSERT_EQ(num_handles, 1u); |
1544 | 1604 |
1545 // Write more data. | 1605 // Write more data. |
1546 const char kExtraData[] = "bye world"; | 1606 const char kExtraData[] = "bye world"; |
1547 const uint32_t kExtraDataSize = static_cast<uint32_t>(sizeof(kExtraData)); | 1607 const uint32_t kExtraDataSize = static_cast<uint32_t>(sizeof(kExtraData)); |
1548 num_bytes = kExtraDataSize; | 1608 num_bytes = kExtraDataSize; |
1549 ASSERT_EQ(MOJO_RESULT_OK, WriteData(kExtraData, &num_bytes)); | 1609 ASSERT_EQ(MOJO_RESULT_OK, WriteData(kExtraData, &num_bytes)); |
1550 ASSERT_EQ(kExtraDataSize, num_bytes); | 1610 ASSERT_EQ(kExtraDataSize, num_bytes); |
1551 | 1611 |
1552 // Wait for it. | 1612 // Wait for it. |
1553 hss = MojoHandleSignalsState(); | 1613 hss = MojoHandleSignalsState(); |
1554 ASSERT_EQ(MOJO_RESULT_OK, | 1614 ASSERT_EQ(MOJO_RESULT_OK, |
1555 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 1615 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_READABLE, |
| 1616 MOJO_DEADLINE_INDEFINITE, &hss)); |
1556 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 1617 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
1557 hss.satisfied_signals); | 1618 hss.satisfied_signals); |
1558 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 1619 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
1559 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 1620 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
1560 hss.satisfiable_signals); | 1621 hss.satisfiable_signals); |
1561 | 1622 |
1562 // Check the second write. | 1623 // Check the second write. |
1563 num_bytes = 0u; | 1624 num_bytes = 0u; |
1564 ASSERT_EQ(MOJO_RESULT_OK, | 1625 ASSERT_EQ(MOJO_RESULT_OK, |
1565 BeginReadData(&read_buffer, &num_bytes, false)); | 1626 BeginReadData(&read_buffer, &num_bytes, false)); |
(...skipping 19 matching lines...) Expand all Loading... |
1585 | 1646 |
1586 // We can write to a data pipe handle immediately. | 1647 // We can write to a data pipe handle immediately. |
1587 int32_t data = 123; | 1648 int32_t data = 123; |
1588 uint32_t num_bytes = sizeof(data); | 1649 uint32_t num_bytes = sizeof(data); |
1589 ASSERT_EQ(MOJO_RESULT_OK, WriteData(&data, &num_bytes)); | 1650 ASSERT_EQ(MOJO_RESULT_OK, WriteData(&data, &num_bytes)); |
1590 ASSERT_EQ(MOJO_RESULT_OK, CloseProducer()); | 1651 ASSERT_EQ(MOJO_RESULT_OK, CloseProducer()); |
1591 | 1652 |
1592 // Now wait for the other side to become readable and to see the peer closed. | 1653 // Now wait for the other side to become readable and to see the peer closed. |
1593 MojoHandleSignalsState state; | 1654 MojoHandleSignalsState state; |
1594 ASSERT_EQ(MOJO_RESULT_OK, | 1655 ASSERT_EQ(MOJO_RESULT_OK, |
1595 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, &state)); | 1656 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| 1657 MOJO_DEADLINE_INDEFINITE, &state)); |
1596 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 1658 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
1597 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 1659 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
1598 state.satisfied_signals); | 1660 state.satisfied_signals); |
1599 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 1661 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
1600 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 1662 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
1601 state.satisfiable_signals); | 1663 state.satisfiable_signals); |
1602 | 1664 |
1603 // Now send the consumer over a MP so that it's serialized. | 1665 // Now send the consumer over a MP so that it's serialized. |
1604 MojoHandle pipe0, pipe1; | 1666 MojoHandle pipe0, pipe1; |
1605 ASSERT_EQ(MOJO_RESULT_OK, | 1667 ASSERT_EQ(MOJO_RESULT_OK, |
1606 MojoCreateMessagePipe(nullptr, &pipe0, &pipe1)); | 1668 MojoCreateMessagePipe(nullptr, &pipe0, &pipe1)); |
1607 | 1669 |
1608 ASSERT_EQ(MOJO_RESULT_OK, | 1670 ASSERT_EQ(MOJO_RESULT_OK, |
1609 MojoWriteMessage(pipe0, nullptr, 0, &consumer_, 1, | 1671 MojoWriteMessage(pipe0, nullptr, 0, &consumer_, 1, |
1610 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 1672 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
1611 consumer_ = MOJO_HANDLE_INVALID; | 1673 consumer_ = MOJO_HANDLE_INVALID; |
1612 ASSERT_EQ(MOJO_RESULT_OK, | 1674 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1, MOJO_HANDLE_SIGNAL_READABLE, |
1613 WaitForSignals(pipe1, MOJO_HANDLE_SIGNAL_READABLE, &state)); | 1675 MOJO_DEADLINE_INDEFINITE, &state)); |
1614 uint32_t num_handles = 1; | 1676 uint32_t num_handles = 1; |
1615 ASSERT_EQ(MOJO_RESULT_OK, | 1677 ASSERT_EQ(MOJO_RESULT_OK, |
1616 MojoReadMessage(pipe1, nullptr, 0, &consumer_, &num_handles, | 1678 MojoReadMessage(pipe1, nullptr, 0, &consumer_, &num_handles, |
1617 MOJO_READ_MESSAGE_FLAG_NONE)); | 1679 MOJO_READ_MESSAGE_FLAG_NONE)); |
1618 ASSERT_EQ(num_handles, 1u); | 1680 ASSERT_EQ(num_handles, 1u); |
1619 | 1681 |
1620 ASSERT_EQ(MOJO_RESULT_OK, | 1682 ASSERT_EQ(MOJO_RESULT_OK, |
1621 WaitForSignals(consumer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, &state)); | 1683 MojoWait(consumer_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| 1684 MOJO_DEADLINE_INDEFINITE, &state)); |
1622 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 1685 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
1623 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 1686 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
1624 state.satisfied_signals); | 1687 state.satisfied_signals); |
1625 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | | 1688 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | |
1626 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, | 1689 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, |
1627 state.satisfiable_signals); | 1690 state.satisfiable_signals); |
1628 | 1691 |
1629 int32_t read_data; | 1692 int32_t read_data; |
1630 ASSERT_EQ(MOJO_RESULT_OK, ReadData(&read_data, &num_bytes)); | 1693 ASSERT_EQ(MOJO_RESULT_OK, ReadData(&read_data, &num_bytes)); |
1631 ASSERT_EQ(sizeof(read_data), num_bytes); | 1694 ASSERT_EQ(sizeof(read_data), num_bytes); |
(...skipping 14 matching lines...) Expand all Loading... |
1646 if (result == MOJO_RESULT_OK) { | 1709 if (result == MOJO_RESULT_OK) { |
1647 num_bytes -= write_bytes; | 1710 num_bytes -= write_bytes; |
1648 elements = static_cast<const uint8_t*>(elements) + write_bytes; | 1711 elements = static_cast<const uint8_t*>(elements) + write_bytes; |
1649 if (num_bytes == 0) | 1712 if (num_bytes == 0) |
1650 return true; | 1713 return true; |
1651 } else { | 1714 } else { |
1652 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, result); | 1715 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, result); |
1653 } | 1716 } |
1654 | 1717 |
1655 MojoHandleSignalsState hss = MojoHandleSignalsState(); | 1718 MojoHandleSignalsState hss = MojoHandleSignalsState(); |
1656 EXPECT_EQ(MOJO_RESULT_OK, test::MojoTestBase::WaitForSignals( | 1719 EXPECT_EQ(MOJO_RESULT_OK, MojoWait(producer, MOJO_HANDLE_SIGNAL_WRITABLE, |
1657 producer, MOJO_HANDLE_SIGNAL_WRITABLE, &hss)); | 1720 MOJO_DEADLINE_INDEFINITE, &hss)); |
1658 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); | 1721 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); |
1659 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 1722 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
1660 hss.satisfiable_signals); | 1723 hss.satisfiable_signals); |
1661 } | 1724 } |
1662 | 1725 |
1663 return false; | 1726 return false; |
1664 } | 1727 } |
1665 | 1728 |
1666 // If |expect_empty| is true, expect |consumer| to be empty after reading. | 1729 // If |expect_empty| is true, expect |consumer| to be empty after reading. |
1667 bool ReadAllData(MojoHandle consumer, | 1730 bool ReadAllData(MojoHandle consumer, |
(...skipping 16 matching lines...) Expand all Loading... |
1684 MOJO_READ_DATA_FLAG_QUERY); | 1747 MOJO_READ_DATA_FLAG_QUERY); |
1685 EXPECT_EQ(0u, num_bytes); | 1748 EXPECT_EQ(0u, num_bytes); |
1686 } | 1749 } |
1687 return true; | 1750 return true; |
1688 } | 1751 } |
1689 } else { | 1752 } else { |
1690 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, result); | 1753 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, result); |
1691 } | 1754 } |
1692 | 1755 |
1693 MojoHandleSignalsState hss = MojoHandleSignalsState(); | 1756 MojoHandleSignalsState hss = MojoHandleSignalsState(); |
1694 EXPECT_EQ(MOJO_RESULT_OK, test::MojoTestBase::WaitForSignals( | 1757 EXPECT_EQ(MOJO_RESULT_OK, MojoWait(consumer, MOJO_HANDLE_SIGNAL_READABLE, |
1695 consumer, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 1758 MOJO_DEADLINE_INDEFINITE, &hss)); |
1696 // Peer could have become closed while we're still waiting for data. | 1759 // Peer could have become closed while we're still waiting for data. |
1697 EXPECT_TRUE(MOJO_HANDLE_SIGNAL_READABLE & hss.satisfied_signals); | 1760 EXPECT_TRUE(MOJO_HANDLE_SIGNAL_READABLE & hss.satisfied_signals); |
1698 EXPECT_TRUE(hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE); | 1761 EXPECT_TRUE(hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE); |
1699 EXPECT_TRUE(hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_PEER_CLOSED); | 1762 EXPECT_TRUE(hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_PEER_CLOSED); |
1700 } | 1763 } |
1701 | 1764 |
1702 return num_bytes == 0; | 1765 return num_bytes == 0; |
1703 } | 1766 } |
1704 | 1767 |
1705 #if !defined(OS_IOS) | 1768 #if !defined(OS_IOS) |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1744 ASSERT_TRUE(WriteAllData(producer_, kMultiprocessTestData, kTestDataSize)); | 1807 ASSERT_TRUE(WriteAllData(producer_, kMultiprocessTestData, kTestDataSize)); |
1745 | 1808 |
1746 // Swap ends. | 1809 // Swap ends. |
1747 ASSERT_EQ(MOJO_RESULT_OK, | 1810 ASSERT_EQ(MOJO_RESULT_OK, |
1748 MojoWriteMessage(server_mp, nullptr, 0, &producer_, 1, | 1811 MojoWriteMessage(server_mp, nullptr, 0, &producer_, 1, |
1749 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 1812 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
1750 | 1813 |
1751 // Receive the consumer from the other side. | 1814 // Receive the consumer from the other side. |
1752 producer_ = MOJO_HANDLE_INVALID; | 1815 producer_ = MOJO_HANDLE_INVALID; |
1753 MojoHandleSignalsState hss = MojoHandleSignalsState(); | 1816 MojoHandleSignalsState hss = MojoHandleSignalsState(); |
1754 ASSERT_EQ(MOJO_RESULT_OK, | 1817 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(server_mp, MOJO_HANDLE_SIGNAL_READABLE, |
1755 WaitForSignals(server_mp, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 1818 MOJO_DEADLINE_INDEFINITE, &hss)); |
1756 MojoHandle handles[2]; | 1819 MojoHandle handles[2]; |
1757 uint32_t num_handles = arraysize(handles); | 1820 uint32_t num_handles = arraysize(handles); |
1758 ASSERT_EQ(MOJO_RESULT_OK, | 1821 ASSERT_EQ(MOJO_RESULT_OK, |
1759 MojoReadMessage(server_mp, nullptr, 0, handles, &num_handles, | 1822 MojoReadMessage(server_mp, nullptr, 0, handles, &num_handles, |
1760 MOJO_READ_MESSAGE_FLAG_NONE)); | 1823 MOJO_READ_MESSAGE_FLAG_NONE)); |
1761 ASSERT_EQ(1u, num_handles); | 1824 ASSERT_EQ(1u, num_handles); |
1762 consumer_ = handles[0]; | 1825 consumer_ = handles[0]; |
1763 | 1826 |
1764 // Read the test string twice. Once for when we sent it, and once for the | 1827 // Read the test string twice. Once for when we sent it, and once for the |
1765 // other end sending it. | 1828 // other end sending it. |
1766 for (int i = 0; i < 2; ++i) { | 1829 for (int i = 0; i < 2; ++i) { |
1767 EXPECT_TRUE(ReadAllData(consumer_, buffer, kTestDataSize, i == 1)); | 1830 EXPECT_TRUE(ReadAllData(consumer_, buffer, kTestDataSize, i == 1)); |
1768 EXPECT_EQ(0, memcmp(buffer, kMultiprocessTestData, kTestDataSize)); | 1831 EXPECT_EQ(0, memcmp(buffer, kMultiprocessTestData, kTestDataSize)); |
1769 } | 1832 } |
1770 | 1833 |
1771 WriteMessage(server_mp, "quit"); | 1834 WriteMessage(server_mp, "quit"); |
1772 | 1835 |
1773 // Don't have to close the consumer here because it will be done for us. | 1836 // Don't have to close the consumer here because it will be done for us. |
1774 END_CHILD() | 1837 END_CHILD() |
1775 } | 1838 } |
1776 | 1839 |
1777 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(MultiprocessClient, DataPipeTest, client_mp) { | 1840 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(MultiprocessClient, DataPipeTest, client_mp) { |
1778 const uint32_t kTestDataSize = | 1841 const uint32_t kTestDataSize = |
1779 static_cast<uint32_t>(sizeof(kMultiprocessTestData)); | 1842 static_cast<uint32_t>(sizeof(kMultiprocessTestData)); |
1780 | 1843 |
1781 // Receive the data pipe from the other side. | 1844 // Receive the data pipe from the other side. |
1782 MojoHandle consumer = MOJO_HANDLE_INVALID; | 1845 MojoHandle consumer = MOJO_HANDLE_INVALID; |
1783 MojoHandleSignalsState hss = MojoHandleSignalsState(); | 1846 MojoHandleSignalsState hss = MojoHandleSignalsState(); |
1784 ASSERT_EQ(MOJO_RESULT_OK, | 1847 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE, |
1785 WaitForSignals(client_mp, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 1848 MOJO_DEADLINE_INDEFINITE, &hss)); |
1786 MojoHandle handles[2]; | 1849 MojoHandle handles[2]; |
1787 uint32_t num_handles = arraysize(handles); | 1850 uint32_t num_handles = arraysize(handles); |
1788 ASSERT_EQ(MOJO_RESULT_OK, | 1851 ASSERT_EQ(MOJO_RESULT_OK, |
1789 MojoReadMessage(client_mp, nullptr, 0, handles, &num_handles, | 1852 MojoReadMessage(client_mp, nullptr, 0, handles, &num_handles, |
1790 MOJO_READ_MESSAGE_FLAG_NONE)); | 1853 MOJO_READ_MESSAGE_FLAG_NONE)); |
1791 ASSERT_EQ(1u, num_handles); | 1854 ASSERT_EQ(1u, num_handles); |
1792 consumer = handles[0]; | 1855 consumer = handles[0]; |
1793 | 1856 |
1794 // Read the initial string that was sent. | 1857 // Read the initial string that was sent. |
1795 int32_t buffer[100]; | 1858 int32_t buffer[100]; |
(...skipping 14 matching lines...) Expand all Loading... |
1810 } | 1873 } |
1811 } | 1874 } |
1812 | 1875 |
1813 // Swap ends. | 1876 // Swap ends. |
1814 ASSERT_EQ(MOJO_RESULT_OK, MojoWriteMessage(client_mp, nullptr, 0, &consumer, | 1877 ASSERT_EQ(MOJO_RESULT_OK, MojoWriteMessage(client_mp, nullptr, 0, &consumer, |
1815 1, MOJO_WRITE_MESSAGE_FLAG_NONE)); | 1878 1, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
1816 | 1879 |
1817 // Receive the producer from the other side. | 1880 // Receive the producer from the other side. |
1818 MojoHandle producer = MOJO_HANDLE_INVALID; | 1881 MojoHandle producer = MOJO_HANDLE_INVALID; |
1819 hss = MojoHandleSignalsState(); | 1882 hss = MojoHandleSignalsState(); |
1820 ASSERT_EQ(MOJO_RESULT_OK, | 1883 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE, |
1821 WaitForSignals(client_mp, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 1884 MOJO_DEADLINE_INDEFINITE, &hss)); |
1822 num_handles = arraysize(handles); | 1885 num_handles = arraysize(handles); |
1823 ASSERT_EQ(MOJO_RESULT_OK, | 1886 ASSERT_EQ(MOJO_RESULT_OK, |
1824 MojoReadMessage(client_mp, nullptr, 0, handles, &num_handles, | 1887 MojoReadMessage(client_mp, nullptr, 0, handles, &num_handles, |
1825 MOJO_READ_MESSAGE_FLAG_NONE)); | 1888 MOJO_READ_MESSAGE_FLAG_NONE)); |
1826 ASSERT_EQ(1u, num_handles); | 1889 ASSERT_EQ(1u, num_handles); |
1827 producer = handles[0]; | 1890 producer = handles[0]; |
1828 | 1891 |
1829 // Write the test string one more time. | 1892 // Write the test string one more time. |
1830 EXPECT_TRUE(WriteAllData(producer, kMultiprocessTestData, kTestDataSize)); | 1893 EXPECT_TRUE(WriteAllData(producer, kMultiprocessTestData, kTestDataSize)); |
1831 | 1894 |
(...skipping 19 matching lines...) Expand all Loading... |
1851 | 1914 |
1852 // Wait for a quit message. | 1915 // Wait for a quit message. |
1853 EXPECT_EQ("quit", ReadMessage(h)); | 1916 EXPECT_EQ("quit", ReadMessage(h)); |
1854 } | 1917 } |
1855 | 1918 |
1856 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(ReadAndCloseConsumer, DataPipeTest, h) { | 1919 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(ReadAndCloseConsumer, DataPipeTest, h) { |
1857 MojoHandle c; | 1920 MojoHandle c; |
1858 std::string expected_message = ReadMessageWithHandles(h, &c, 1); | 1921 std::string expected_message = ReadMessageWithHandles(h, &c, 1); |
1859 | 1922 |
1860 // Wait for the consumer to become readable. | 1923 // Wait for the consumer to become readable. |
1861 EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(c, MOJO_HANDLE_SIGNAL_READABLE)); | 1924 EXPECT_EQ(MOJO_RESULT_OK, MojoWait(c, MOJO_HANDLE_SIGNAL_READABLE, |
| 1925 MOJO_DEADLINE_INDEFINITE, nullptr)); |
1862 | 1926 |
1863 // Drain the consumer and expect to find the given message. | 1927 // Drain the consumer and expect to find the given message. |
1864 uint32_t num_bytes = static_cast<uint32_t>(expected_message.size()); | 1928 uint32_t num_bytes = static_cast<uint32_t>(expected_message.size()); |
1865 std::vector<char> bytes(expected_message.size()); | 1929 std::vector<char> bytes(expected_message.size()); |
1866 EXPECT_EQ(MOJO_RESULT_OK, MojoReadData(c, bytes.data(), &num_bytes, | 1930 EXPECT_EQ(MOJO_RESULT_OK, MojoReadData(c, bytes.data(), &num_bytes, |
1867 MOJO_READ_DATA_FLAG_NONE)); | 1931 MOJO_READ_DATA_FLAG_NONE)); |
1868 EXPECT_EQ(num_bytes, static_cast<uint32_t>(bytes.size())); | 1932 EXPECT_EQ(num_bytes, static_cast<uint32_t>(bytes.size())); |
1869 | 1933 |
1870 std::string message(bytes.data(), bytes.size()); | 1934 std::string message(bytes.data(), bytes.size()); |
1871 EXPECT_EQ(expected_message, message); | 1935 EXPECT_EQ(expected_message, message); |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1918 // Wait for a quit message. | 1982 // Wait for a quit message. |
1919 EXPECT_EQ("quit", ReadMessage(h)); | 1983 EXPECT_EQ("quit", ReadMessage(h)); |
1920 } | 1984 } |
1921 | 1985 |
1922 TEST_F(DataPipeTest, CreateInChild) { | 1986 TEST_F(DataPipeTest, CreateInChild) { |
1923 RUN_CHILD_ON_PIPE(CreateAndWrite, child) | 1987 RUN_CHILD_ON_PIPE(CreateAndWrite, child) |
1924 MojoHandle c; | 1988 MojoHandle c; |
1925 std::string expected_message = ReadMessageWithHandles(child, &c, 1); | 1989 std::string expected_message = ReadMessageWithHandles(child, &c, 1); |
1926 | 1990 |
1927 // Wait for the consumer to become readable. | 1991 // Wait for the consumer to become readable. |
1928 EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(c, MOJO_HANDLE_SIGNAL_READABLE)); | 1992 EXPECT_EQ(MOJO_RESULT_OK, MojoWait(c, MOJO_HANDLE_SIGNAL_READABLE, |
| 1993 MOJO_DEADLINE_INDEFINITE, nullptr)); |
1929 | 1994 |
1930 // Drain the consumer and expect to find the given message. | 1995 // Drain the consumer and expect to find the given message. |
1931 uint32_t num_bytes = static_cast<uint32_t>(expected_message.size()); | 1996 uint32_t num_bytes = static_cast<uint32_t>(expected_message.size()); |
1932 std::vector<char> bytes(expected_message.size()); | 1997 std::vector<char> bytes(expected_message.size()); |
1933 EXPECT_EQ(MOJO_RESULT_OK, MojoReadData(c, bytes.data(), &num_bytes, | 1998 EXPECT_EQ(MOJO_RESULT_OK, MojoReadData(c, bytes.data(), &num_bytes, |
1934 MOJO_READ_DATA_FLAG_NONE)); | 1999 MOJO_READ_DATA_FLAG_NONE)); |
1935 EXPECT_EQ(num_bytes, static_cast<uint32_t>(bytes.size())); | 2000 EXPECT_EQ(num_bytes, static_cast<uint32_t>(bytes.size())); |
1936 | 2001 |
1937 std::string message(bytes.data(), bytes.size()); | 2002 std::string message(bytes.data(), bytes.size()); |
1938 EXPECT_EQ(expected_message, message); | 2003 EXPECT_EQ(expected_message, message); |
1939 | 2004 |
1940 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(c)); | 2005 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(c)); |
1941 WriteMessage(child, "quit"); | 2006 WriteMessage(child, "quit"); |
1942 END_CHILD() | 2007 END_CHILD() |
1943 } | 2008 } |
1944 | 2009 |
1945 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(DataPipeStatusChangeInTransitClient, | 2010 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(DataPipeStatusChangeInTransitClient, |
1946 DataPipeTest, parent) { | 2011 DataPipeTest, parent) { |
1947 // This test verifies that peer closure is detectable through various | 2012 // This test verifies that peer closure is detectable through various |
1948 // mechanisms when it races with handle transfer. | 2013 // mechanisms when it races with handle transfer. |
1949 | 2014 |
1950 MojoHandle handles[6]; | 2015 MojoHandle handles[6]; |
1951 EXPECT_EQ("o_O", ReadMessageWithHandles(parent, handles, 6)); | 2016 EXPECT_EQ("o_O", ReadMessageWithHandles(parent, handles, 6)); |
1952 MojoHandle* producers = &handles[0]; | 2017 MojoHandle* producers = &handles[0]; |
1953 MojoHandle* consumers = &handles[3]; | 2018 MojoHandle* consumers = &handles[3]; |
1954 | 2019 |
1955 // Wait on producer 0 | 2020 // Wait on producer 0 using MojoWait. |
1956 EXPECT_EQ(MOJO_RESULT_OK, | 2021 EXPECT_EQ(MOJO_RESULT_OK, |
1957 WaitForSignals(producers[0], MOJO_HANDLE_SIGNAL_PEER_CLOSED)); | 2022 MojoWait(producers[0], MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| 2023 MOJO_DEADLINE_INDEFINITE, nullptr)); |
1958 | 2024 |
1959 // Wait on consumer 0 | 2025 // Wait on consumer 0 using MojoWait. |
1960 EXPECT_EQ(MOJO_RESULT_OK, | 2026 EXPECT_EQ(MOJO_RESULT_OK, |
1961 WaitForSignals(consumers[0], MOJO_HANDLE_SIGNAL_PEER_CLOSED)); | 2027 MojoWait(consumers[0], MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| 2028 MOJO_DEADLINE_INDEFINITE, nullptr)); |
1962 | 2029 |
1963 base::MessageLoop message_loop; | 2030 base::MessageLoop message_loop; |
1964 | 2031 |
1965 // Wait on producer 1 and consumer 1 using SimpleWatchers. | 2032 // Wait on producer 1 and consumer 1 using SimpleWatchers. |
1966 { | 2033 { |
1967 base::RunLoop run_loop; | 2034 base::RunLoop run_loop; |
1968 int count = 0; | 2035 int count = 0; |
1969 auto callback = base::Bind( | 2036 auto callback = base::Bind( |
1970 [] (base::RunLoop* loop, int* count, MojoResult result) { | 2037 [] (base::RunLoop* loop, int* count, MojoResult result) { |
1971 EXPECT_EQ(MOJO_RESULT_OK, result); | 2038 EXPECT_EQ(MOJO_RESULT_OK, result); |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2026 for (size_t i = 3; i < 6; ++i) | 2093 for (size_t i = 3; i < 6; ++i) |
2027 CloseHandle(producers[i]); | 2094 CloseHandle(producers[i]); |
2028 END_CHILD() | 2095 END_CHILD() |
2029 } | 2096 } |
2030 | 2097 |
2031 #endif // !defined(OS_IOS) | 2098 #endif // !defined(OS_IOS) |
2032 | 2099 |
2033 } // namespace | 2100 } // namespace |
2034 } // namespace edk | 2101 } // namespace edk |
2035 } // namespace mojo | 2102 } // namespace mojo |
OLD | NEW |