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