OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 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 #include <stdio.h> | 7 #include <stdio.h> |
8 #include <string.h> | 8 #include <string.h> |
9 | 9 |
10 #include <string> | 10 #include <string> |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
84 // For each message received, sends a reply message with the same contents | 84 // For each message received, sends a reply message with the same contents |
85 // repeated twice, until the other end is closed or it receives "quitquitquit" | 85 // repeated twice, until the other end is closed or it receives "quitquitquit" |
86 // (which it doesn't reply to). It'll return the number of messages received, | 86 // (which it doesn't reply to). It'll return the number of messages received, |
87 // not including any "quitquitquit" message, modulo 100. | 87 // not including any "quitquitquit" message, modulo 100. |
88 DEFINE_TEST_CLIENT_WITH_PIPE(EchoEcho, MultiprocessMessagePipeTest, h) { | 88 DEFINE_TEST_CLIENT_WITH_PIPE(EchoEcho, MultiprocessMessagePipeTest, h) { |
89 const std::string quitquitquit("quitquitquit"); | 89 const std::string quitquitquit("quitquitquit"); |
90 int rv = 0; | 90 int rv = 0; |
91 for (;; rv = (rv + 1) % 100) { | 91 for (;; rv = (rv + 1) % 100) { |
92 // Wait for our end of the message pipe to be readable. | 92 // Wait for our end of the message pipe to be readable. |
93 HandleSignalsState hss; | 93 HandleSignalsState hss; |
94 MojoResult result = WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss); | 94 MojoResult result = |
| 95 MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE, |
| 96 MOJO_DEADLINE_INDEFINITE, &hss); |
95 if (result != MOJO_RESULT_OK) { | 97 if (result != MOJO_RESULT_OK) { |
96 // It was closed, probably. | 98 // It was closed, probably. |
97 CHECK_EQ(result, MOJO_RESULT_FAILED_PRECONDITION); | 99 CHECK_EQ(result, MOJO_RESULT_FAILED_PRECONDITION); |
98 CHECK_EQ(hss.satisfied_signals, MOJO_HANDLE_SIGNAL_PEER_CLOSED); | 100 CHECK_EQ(hss.satisfied_signals, MOJO_HANDLE_SIGNAL_PEER_CLOSED); |
99 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_PEER_CLOSED); | 101 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_PEER_CLOSED); |
100 break; | 102 break; |
101 } else { | 103 } else { |
102 CHECK((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); | 104 CHECK((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
103 CHECK((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); | 105 CHECK((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
104 } | 106 } |
(...skipping 25 matching lines...) Expand all Loading... |
130 TEST_P(MultiprocessMessagePipeTestWithPeerSupport, Basic) { | 132 TEST_P(MultiprocessMessagePipeTestWithPeerSupport, Basic) { |
131 RUN_CHILD_ON_PIPE(EchoEcho, h) | 133 RUN_CHILD_ON_PIPE(EchoEcho, h) |
132 std::string hello("hello"); | 134 std::string hello("hello"); |
133 ASSERT_EQ(MOJO_RESULT_OK, | 135 ASSERT_EQ(MOJO_RESULT_OK, |
134 MojoWriteMessage(h, hello.data(), | 136 MojoWriteMessage(h, hello.data(), |
135 static_cast<uint32_t>(hello.size()), nullptr, 0u, | 137 static_cast<uint32_t>(hello.size()), nullptr, 0u, |
136 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 138 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
137 | 139 |
138 HandleSignalsState hss; | 140 HandleSignalsState hss; |
139 ASSERT_EQ(MOJO_RESULT_OK, | 141 ASSERT_EQ(MOJO_RESULT_OK, |
140 WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 142 MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE, |
| 143 MOJO_DEADLINE_INDEFINITE, &hss)); |
141 // The child may or may not have closed its end of the message pipe and died | 144 // The child may or may not have closed its end of the message pipe and died |
142 // (and we may or may not know it yet), so our end may or may not appear as | 145 // (and we may or may not know it yet), so our end may or may not appear as |
143 // writable. | 146 // writable. |
144 EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); | 147 EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
145 EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); | 148 EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
146 | 149 |
147 std::string read_buffer(1000, '\0'); | 150 std::string read_buffer(1000, '\0'); |
148 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); | 151 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); |
149 CHECK_EQ(MojoReadMessage(h, &read_buffer[0], | 152 CHECK_EQ(MojoReadMessage(h, &read_buffer[0], |
150 &read_buffer_size, nullptr, 0, | 153 &read_buffer_size, nullptr, 0, |
(...skipping 18 matching lines...) Expand all Loading... |
169 std::string write_buffer(i, 'A' + (i % 26)); | 172 std::string write_buffer(i, 'A' + (i % 26)); |
170 ASSERT_EQ(MOJO_RESULT_OK, | 173 ASSERT_EQ(MOJO_RESULT_OK, |
171 MojoWriteMessage(h, write_buffer.data(), | 174 MojoWriteMessage(h, write_buffer.data(), |
172 static_cast<uint32_t>(write_buffer.size()), | 175 static_cast<uint32_t>(write_buffer.size()), |
173 nullptr, 0u, MOJO_WRITE_MESSAGE_FLAG_NONE)); | 176 nullptr, 0u, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
174 } | 177 } |
175 | 178 |
176 for (size_t i = 0; i < kNumMessages; i++) { | 179 for (size_t i = 0; i < kNumMessages; i++) { |
177 HandleSignalsState hss; | 180 HandleSignalsState hss; |
178 ASSERT_EQ(MOJO_RESULT_OK, | 181 ASSERT_EQ(MOJO_RESULT_OK, |
179 WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 182 MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE, |
| 183 MOJO_DEADLINE_INDEFINITE, &hss)); |
180 // The child may or may not have closed its end of the message pipe and | 184 // The child may or may not have closed its end of the message pipe and |
181 // died (and we may or may not know it yet), so our end may or may not | 185 // died (and we may or may not know it yet), so our end may or may not |
182 // appear as writable. | 186 // appear as writable. |
183 ASSERT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); | 187 ASSERT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
184 ASSERT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); | 188 ASSERT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
185 | 189 |
186 std::string read_buffer(kNumMessages * 2, '\0'); | 190 std::string read_buffer(kNumMessages * 2, '\0'); |
187 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); | 191 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); |
188 ASSERT_EQ(MojoReadMessage(h, &read_buffer[0], | 192 ASSERT_EQ(MojoReadMessage(h, &read_buffer[0], |
189 &read_buffer_size, nullptr, 0, | 193 &read_buffer_size, nullptr, 0, |
190 MOJO_READ_MESSAGE_FLAG_NONE), | 194 MOJO_READ_MESSAGE_FLAG_NONE), |
191 MOJO_RESULT_OK); | 195 MOJO_RESULT_OK); |
192 read_buffer.resize(read_buffer_size); | 196 read_buffer.resize(read_buffer_size); |
193 | 197 |
194 ASSERT_EQ(std::string(i * 2, 'A' + (i % 26)), read_buffer); | 198 ASSERT_EQ(std::string(i * 2, 'A' + (i % 26)), read_buffer); |
195 } | 199 } |
196 | 200 |
197 const std::string quitquitquit("quitquitquit"); | 201 const std::string quitquitquit("quitquitquit"); |
198 ASSERT_EQ(MOJO_RESULT_OK, | 202 ASSERT_EQ(MOJO_RESULT_OK, |
199 MojoWriteMessage(h, quitquitquit.data(), | 203 MojoWriteMessage(h, quitquitquit.data(), |
200 static_cast<uint32_t>(quitquitquit.size()), | 204 static_cast<uint32_t>(quitquitquit.size()), |
201 nullptr, 0u, MOJO_WRITE_MESSAGE_FLAG_NONE)); | 205 nullptr, 0u, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
202 | 206 |
203 // Wait for it to become readable, which should fail (since we sent | 207 // Wait for it to become readable, which should fail (since we sent |
204 // "quitquitquit"). | 208 // "quitquitquit"). |
205 HandleSignalsState hss; | 209 HandleSignalsState hss; |
206 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | 210 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
207 WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 211 MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE, |
| 212 MOJO_DEADLINE_INDEFINITE, &hss)); |
208 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); | 213 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); |
209 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); | 214 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); |
210 END_CHILD_AND_EXPECT_EXIT_CODE(static_cast<int>(kNumMessages % 100)); | 215 END_CHILD_AND_EXPECT_EXIT_CODE(static_cast<int>(kNumMessages % 100)); |
211 } | 216 } |
212 | 217 |
213 DEFINE_TEST_CLIENT_WITH_PIPE(CheckSharedBuffer, MultiprocessMessagePipeTest, | 218 DEFINE_TEST_CLIENT_WITH_PIPE(CheckSharedBuffer, MultiprocessMessagePipeTest, |
214 h) { | 219 h) { |
215 // Wait for the first message from our parent. | 220 // Wait for the first message from our parent. |
216 HandleSignalsState hss; | 221 HandleSignalsState hss; |
217 CHECK_EQ(WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss), | 222 CHECK_EQ(MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE, |
| 223 MOJO_DEADLINE_INDEFINITE, &hss), |
218 MOJO_RESULT_OK); | 224 MOJO_RESULT_OK); |
219 // In this test, the parent definitely doesn't close its end of the message | 225 // In this test, the parent definitely doesn't close its end of the message |
220 // pipe before we do. | 226 // pipe before we do. |
221 CHECK_EQ(hss.satisfied_signals, | 227 CHECK_EQ(hss.satisfied_signals, |
222 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); | 228 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); |
223 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | | 229 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | |
224 MOJO_HANDLE_SIGNAL_WRITABLE | | 230 MOJO_HANDLE_SIGNAL_WRITABLE | |
225 MOJO_HANDLE_SIGNAL_PEER_CLOSED); | 231 MOJO_HANDLE_SIGNAL_PEER_CLOSED); |
226 | 232 |
227 // It should have a shared buffer. | 233 // It should have a shared buffer. |
(...skipping 24 matching lines...) Expand all Loading... |
252 | 258 |
253 // And send a message to signal that we've written stuff. | 259 // And send a message to signal that we've written stuff. |
254 const std::string go2("go 2"); | 260 const std::string go2("go 2"); |
255 CHECK_EQ(MojoWriteMessage(h, go2.data(), | 261 CHECK_EQ(MojoWriteMessage(h, go2.data(), |
256 static_cast<uint32_t>(go2.size()), nullptr, 0u, | 262 static_cast<uint32_t>(go2.size()), nullptr, 0u, |
257 MOJO_WRITE_MESSAGE_FLAG_NONE), | 263 MOJO_WRITE_MESSAGE_FLAG_NONE), |
258 MOJO_RESULT_OK); | 264 MOJO_RESULT_OK); |
259 | 265 |
260 // Now wait for our parent to send us a message. | 266 // Now wait for our parent to send us a message. |
261 hss = HandleSignalsState(); | 267 hss = HandleSignalsState(); |
262 CHECK_EQ(WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss), | 268 CHECK_EQ(MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE, |
| 269 MOJO_DEADLINE_INDEFINITE, &hss), |
263 MOJO_RESULT_OK); | 270 MOJO_RESULT_OK); |
264 CHECK_EQ(hss.satisfied_signals, | 271 CHECK_EQ(hss.satisfied_signals, |
265 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); | 272 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); |
266 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | | 273 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | |
267 MOJO_HANDLE_SIGNAL_WRITABLE | | 274 MOJO_HANDLE_SIGNAL_WRITABLE | |
268 MOJO_HANDLE_SIGNAL_PEER_CLOSED); | 275 MOJO_HANDLE_SIGNAL_PEER_CLOSED); |
269 | 276 |
270 read_buffer = std::string(100, '\0'); | 277 read_buffer = std::string(100, '\0'); |
271 num_bytes = static_cast<uint32_t>(read_buffer.size()); | 278 num_bytes = static_cast<uint32_t>(read_buffer.size()); |
272 CHECK_EQ(MojoReadMessage(h, &read_buffer[0], &num_bytes, | 279 CHECK_EQ(MojoReadMessage(h, &read_buffer[0], &num_bytes, |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
308 handles[0] = duplicated_shared_buffer; | 315 handles[0] = duplicated_shared_buffer; |
309 ASSERT_EQ(MOJO_RESULT_OK, | 316 ASSERT_EQ(MOJO_RESULT_OK, |
310 MojoWriteMessage(h, &go1[0], | 317 MojoWriteMessage(h, &go1[0], |
311 static_cast<uint32_t>(go1.size()), &handles[0], | 318 static_cast<uint32_t>(go1.size()), &handles[0], |
312 arraysize(handles), | 319 arraysize(handles), |
313 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 320 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
314 | 321 |
315 // Wait for a message from the child. | 322 // Wait for a message from the child. |
316 HandleSignalsState hss; | 323 HandleSignalsState hss; |
317 ASSERT_EQ(MOJO_RESULT_OK, | 324 ASSERT_EQ(MOJO_RESULT_OK, |
318 WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 325 MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE, |
| 326 MOJO_DEADLINE_INDEFINITE, &hss)); |
319 EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); | 327 EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
320 EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); | 328 EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
321 | 329 |
322 std::string read_buffer(100, '\0'); | 330 std::string read_buffer(100, '\0'); |
323 uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size()); | 331 uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size()); |
324 ASSERT_EQ(MOJO_RESULT_OK, | 332 ASSERT_EQ(MOJO_RESULT_OK, |
325 MojoReadMessage(h, &read_buffer[0], | 333 MojoReadMessage(h, &read_buffer[0], |
326 &num_bytes, nullptr, 0, | 334 &num_bytes, nullptr, 0, |
327 MOJO_READ_MESSAGE_FLAG_NONE)); | 335 MOJO_READ_MESSAGE_FLAG_NONE)); |
328 read_buffer.resize(num_bytes); | 336 read_buffer.resize(num_bytes); |
(...skipping 15 matching lines...) Expand all Loading... |
344 // And send a message to signal that we've written stuff. | 352 // And send a message to signal that we've written stuff. |
345 const std::string go3("go 3"); | 353 const std::string go3("go 3"); |
346 ASSERT_EQ(MOJO_RESULT_OK, | 354 ASSERT_EQ(MOJO_RESULT_OK, |
347 MojoWriteMessage(h, &go3[0], | 355 MojoWriteMessage(h, &go3[0], |
348 static_cast<uint32_t>(go3.size()), nullptr, 0u, | 356 static_cast<uint32_t>(go3.size()), nullptr, 0u, |
349 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 357 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
350 | 358 |
351 // Wait for |h| to become readable, which should fail. | 359 // Wait for |h| to become readable, which should fail. |
352 hss = HandleSignalsState(); | 360 hss = HandleSignalsState(); |
353 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | 361 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
354 WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 362 MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE, |
| 363 MOJO_DEADLINE_INDEFINITE, &hss)); |
355 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); | 364 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); |
356 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); | 365 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); |
357 END_CHILD() | 366 END_CHILD() |
358 } | 367 } |
359 | 368 |
360 DEFINE_TEST_CLIENT_WITH_PIPE(CheckPlatformHandleFile, | 369 DEFINE_TEST_CLIENT_WITH_PIPE(CheckPlatformHandleFile, |
361 MultiprocessMessagePipeTest, h) { | 370 MultiprocessMessagePipeTest, h) { |
362 HandleSignalsState hss; | 371 HandleSignalsState hss; |
363 CHECK_EQ(WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss), | 372 CHECK_EQ(MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE, |
| 373 MOJO_DEADLINE_INDEFINITE, &hss), |
364 MOJO_RESULT_OK); | 374 MOJO_RESULT_OK); |
365 CHECK_EQ(hss.satisfied_signals, | 375 CHECK_EQ(hss.satisfied_signals, |
366 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); | 376 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); |
367 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | | 377 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | |
368 MOJO_HANDLE_SIGNAL_WRITABLE | | 378 MOJO_HANDLE_SIGNAL_WRITABLE | |
369 MOJO_HANDLE_SIGNAL_PEER_CLOSED); | 379 MOJO_HANDLE_SIGNAL_PEER_CLOSED); |
370 | 380 |
371 std::string read_buffer(100, '\0'); | 381 std::string read_buffer(100, '\0'); |
372 uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size()); | 382 uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size()); |
373 MojoHandle handles[255]; // Maximum number to receive. | 383 MojoHandle handles[255]; // Maximum number to receive. |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
438 ASSERT_EQ(MOJO_RESULT_OK, | 448 ASSERT_EQ(MOJO_RESULT_OK, |
439 MojoWriteMessage(h, message, | 449 MojoWriteMessage(h, message, |
440 static_cast<uint32_t>(strlen(message)), | 450 static_cast<uint32_t>(strlen(message)), |
441 &handles[0], | 451 &handles[0], |
442 static_cast<uint32_t>(handles.size()), | 452 static_cast<uint32_t>(handles.size()), |
443 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 453 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
444 | 454 |
445 // Wait for it to become readable, which should fail. | 455 // Wait for it to become readable, which should fail. |
446 HandleSignalsState hss; | 456 HandleSignalsState hss; |
447 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | 457 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
448 WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 458 MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE, |
| 459 MOJO_DEADLINE_INDEFINITE, &hss)); |
449 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); | 460 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); |
450 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); | 461 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); |
451 END_CHILD() | 462 END_CHILD() |
452 } | 463 } |
453 | 464 |
454 // Android multi-process tests are not executing the new process. This is flaky. | 465 // Android multi-process tests are not executing the new process. This is flaky. |
455 #if !defined(OS_ANDROID) | 466 #if !defined(OS_ANDROID) |
456 INSTANTIATE_TEST_CASE_P(PipeCount, | 467 INSTANTIATE_TEST_CASE_P(PipeCount, |
457 MultiprocessMessagePipeTestWithPipeCount, | 468 MultiprocessMessagePipeTestWithPipeCount, |
458 // TODO(rockot): Re-enable the 140-pipe case when | 469 // TODO(rockot): Re-enable the 140-pipe case when |
459 // ChannelPosix has support for sending lots of handles. | 470 // ChannelPosix has support for sending lots of handles. |
460 testing::Values(1u, 128u /*, 140u*/)); | 471 testing::Values(1u, 128u /*, 140u*/)); |
461 #endif | 472 #endif |
462 | 473 |
463 DEFINE_TEST_CLIENT_WITH_PIPE(CheckMessagePipe, MultiprocessMessagePipeTest, h) { | 474 DEFINE_TEST_CLIENT_WITH_PIPE(CheckMessagePipe, MultiprocessMessagePipeTest, h) { |
464 // Wait for the first message from our parent. | 475 // Wait for the first message from our parent. |
465 HandleSignalsState hss; | 476 HandleSignalsState hss; |
466 CHECK_EQ(WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss), | 477 CHECK_EQ(MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE, |
| 478 MOJO_DEADLINE_INDEFINITE, &hss), |
467 MOJO_RESULT_OK); | 479 MOJO_RESULT_OK); |
468 // In this test, the parent definitely doesn't close its end of the message | 480 // In this test, the parent definitely doesn't close its end of the message |
469 // pipe before we do. | 481 // pipe before we do. |
470 CHECK_EQ(hss.satisfied_signals, | 482 CHECK_EQ(hss.satisfied_signals, |
471 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); | 483 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); |
472 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | | 484 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | |
473 MOJO_HANDLE_SIGNAL_WRITABLE | | 485 MOJO_HANDLE_SIGNAL_WRITABLE | |
474 MOJO_HANDLE_SIGNAL_PEER_CLOSED); | 486 MOJO_HANDLE_SIGNAL_PEER_CLOSED); |
475 | 487 |
476 // It should have a message pipe. | 488 // It should have a message pipe. |
477 MojoHandle handles[10]; | 489 MojoHandle handles[10]; |
478 uint32_t num_handlers = arraysize(handles); | 490 uint32_t num_handlers = arraysize(handles); |
479 CHECK_EQ(MojoReadMessage(h, nullptr, | 491 CHECK_EQ(MojoReadMessage(h, nullptr, |
480 nullptr, &handles[0], | 492 nullptr, &handles[0], |
481 &num_handlers, MOJO_READ_MESSAGE_FLAG_NONE), | 493 &num_handlers, MOJO_READ_MESSAGE_FLAG_NONE), |
482 MOJO_RESULT_OK); | 494 MOJO_RESULT_OK); |
483 CHECK_EQ(num_handlers, 1u); | 495 CHECK_EQ(num_handlers, 1u); |
484 | 496 |
485 // Read data from the received message pipe. | 497 // Read data from the received message pipe. |
486 CHECK_EQ(WaitForSignals(handles[0], MOJO_HANDLE_SIGNAL_READABLE, &hss), | 498 CHECK_EQ(MojoWait(handles[0], MOJO_HANDLE_SIGNAL_READABLE, |
| 499 MOJO_DEADLINE_INDEFINITE, &hss), |
487 MOJO_RESULT_OK); | 500 MOJO_RESULT_OK); |
488 CHECK_EQ(hss.satisfied_signals, | 501 CHECK_EQ(hss.satisfied_signals, |
489 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); | 502 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); |
490 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | | 503 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | |
491 MOJO_HANDLE_SIGNAL_WRITABLE | | 504 MOJO_HANDLE_SIGNAL_WRITABLE | |
492 MOJO_HANDLE_SIGNAL_PEER_CLOSED); | 505 MOJO_HANDLE_SIGNAL_PEER_CLOSED); |
493 | 506 |
494 std::string read_buffer(100, '\0'); | 507 std::string read_buffer(100, '\0'); |
495 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); | 508 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); |
496 CHECK_EQ(MojoReadMessage(handles[0], &read_buffer[0], | 509 CHECK_EQ(MojoReadMessage(handles[0], &read_buffer[0], |
(...skipping 30 matching lines...) Expand all Loading... |
527 MojoWriteMessage(mp1, &hello[0], | 540 MojoWriteMessage(mp1, &hello[0], |
528 static_cast<uint32_t>(hello.size()), nullptr, 0, | 541 static_cast<uint32_t>(hello.size()), nullptr, 0, |
529 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 542 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
530 ASSERT_EQ(MOJO_RESULT_OK, | 543 ASSERT_EQ(MOJO_RESULT_OK, |
531 MojoWriteMessage(h, nullptr, 0, &mp2, 1, | 544 MojoWriteMessage(h, nullptr, 0, &mp2, 1, |
532 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 545 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
533 | 546 |
534 // Wait for a message from the child. | 547 // Wait for a message from the child. |
535 HandleSignalsState hss; | 548 HandleSignalsState hss; |
536 ASSERT_EQ(MOJO_RESULT_OK, | 549 ASSERT_EQ(MOJO_RESULT_OK, |
537 WaitForSignals(mp1, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 550 MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE, |
| 551 MOJO_DEADLINE_INDEFINITE, &hss)); |
538 EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); | 552 EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
539 EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); | 553 EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
540 | 554 |
541 std::string read_buffer(100, '\0'); | 555 std::string read_buffer(100, '\0'); |
542 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); | 556 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); |
543 CHECK_EQ(MojoReadMessage(mp1, &read_buffer[0], | 557 CHECK_EQ(MojoReadMessage(mp1, &read_buffer[0], |
544 &read_buffer_size, nullptr, | 558 &read_buffer_size, nullptr, |
545 0, MOJO_READ_MESSAGE_FLAG_NONE), | 559 0, MOJO_READ_MESSAGE_FLAG_NONE), |
546 MOJO_RESULT_OK); | 560 MOJO_RESULT_OK); |
547 read_buffer.resize(read_buffer_size); | 561 read_buffer.resize(read_buffer_size); |
(...skipping 16 matching lines...) Expand all Loading... |
564 MojoWriteMessage(mp1, &hello[0], | 578 MojoWriteMessage(mp1, &hello[0], |
565 static_cast<uint32_t>(hello.size()), nullptr, 0u, | 579 static_cast<uint32_t>(hello.size()), nullptr, 0u, |
566 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 580 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
567 ASSERT_EQ(MOJO_RESULT_OK, | 581 ASSERT_EQ(MOJO_RESULT_OK, |
568 MojoWriteMessage(h, nullptr, 0u, &mp2, 1u, | 582 MojoWriteMessage(h, nullptr, 0u, &mp2, 1u, |
569 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 583 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
570 | 584 |
571 // Wait for a message from the child. | 585 // Wait for a message from the child. |
572 HandleSignalsState hss; | 586 HandleSignalsState hss; |
573 ASSERT_EQ(MOJO_RESULT_OK, | 587 ASSERT_EQ(MOJO_RESULT_OK, |
574 WaitForSignals(mp1, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 588 MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE, |
| 589 MOJO_DEADLINE_INDEFINITE, &hss)); |
575 EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); | 590 EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
576 EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); | 591 EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
577 | 592 |
578 std::string read_buffer(100, '\0'); | 593 std::string read_buffer(100, '\0'); |
579 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); | 594 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); |
580 CHECK_EQ(MojoReadMessage(mp1, &read_buffer[0], | 595 CHECK_EQ(MojoReadMessage(mp1, &read_buffer[0], |
581 &read_buffer_size, nullptr, | 596 &read_buffer_size, nullptr, |
582 0, MOJO_READ_MESSAGE_FLAG_NONE), | 597 0, MOJO_READ_MESSAGE_FLAG_NONE), |
583 MOJO_RESULT_OK); | 598 MOJO_RESULT_OK); |
584 read_buffer.resize(read_buffer_size); | 599 read_buffer.resize(read_buffer_size); |
585 CHECK_EQ(read_buffer, std::string("world")); | 600 CHECK_EQ(read_buffer, std::string("world")); |
586 END_CHILD(); | 601 END_CHILD(); |
587 } | 602 } |
588 | 603 |
589 DEFINE_TEST_CLIENT_WITH_PIPE(DataPipeConsumer, MultiprocessMessagePipeTest, h) { | 604 DEFINE_TEST_CLIENT_WITH_PIPE(DataPipeConsumer, MultiprocessMessagePipeTest, h) { |
590 // Wait for the first message from our parent. | 605 // Wait for the first message from our parent. |
591 HandleSignalsState hss; | 606 HandleSignalsState hss; |
592 CHECK_EQ(WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE, &hss), | 607 CHECK_EQ(MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE, |
| 608 MOJO_DEADLINE_INDEFINITE, &hss), |
593 MOJO_RESULT_OK); | 609 MOJO_RESULT_OK); |
594 // In this test, the parent definitely doesn't close its end of the message | 610 // In this test, the parent definitely doesn't close its end of the message |
595 // pipe before we do. | 611 // pipe before we do. |
596 CHECK_EQ(hss.satisfied_signals, | 612 CHECK_EQ(hss.satisfied_signals, |
597 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); | 613 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); |
598 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | | 614 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | |
599 MOJO_HANDLE_SIGNAL_WRITABLE | | 615 MOJO_HANDLE_SIGNAL_WRITABLE | |
600 MOJO_HANDLE_SIGNAL_PEER_CLOSED); | 616 MOJO_HANDLE_SIGNAL_PEER_CLOSED); |
601 | 617 |
602 // It should have a message pipe. | 618 // It should have a message pipe. |
603 MojoHandle handles[10]; | 619 MojoHandle handles[10]; |
604 uint32_t num_handlers = arraysize(handles); | 620 uint32_t num_handlers = arraysize(handles); |
605 CHECK_EQ(MojoReadMessage(h, nullptr, | 621 CHECK_EQ(MojoReadMessage(h, nullptr, |
606 nullptr, &handles[0], | 622 nullptr, &handles[0], |
607 &num_handlers, MOJO_READ_MESSAGE_FLAG_NONE), | 623 &num_handlers, MOJO_READ_MESSAGE_FLAG_NONE), |
608 MOJO_RESULT_OK); | 624 MOJO_RESULT_OK); |
609 CHECK_EQ(num_handlers, 1u); | 625 CHECK_EQ(num_handlers, 1u); |
610 | 626 |
611 // Read data from the received message pipe. | 627 // Read data from the received message pipe. |
612 CHECK_EQ(WaitForSignals(handles[0], MOJO_HANDLE_SIGNAL_READABLE, &hss), | 628 CHECK_EQ(MojoWait(handles[0], MOJO_HANDLE_SIGNAL_READABLE, |
| 629 MOJO_DEADLINE_INDEFINITE, &hss), |
613 MOJO_RESULT_OK); | 630 MOJO_RESULT_OK); |
614 CHECK_EQ(hss.satisfied_signals, | 631 CHECK_EQ(hss.satisfied_signals, |
615 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); | 632 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); |
616 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | | 633 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | |
617 MOJO_HANDLE_SIGNAL_WRITABLE | | 634 MOJO_HANDLE_SIGNAL_WRITABLE | |
618 MOJO_HANDLE_SIGNAL_PEER_CLOSED); | 635 MOJO_HANDLE_SIGNAL_PEER_CLOSED); |
619 | 636 |
620 std::string read_buffer(100, '\0'); | 637 std::string read_buffer(100, '\0'); |
621 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); | 638 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); |
622 CHECK_EQ(MojoReadMessage(handles[0], &read_buffer[0], | 639 CHECK_EQ(MojoReadMessage(handles[0], &read_buffer[0], |
(...skipping 30 matching lines...) Expand all Loading... |
653 MojoWriteMessage(mp1, &hello[0], | 670 MojoWriteMessage(mp1, &hello[0], |
654 static_cast<uint32_t>(hello.size()), nullptr, 0u, | 671 static_cast<uint32_t>(hello.size()), nullptr, 0u, |
655 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 672 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
656 ASSERT_EQ(MOJO_RESULT_OK, | 673 ASSERT_EQ(MOJO_RESULT_OK, |
657 MojoWriteMessage(h, nullptr, 0, &mp2, 1u, | 674 MojoWriteMessage(h, nullptr, 0, &mp2, 1u, |
658 MOJO_WRITE_MESSAGE_FLAG_NONE)); | 675 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
659 | 676 |
660 // Wait for a message from the child. | 677 // Wait for a message from the child. |
661 HandleSignalsState hss; | 678 HandleSignalsState hss; |
662 ASSERT_EQ(MOJO_RESULT_OK, | 679 ASSERT_EQ(MOJO_RESULT_OK, |
663 WaitForSignals(mp1, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 680 MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE, |
| 681 MOJO_DEADLINE_INDEFINITE, &hss)); |
664 EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); | 682 EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
665 EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); | 683 EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
666 | 684 |
667 std::string read_buffer(100, '\0'); | 685 std::string read_buffer(100, '\0'); |
668 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); | 686 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); |
669 CHECK_EQ(MojoReadMessage(mp1, &read_buffer[0], | 687 CHECK_EQ(MojoReadMessage(mp1, &read_buffer[0], |
670 &read_buffer_size, nullptr, | 688 &read_buffer_size, nullptr, |
671 0, MOJO_READ_MESSAGE_FLAG_NONE), | 689 0, MOJO_READ_MESSAGE_FLAG_NONE), |
672 MOJO_RESULT_OK); | 690 MOJO_RESULT_OK); |
673 read_buffer.resize(read_buffer_size); | 691 read_buffer.resize(read_buffer_size); |
(...skipping 225 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
899 ReadMessageWithHandles(h, &p1, 1); | 917 ReadMessageWithHandles(h, &p1, 1); |
900 WriteMessageWithHandles(h, "", &p1, 1); | 918 WriteMessageWithHandles(h, "", &p1, 1); |
901 } | 919 } |
902 ReadMessageWithHandles(h, &p0, 1); | 920 ReadMessageWithHandles(h, &p0, 1); |
903 WriteMessage(h, "quit"); | 921 WriteMessage(h, "quit"); |
904 END_CHILD() | 922 END_CHILD() |
905 | 923 |
906 EXPECT_EQ("bye", ReadMessage(p0)); | 924 EXPECT_EQ("bye", ReadMessage(p0)); |
907 | 925 |
908 // We should still be able to observe peer closure from the other end. | 926 // We should still be able to observe peer closure from the other end. |
909 EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(p0, MOJO_HANDLE_SIGNAL_PEER_CLOSED)); | 927 EXPECT_EQ(MOJO_RESULT_OK, |
| 928 MojoWait(p0, MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| 929 MOJO_DEADLINE_INDEFINITE, nullptr)); |
910 } | 930 } |
911 | 931 |
912 // Parses commands from the parent pipe and does whatever it's asked to do. | 932 // Parses commands from the parent pipe and does whatever it's asked to do. |
913 DEFINE_TEST_CLIENT_WITH_PIPE(CommandDrivenClient, MultiprocessMessagePipeTest, | 933 DEFINE_TEST_CLIENT_WITH_PIPE(CommandDrivenClient, MultiprocessMessagePipeTest, |
914 h) { | 934 h) { |
915 base::hash_map<std::string, MojoHandle> named_pipes; | 935 base::hash_map<std::string, MojoHandle> named_pipes; |
916 for (;;) { | 936 for (;;) { |
917 MojoHandle p; | 937 MojoHandle p; |
918 auto parts = base::SplitString(ReadMessageWithOptionalHandle(h, &p), ":", | 938 auto parts = base::SplitString(ReadMessageWithOptionalHandle(h, &p), ":", |
919 base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL); | 939 base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL); |
(...skipping 163 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1083 END_CHILD() | 1103 END_CHILD() |
1084 END_CHILD() | 1104 END_CHILD() |
1085 END_CHILD() | 1105 END_CHILD() |
1086 END_CHILD() | 1106 END_CHILD() |
1087 } | 1107 } |
1088 | 1108 |
1089 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(ReceivePipeWithClosedPeer, | 1109 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(ReceivePipeWithClosedPeer, |
1090 MultiprocessMessagePipeTest, h) { | 1110 MultiprocessMessagePipeTest, h) { |
1091 MojoHandle p; | 1111 MojoHandle p; |
1092 EXPECT_EQ("foo", ReadMessageWithHandles(h, &p, 1)); | 1112 EXPECT_EQ("foo", ReadMessageWithHandles(h, &p, 1)); |
1093 EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(p, MOJO_HANDLE_SIGNAL_PEER_CLOSED)); | 1113 |
| 1114 auto result = MojoWait(p, MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| 1115 MOJO_DEADLINE_INDEFINITE, nullptr); |
| 1116 EXPECT_EQ(MOJO_RESULT_OK, result); |
1094 } | 1117 } |
1095 | 1118 |
1096 TEST_P(MultiprocessMessagePipeTestWithPeerSupport, SendPipeThenClosePeer) { | 1119 TEST_P(MultiprocessMessagePipeTestWithPeerSupport, SendPipeThenClosePeer) { |
1097 RUN_CHILD_ON_PIPE(ReceivePipeWithClosedPeer, h) | 1120 RUN_CHILD_ON_PIPE(ReceivePipeWithClosedPeer, h) |
1098 MojoHandle a, b; | 1121 MojoHandle a, b; |
1099 CreateMessagePipe(&a, &b); | 1122 CreateMessagePipe(&a, &b); |
1100 | 1123 |
1101 // Send |a| and immediately close |b|. The child should observe closure. | 1124 // Send |a| and immediately close |b|. The child should observe closure. |
1102 WriteMessageWithHandles(h, "foo", &a, 1); | 1125 WriteMessageWithHandles(h, "foo", &a, 1); |
1103 MojoClose(b); | 1126 MojoClose(b); |
(...skipping 25 matching lines...) Expand all Loading... |
1129 // Receive a pipe from the parent. This is akin to an "application request". | 1152 // Receive a pipe from the parent. This is akin to an "application request". |
1130 MojoHandle application_client; | 1153 MojoHandle application_client; |
1131 EXPECT_EQ("c2a", ReadMessageWithHandles(h, &application_client, 1)); | 1154 EXPECT_EQ("c2a", ReadMessageWithHandles(h, &application_client, 1)); |
1132 | 1155 |
1133 // Receive a pipe from the "application" "client". | 1156 // Receive a pipe from the "application" "client". |
1134 MojoHandle service_client; | 1157 MojoHandle service_client; |
1135 EXPECT_EQ("c2s lol", | 1158 EXPECT_EQ("c2s lol", |
1136 ReadMessageWithHandles(application_client, &service_client, 1)); | 1159 ReadMessageWithHandles(application_client, &service_client, 1)); |
1137 | 1160 |
1138 // Wait for the service client to signal closure. | 1161 // Wait for the service client to signal closure. |
1139 EXPECT_EQ(MOJO_RESULT_OK, | 1162 EXPECT_EQ(MOJO_RESULT_OK, MojoWait(service_client, |
1140 WaitForSignals(service_client, MOJO_HANDLE_SIGNAL_PEER_CLOSED)); | 1163 MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| 1164 MOJO_DEADLINE_INDEFINITE, nullptr)); |
1141 | 1165 |
1142 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(service_client)); | 1166 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(service_client)); |
1143 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(application_client)); | 1167 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(application_client)); |
1144 } | 1168 } |
1145 | 1169 |
1146 #if defined(OS_ANDROID) | 1170 #if defined(OS_ANDROID) |
1147 // Android multi-process tests are not executing the new process. This is flaky. | 1171 // Android multi-process tests are not executing the new process. This is flaky. |
1148 #define MAYBE_SendPipeWithClosedPeerBetweenChildren \ | 1172 #define MAYBE_SendPipeWithClosedPeerBetweenChildren \ |
1149 DISABLED_SendPipeWithClosedPeerBetweenChildren | 1173 DISABLED_SendPipeWithClosedPeerBetweenChildren |
1150 #else | 1174 #else |
(...skipping 25 matching lines...) Expand all Loading... |
1176 CreateMessagePipe(&c, &d); | 1200 CreateMessagePipe(&c, &d); |
1177 | 1201 |
1178 // Send |a| over |c|, immediately close |b|, then send |a| back over |d|. | 1202 // Send |a| over |c|, immediately close |b|, then send |a| back over |d|. |
1179 WriteMessageWithHandles(c, "foo", &a, 1); | 1203 WriteMessageWithHandles(c, "foo", &a, 1); |
1180 EXPECT_EQ("foo", ReadMessageWithHandles(d, &a, 1)); | 1204 EXPECT_EQ("foo", ReadMessageWithHandles(d, &a, 1)); |
1181 WriteMessageWithHandles(d, "bar", &a, 1); | 1205 WriteMessageWithHandles(d, "bar", &a, 1); |
1182 EXPECT_EQ("bar", ReadMessageWithHandles(c, &a, 1)); | 1206 EXPECT_EQ("bar", ReadMessageWithHandles(c, &a, 1)); |
1183 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b)); | 1207 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b)); |
1184 | 1208 |
1185 // We should be able to detect peer closure on |a|. | 1209 // We should be able to detect peer closure on |a|. |
1186 EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(a, MOJO_HANDLE_SIGNAL_PEER_CLOSED)); | 1210 EXPECT_EQ(MOJO_RESULT_OK, MojoWait(a, MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| 1211 MOJO_DEADLINE_INDEFINITE, nullptr)); |
1187 } | 1212 } |
1188 | 1213 |
1189 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(WriteCloseSendPeerClient, | 1214 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(WriteCloseSendPeerClient, |
1190 MultiprocessMessagePipeTest, h) { | 1215 MultiprocessMessagePipeTest, h) { |
1191 MojoHandle pipe[2]; | 1216 MojoHandle pipe[2]; |
1192 EXPECT_EQ("foo", ReadMessageWithHandles(h, pipe, 2)); | 1217 EXPECT_EQ("foo", ReadMessageWithHandles(h, pipe, 2)); |
1193 | 1218 |
1194 // Write some messages to the first endpoint and then close it. | 1219 // Write some messages to the first endpoint and then close it. |
1195 WriteMessage(pipe[0], "baz"); | 1220 WriteMessage(pipe[0], "baz"); |
1196 WriteMessage(pipe[0], "qux"); | 1221 WriteMessage(pipe[0], "qux"); |
(...skipping 22 matching lines...) Expand all Loading... |
1219 WriteMessageWithHandles(h, "foo", pipe, 2); | 1244 WriteMessageWithHandles(h, "foo", pipe, 2); |
1220 | 1245 |
1221 // Read back an endpoint which should have messages on it. | 1246 // Read back an endpoint which should have messages on it. |
1222 MojoHandle p; | 1247 MojoHandle p; |
1223 EXPECT_EQ("bar", ReadMessageWithHandles(h, &p, 1)); | 1248 EXPECT_EQ("bar", ReadMessageWithHandles(h, &p, 1)); |
1224 | 1249 |
1225 EXPECT_EQ("baz", ReadMessage(p)); | 1250 EXPECT_EQ("baz", ReadMessage(p)); |
1226 EXPECT_EQ("qux", ReadMessage(p)); | 1251 EXPECT_EQ("qux", ReadMessage(p)); |
1227 | 1252 |
1228 // Expect to have peer closure signaled. | 1253 // Expect to have peer closure signaled. |
1229 EXPECT_EQ(MOJO_RESULT_OK, | 1254 EXPECT_EQ(MOJO_RESULT_OK, MojoWait(p, MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
1230 WaitForSignals(p, MOJO_HANDLE_SIGNAL_PEER_CLOSED)); | 1255 MOJO_DEADLINE_INDEFINITE, nullptr)); |
1231 | 1256 |
1232 WriteMessage(h, "quit"); | 1257 WriteMessage(h, "quit"); |
1233 END_CHILD() | 1258 END_CHILD() |
1234 } | 1259 } |
1235 | 1260 |
1236 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(MessagePipeStatusChangeInTransitClient, | 1261 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(MessagePipeStatusChangeInTransitClient, |
1237 MultiprocessMessagePipeTest, parent) { | 1262 MultiprocessMessagePipeTest, parent) { |
1238 // This test verifies that peer closure is detectable through various | 1263 // This test verifies that peer closure is detectable through various |
1239 // mechanisms when it races with handle transfer. | 1264 // mechanisms when it races with handle transfer. |
1240 MojoHandle handles[4]; | 1265 MojoHandle handles[4]; |
1241 EXPECT_EQ("o_O", ReadMessageWithHandles(parent, handles, 4)); | 1266 EXPECT_EQ("o_O", ReadMessageWithHandles(parent, handles, 4)); |
1242 | 1267 |
1243 EXPECT_EQ(MOJO_RESULT_OK, | 1268 // Wait on handle 0 using MojoWait. |
1244 WaitForSignals(handles[0], MOJO_HANDLE_SIGNAL_PEER_CLOSED)); | 1269 EXPECT_EQ(MOJO_RESULT_OK, MojoWait(handles[0], MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| 1270 MOJO_DEADLINE_INDEFINITE, nullptr)); |
1245 | 1271 |
1246 base::MessageLoop message_loop; | 1272 base::MessageLoop message_loop; |
1247 | 1273 |
1248 // Wait on handle 1 using a SimpleWatcher. | 1274 // Wait on handle 1 using a SimpleWatcher. |
1249 { | 1275 { |
1250 base::RunLoop run_loop; | 1276 base::RunLoop run_loop; |
1251 SimpleWatcher watcher(FROM_HERE, SimpleWatcher::ArmingPolicy::AUTOMATIC); | 1277 SimpleWatcher watcher(FROM_HERE, SimpleWatcher::ArmingPolicy::AUTOMATIC); |
1252 watcher.Watch(Handle(handles[1]), MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 1278 watcher.Watch(Handle(handles[1]), MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
1253 base::Bind( | 1279 base::Bind( |
1254 [](base::RunLoop* loop, MojoResult result) { | 1280 [](base::RunLoop* loop, MojoResult result) { |
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1316 set_process_error_callback(base::Bind(&OnProcessError, | 1342 set_process_error_callback(base::Bind(&OnProcessError, |
1317 &second_process_error)); | 1343 &second_process_error)); |
1318 RUN_CHILD_ON_PIPE(BadMessageClient, child2) | 1344 RUN_CHILD_ON_PIPE(BadMessageClient, child2) |
1319 MojoHandle a, b, c, d; | 1345 MojoHandle a, b, c, d; |
1320 CreateMessagePipe(&a, &b); | 1346 CreateMessagePipe(&a, &b); |
1321 CreateMessagePipe(&c, &d); | 1347 CreateMessagePipe(&c, &d); |
1322 WriteMessageWithHandles(child1, "hi", &b, 1); | 1348 WriteMessageWithHandles(child1, "hi", &b, 1); |
1323 WriteMessageWithHandles(child2, "hi", &d, 1); | 1349 WriteMessageWithHandles(child2, "hi", &d, 1); |
1324 | 1350 |
1325 // Read a message from the pipe we sent to child1 and flag it as bad. | 1351 // Read a message from the pipe we sent to child1 and flag it as bad. |
1326 ASSERT_EQ(MOJO_RESULT_OK, WaitForSignals(a, MOJO_HANDLE_SIGNAL_READABLE)); | 1352 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(a, MOJO_HANDLE_SIGNAL_READABLE, |
| 1353 MOJO_DEADLINE_INDEFINITE, nullptr)); |
1327 uint32_t num_bytes = 0; | 1354 uint32_t num_bytes = 0; |
1328 MojoMessageHandle message; | 1355 MojoMessageHandle message; |
1329 ASSERT_EQ(MOJO_RESULT_OK, | 1356 ASSERT_EQ(MOJO_RESULT_OK, |
1330 MojoReadMessageNew(a, &message, &num_bytes, nullptr, 0, | 1357 MojoReadMessageNew(a, &message, &num_bytes, nullptr, 0, |
1331 MOJO_READ_MESSAGE_FLAG_NONE)); | 1358 MOJO_READ_MESSAGE_FLAG_NONE)); |
1332 EXPECT_EQ(MOJO_RESULT_OK, | 1359 EXPECT_EQ(MOJO_RESULT_OK, |
1333 MojoNotifyBadMessage(message, kFirstErrorMessage.data(), | 1360 MojoNotifyBadMessage(message, kFirstErrorMessage.data(), |
1334 kFirstErrorMessage.size())); | 1361 kFirstErrorMessage.size())); |
1335 EXPECT_EQ(MOJO_RESULT_OK, MojoFreeMessage(message)); | 1362 EXPECT_EQ(MOJO_RESULT_OK, MojoFreeMessage(message)); |
1336 | 1363 |
1337 // Read a message from the pipe we sent to child2 and flag it as bad. | 1364 // Read a message from the pipe we sent to child2 and flag it as bad. |
1338 ASSERT_EQ(MOJO_RESULT_OK, WaitForSignals(c, MOJO_HANDLE_SIGNAL_READABLE)); | 1365 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(c, MOJO_HANDLE_SIGNAL_READABLE, |
| 1366 MOJO_DEADLINE_INDEFINITE, nullptr)); |
1339 ASSERT_EQ(MOJO_RESULT_OK, | 1367 ASSERT_EQ(MOJO_RESULT_OK, |
1340 MojoReadMessageNew(c, &message, &num_bytes, nullptr, 0, | 1368 MojoReadMessageNew(c, &message, &num_bytes, nullptr, 0, |
1341 MOJO_READ_MESSAGE_FLAG_NONE)); | 1369 MOJO_READ_MESSAGE_FLAG_NONE)); |
1342 EXPECT_EQ(MOJO_RESULT_OK, | 1370 EXPECT_EQ(MOJO_RESULT_OK, |
1343 MojoNotifyBadMessage(message, kSecondErrorMessage.data(), | 1371 MojoNotifyBadMessage(message, kSecondErrorMessage.data(), |
1344 kSecondErrorMessage.size())); | 1372 kSecondErrorMessage.size())); |
1345 EXPECT_EQ(MOJO_RESULT_OK, MojoFreeMessage(message)); | 1373 EXPECT_EQ(MOJO_RESULT_OK, MojoFreeMessage(message)); |
1346 | 1374 |
1347 WriteMessage(child2, "bye"); | 1375 WriteMessage(child2, "bye"); |
1348 END_CHILD(); | 1376 END_CHILD(); |
1349 | 1377 |
1350 WriteMessage(child1, "bye"); | 1378 WriteMessage(child1, "bye"); |
1351 END_CHILD() | 1379 END_CHILD() |
1352 | 1380 |
1353 // The error messages should match the processes which triggered them. | 1381 // The error messages should match the processes which triggered them. |
1354 EXPECT_NE(std::string::npos, first_process_error.find(kFirstErrorMessage)); | 1382 EXPECT_NE(std::string::npos, first_process_error.find(kFirstErrorMessage)); |
1355 EXPECT_NE(std::string::npos, second_process_error.find(kSecondErrorMessage)); | 1383 EXPECT_NE(std::string::npos, second_process_error.find(kSecondErrorMessage)); |
1356 } | 1384 } |
1357 INSTANTIATE_TEST_CASE_P( | 1385 INSTANTIATE_TEST_CASE_P( |
1358 , | 1386 , |
1359 MultiprocessMessagePipeTestWithPeerSupport, | 1387 MultiprocessMessagePipeTestWithPeerSupport, |
1360 testing::Values(test::MojoTestBase::LaunchType::CHILD, | 1388 testing::Values(test::MojoTestBase::LaunchType::CHILD, |
1361 test::MojoTestBase::LaunchType::PEER, | 1389 test::MojoTestBase::LaunchType::PEER, |
1362 test::MojoTestBase::LaunchType::NAMED_CHILD, | 1390 test::MojoTestBase::LaunchType::NAMED_CHILD, |
1363 test::MojoTestBase::LaunchType::NAMED_PEER)); | 1391 test::MojoTestBase::LaunchType::NAMED_PEER)); |
1364 } // namespace | 1392 } // namespace |
1365 } // namespace edk | 1393 } // namespace edk |
1366 } // namespace mojo | 1394 } // namespace mojo |
OLD | NEW |