Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(109)

Side by Side Diff: mojo/edk/system/multiprocess_message_pipe_unittest.cc

Issue 623883002: Revert "Move mojo edk into mojo/edk" (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 6 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « mojo/edk/system/message_pipe_unittest.cc ('k') | mojo/edk/system/options_validation.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include <stdint.h>
6 #include <stdio.h>
7 #include <string.h>
8
9 #include <string>
10 #include <vector>
11
12 #include "base/bind.h"
13 #include "base/files/file_path.h"
14 #include "base/files/file_util.h"
15 #include "base/files/scoped_file.h"
16 #include "base/files/scoped_temp_dir.h"
17 #include "base/location.h"
18 #include "base/logging.h"
19 #include "base/macros.h"
20 #include "build/build_config.h" // TODO(vtl): Remove this.
21 #include "mojo/edk/embedder/platform_shared_buffer.h"
22 #include "mojo/edk/embedder/scoped_platform_handle.h"
23 #include "mojo/edk/system/channel.h"
24 #include "mojo/edk/system/dispatcher.h"
25 #include "mojo/edk/system/message_pipe.h"
26 #include "mojo/edk/system/message_pipe_test_utils.h"
27 #include "mojo/edk/system/platform_handle_dispatcher.h"
28 #include "mojo/edk/system/raw_channel.h"
29 #include "mojo/edk/system/shared_buffer_dispatcher.h"
30 #include "mojo/edk/system/test_utils.h"
31 #include "mojo/edk/test/test_utils.h"
32 #include "testing/gtest/include/gtest/gtest.h"
33
34 namespace mojo {
35 namespace system {
36 namespace {
37
38 class MultiprocessMessagePipeTest
39 : public test::MultiprocessMessagePipeTestBase {};
40
41 // For each message received, sends a reply message with the same contents
42 // repeated twice, until the other end is closed or it receives "quitquitquit"
43 // (which it doesn't reply to). It'll return the number of messages received,
44 // not including any "quitquitquit" message, modulo 100.
45 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(EchoEcho) {
46 embedder::SimplePlatformSupport platform_support;
47 test::ChannelThread channel_thread(&platform_support);
48 embedder::ScopedPlatformHandle client_platform_handle =
49 mojo::test::MultiprocessTestHelper::client_platform_handle.Pass();
50 CHECK(client_platform_handle.is_valid());
51 scoped_refptr<ChannelEndpoint> ep;
52 scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
53 channel_thread.Start(client_platform_handle.Pass(), ep);
54
55 const std::string quitquitquit("quitquitquit");
56 int rv = 0;
57 for (;; rv = (rv + 1) % 100) {
58 // Wait for our end of the message pipe to be readable.
59 HandleSignalsState hss;
60 MojoResult result =
61 test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss);
62 if (result != MOJO_RESULT_OK) {
63 // It was closed, probably.
64 CHECK_EQ(result, MOJO_RESULT_FAILED_PRECONDITION);
65 CHECK_EQ(hss.satisfied_signals, 0u);
66 CHECK_EQ(hss.satisfiable_signals, 0u);
67 break;
68 } else {
69 CHECK((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
70 CHECK((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
71 }
72
73 std::string read_buffer(1000, '\0');
74 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
75 CHECK_EQ(mp->ReadMessage(0,
76 UserPointer<void>(&read_buffer[0]),
77 MakeUserPointer(&read_buffer_size),
78 nullptr,
79 nullptr,
80 MOJO_READ_MESSAGE_FLAG_NONE),
81 MOJO_RESULT_OK);
82 read_buffer.resize(read_buffer_size);
83 VLOG(2) << "Child got: " << read_buffer;
84
85 if (read_buffer == quitquitquit) {
86 VLOG(2) << "Child quitting.";
87 break;
88 }
89
90 std::string write_buffer = read_buffer + read_buffer;
91 CHECK_EQ(mp->WriteMessage(0,
92 UserPointer<const void>(write_buffer.data()),
93 static_cast<uint32_t>(write_buffer.size()),
94 nullptr,
95 MOJO_WRITE_MESSAGE_FLAG_NONE),
96 MOJO_RESULT_OK);
97 }
98
99 mp->Close(0);
100 return rv;
101 }
102
103 // Sends "hello" to child, and expects "hellohello" back.
104 TEST_F(MultiprocessMessagePipeTest, Basic) {
105 helper()->StartChild("EchoEcho");
106
107 scoped_refptr<ChannelEndpoint> ep;
108 scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
109 Init(ep);
110
111 std::string hello("hello");
112 EXPECT_EQ(MOJO_RESULT_OK,
113 mp->WriteMessage(0,
114 UserPointer<const void>(hello.data()),
115 static_cast<uint32_t>(hello.size()),
116 nullptr,
117 MOJO_WRITE_MESSAGE_FLAG_NONE));
118
119 HandleSignalsState hss;
120 EXPECT_EQ(MOJO_RESULT_OK,
121 test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
122 // The child may or may not have closed its end of the message pipe and died
123 // (and we may or may not know it yet), so our end may or may not appear as
124 // writable.
125 EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
126 EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
127
128 std::string read_buffer(1000, '\0');
129 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
130 CHECK_EQ(mp->ReadMessage(0,
131 UserPointer<void>(&read_buffer[0]),
132 MakeUserPointer(&read_buffer_size),
133 nullptr,
134 nullptr,
135 MOJO_READ_MESSAGE_FLAG_NONE),
136 MOJO_RESULT_OK);
137 read_buffer.resize(read_buffer_size);
138 VLOG(2) << "Parent got: " << read_buffer;
139 EXPECT_EQ(hello + hello, read_buffer);
140
141 mp->Close(0);
142
143 // We sent one message.
144 EXPECT_EQ(1 % 100, helper()->WaitForChildShutdown());
145 }
146
147 // Sends a bunch of messages to the child. Expects them "repeated" back. Waits
148 // for the child to close its end before quitting.
149 TEST_F(MultiprocessMessagePipeTest, QueueMessages) {
150 helper()->StartChild("EchoEcho");
151
152 scoped_refptr<ChannelEndpoint> ep;
153 scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
154 Init(ep);
155
156 static const size_t kNumMessages = 1001;
157 for (size_t i = 0; i < kNumMessages; i++) {
158 std::string write_buffer(i, 'A' + (i % 26));
159 EXPECT_EQ(MOJO_RESULT_OK,
160 mp->WriteMessage(0,
161 UserPointer<const void>(write_buffer.data()),
162 static_cast<uint32_t>(write_buffer.size()),
163 nullptr,
164 MOJO_WRITE_MESSAGE_FLAG_NONE));
165 }
166
167 const std::string quitquitquit("quitquitquit");
168 EXPECT_EQ(MOJO_RESULT_OK,
169 mp->WriteMessage(0,
170 UserPointer<const void>(quitquitquit.data()),
171 static_cast<uint32_t>(quitquitquit.size()),
172 nullptr,
173 MOJO_WRITE_MESSAGE_FLAG_NONE));
174
175 for (size_t i = 0; i < kNumMessages; i++) {
176 HandleSignalsState hss;
177 EXPECT_EQ(MOJO_RESULT_OK,
178 test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
179 // The child may or may not have closed its end of the message pipe and died
180 // (and we may or may not know it yet), so our end may or may not appear as
181 // writable.
182 EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
183 EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
184
185 std::string read_buffer(kNumMessages * 2, '\0');
186 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
187 CHECK_EQ(mp->ReadMessage(0,
188 UserPointer<void>(&read_buffer[0]),
189 MakeUserPointer(&read_buffer_size),
190 nullptr,
191 nullptr,
192 MOJO_READ_MESSAGE_FLAG_NONE),
193 MOJO_RESULT_OK);
194 read_buffer.resize(read_buffer_size);
195
196 EXPECT_EQ(std::string(i * 2, 'A' + (i % 26)), read_buffer);
197 }
198
199 // Wait for it to become readable, which should fail (since we sent
200 // "quitquitquit").
201 HandleSignalsState hss;
202 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
203 test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
204 EXPECT_EQ(0u, hss.satisfied_signals);
205 EXPECT_EQ(0u, hss.satisfiable_signals);
206
207 mp->Close(0);
208
209 EXPECT_EQ(static_cast<int>(kNumMessages % 100),
210 helper()->WaitForChildShutdown());
211 }
212
213 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckSharedBuffer) {
214 embedder::SimplePlatformSupport platform_support;
215 test::ChannelThread channel_thread(&platform_support);
216 embedder::ScopedPlatformHandle client_platform_handle =
217 mojo::test::MultiprocessTestHelper::client_platform_handle.Pass();
218 CHECK(client_platform_handle.is_valid());
219 scoped_refptr<ChannelEndpoint> ep;
220 scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
221 channel_thread.Start(client_platform_handle.Pass(), ep);
222
223 // Wait for the first message from our parent.
224 HandleSignalsState hss;
225 CHECK_EQ(test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss),
226 MOJO_RESULT_OK);
227 // In this test, the parent definitely doesn't close its end of the message
228 // pipe before we do.
229 CHECK_EQ(hss.satisfied_signals,
230 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
231 CHECK_EQ(hss.satisfiable_signals,
232 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
233
234 // It should have a shared buffer.
235 std::string read_buffer(100, '\0');
236 uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
237 DispatcherVector dispatchers;
238 uint32_t num_dispatchers = 10; // Maximum number to receive.
239 CHECK_EQ(mp->ReadMessage(0,
240 UserPointer<void>(&read_buffer[0]),
241 MakeUserPointer(&num_bytes),
242 &dispatchers,
243 &num_dispatchers,
244 MOJO_READ_MESSAGE_FLAG_NONE),
245 MOJO_RESULT_OK);
246 read_buffer.resize(num_bytes);
247 CHECK_EQ(read_buffer, std::string("go 1"));
248 CHECK_EQ(num_dispatchers, 1u);
249
250 CHECK_EQ(dispatchers[0]->GetType(), Dispatcher::kTypeSharedBuffer);
251
252 scoped_refptr<SharedBufferDispatcher> dispatcher(
253 static_cast<SharedBufferDispatcher*>(dispatchers[0].get()));
254
255 // Make a mapping.
256 scoped_ptr<embedder::PlatformSharedBufferMapping> mapping;
257 CHECK_EQ(dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping),
258 MOJO_RESULT_OK);
259 CHECK(mapping);
260 CHECK(mapping->GetBase());
261 CHECK_EQ(mapping->GetLength(), 100u);
262
263 // Write some stuff to the shared buffer.
264 static const char kHello[] = "hello";
265 memcpy(mapping->GetBase(), kHello, sizeof(kHello));
266
267 // We should be able to close the dispatcher now.
268 dispatcher->Close();
269
270 // And send a message to signal that we've written stuff.
271 const std::string go2("go 2");
272 CHECK_EQ(mp->WriteMessage(0,
273 UserPointer<const void>(&go2[0]),
274 static_cast<uint32_t>(go2.size()),
275 nullptr,
276 MOJO_WRITE_MESSAGE_FLAG_NONE),
277 MOJO_RESULT_OK);
278
279 // Now wait for our parent to send us a message.
280 hss = HandleSignalsState();
281 CHECK_EQ(test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss),
282 MOJO_RESULT_OK);
283 CHECK_EQ(hss.satisfied_signals,
284 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
285 CHECK_EQ(hss.satisfiable_signals,
286 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
287
288 read_buffer = std::string(100, '\0');
289 num_bytes = static_cast<uint32_t>(read_buffer.size());
290 CHECK_EQ(mp->ReadMessage(0,
291 UserPointer<void>(&read_buffer[0]),
292 MakeUserPointer(&num_bytes),
293 nullptr,
294 nullptr,
295 MOJO_READ_MESSAGE_FLAG_NONE),
296 MOJO_RESULT_OK);
297 read_buffer.resize(num_bytes);
298 CHECK_EQ(read_buffer, std::string("go 3"));
299
300 // It should have written something to the shared buffer.
301 static const char kWorld[] = "world!!!";
302 CHECK_EQ(memcmp(mapping->GetBase(), kWorld, sizeof(kWorld)), 0);
303
304 // And we're done.
305 mp->Close(0);
306
307 return 0;
308 }
309
310 #if defined(OS_POSIX)
311 #define MAYBE_SharedBufferPassing SharedBufferPassing
312 #else
313 // Not yet implemented (on Windows).
314 #define MAYBE_SharedBufferPassing DISABLED_SharedBufferPassing
315 #endif
316 TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) {
317 helper()->StartChild("CheckSharedBuffer");
318
319 scoped_refptr<ChannelEndpoint> ep;
320 scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
321 Init(ep);
322
323 // Make a shared buffer.
324 scoped_refptr<SharedBufferDispatcher> dispatcher;
325 EXPECT_EQ(MOJO_RESULT_OK,
326 SharedBufferDispatcher::Create(
327 platform_support(),
328 SharedBufferDispatcher::kDefaultCreateOptions,
329 100,
330 &dispatcher));
331 ASSERT_TRUE(dispatcher.get());
332
333 // Make a mapping.
334 scoped_ptr<embedder::PlatformSharedBufferMapping> mapping;
335 EXPECT_EQ(MOJO_RESULT_OK,
336 dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
337 ASSERT_TRUE(mapping);
338 ASSERT_TRUE(mapping->GetBase());
339 ASSERT_EQ(100u, mapping->GetLength());
340
341 // Send the shared buffer.
342 const std::string go1("go 1");
343 DispatcherTransport transport(
344 test::DispatcherTryStartTransport(dispatcher.get()));
345 ASSERT_TRUE(transport.is_valid());
346
347 std::vector<DispatcherTransport> transports;
348 transports.push_back(transport);
349 EXPECT_EQ(MOJO_RESULT_OK,
350 mp->WriteMessage(0,
351 UserPointer<const void>(&go1[0]),
352 static_cast<uint32_t>(go1.size()),
353 &transports,
354 MOJO_WRITE_MESSAGE_FLAG_NONE));
355 transport.End();
356
357 EXPECT_TRUE(dispatcher->HasOneRef());
358 dispatcher = nullptr;
359
360 // Wait for a message from the child.
361 HandleSignalsState hss;
362 EXPECT_EQ(MOJO_RESULT_OK,
363 test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
364 EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
365 EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
366
367 std::string read_buffer(100, '\0');
368 uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
369 EXPECT_EQ(MOJO_RESULT_OK,
370 mp->ReadMessage(0,
371 UserPointer<void>(&read_buffer[0]),
372 MakeUserPointer(&num_bytes),
373 nullptr,
374 nullptr,
375 MOJO_READ_MESSAGE_FLAG_NONE));
376 read_buffer.resize(num_bytes);
377 EXPECT_EQ(std::string("go 2"), read_buffer);
378
379 // After we get it, the child should have written something to the shared
380 // buffer.
381 static const char kHello[] = "hello";
382 EXPECT_EQ(0, memcmp(mapping->GetBase(), kHello, sizeof(kHello)));
383
384 // Now we'll write some stuff to the shared buffer.
385 static const char kWorld[] = "world!!!";
386 memcpy(mapping->GetBase(), kWorld, sizeof(kWorld));
387
388 // And send a message to signal that we've written stuff.
389 const std::string go3("go 3");
390 EXPECT_EQ(MOJO_RESULT_OK,
391 mp->WriteMessage(0,
392 UserPointer<const void>(&go3[0]),
393 static_cast<uint32_t>(go3.size()),
394 nullptr,
395 MOJO_WRITE_MESSAGE_FLAG_NONE));
396
397 // Wait for |mp| to become readable, which should fail.
398 hss = HandleSignalsState();
399 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
400 test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
401 EXPECT_EQ(0u, hss.satisfied_signals);
402 EXPECT_EQ(0u, hss.satisfiable_signals);
403
404 mp->Close(0);
405
406 EXPECT_EQ(0, helper()->WaitForChildShutdown());
407 }
408
409 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckPlatformHandleFile) {
410 embedder::SimplePlatformSupport platform_support;
411 test::ChannelThread channel_thread(&platform_support);
412 embedder::ScopedPlatformHandle client_platform_handle =
413 mojo::test::MultiprocessTestHelper::client_platform_handle.Pass();
414 CHECK(client_platform_handle.is_valid());
415 scoped_refptr<ChannelEndpoint> ep;
416 scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
417 channel_thread.Start(client_platform_handle.Pass(), ep);
418
419 HandleSignalsState hss;
420 CHECK_EQ(test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss),
421 MOJO_RESULT_OK);
422 CHECK_EQ(hss.satisfied_signals,
423 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
424 CHECK_EQ(hss.satisfiable_signals,
425 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE);
426
427 std::string read_buffer(100, '\0');
428 uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
429 DispatcherVector dispatchers;
430 uint32_t num_dispatchers = 10; // Maximum number to receive.
431 CHECK_EQ(mp->ReadMessage(0,
432 UserPointer<void>(&read_buffer[0]),
433 MakeUserPointer(&num_bytes),
434 &dispatchers,
435 &num_dispatchers,
436 MOJO_READ_MESSAGE_FLAG_NONE),
437 MOJO_RESULT_OK);
438 mp->Close(0);
439
440 read_buffer.resize(num_bytes);
441 CHECK_EQ(read_buffer, std::string("hello"));
442 CHECK_EQ(num_dispatchers, 1u);
443
444 CHECK_EQ(dispatchers[0]->GetType(), Dispatcher::kTypePlatformHandle);
445
446 scoped_refptr<PlatformHandleDispatcher> dispatcher(
447 static_cast<PlatformHandleDispatcher*>(dispatchers[0].get()));
448 embedder::ScopedPlatformHandle h = dispatcher->PassPlatformHandle().Pass();
449 CHECK(h.is_valid());
450 dispatcher->Close();
451
452 base::ScopedFILE fp(mojo::test::FILEFromPlatformHandle(h.Pass(), "r"));
453 CHECK(fp);
454 std::string fread_buffer(100, '\0');
455 size_t bytes_read = fread(&fread_buffer[0], 1, fread_buffer.size(), fp.get());
456 fread_buffer.resize(bytes_read);
457 CHECK_EQ(fread_buffer, "world");
458
459 return 0;
460 }
461
462 #if defined(OS_POSIX)
463 #define MAYBE_PlatformHandlePassing PlatformHandlePassing
464 #else
465 // Not yet implemented (on Windows).
466 #define MAYBE_PlatformHandlePassing DISABLED_PlatformHandlePassing
467 #endif
468 TEST_F(MultiprocessMessagePipeTest, MAYBE_PlatformHandlePassing) {
469 base::ScopedTempDir temp_dir;
470 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
471
472 helper()->StartChild("CheckPlatformHandleFile");
473
474 scoped_refptr<ChannelEndpoint> ep;
475 scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy(&ep));
476 Init(ep);
477
478 base::FilePath unused;
479 base::ScopedFILE fp(
480 CreateAndOpenTemporaryFileInDir(temp_dir.path(), &unused));
481 const std::string world("world");
482 ASSERT_EQ(fwrite(&world[0], 1, world.size(), fp.get()), world.size());
483 fflush(fp.get());
484 rewind(fp.get());
485
486 embedder::ScopedPlatformHandle h(
487 mojo::test::PlatformHandleFromFILE(fp.Pass()));
488 scoped_refptr<PlatformHandleDispatcher> dispatcher(
489 new PlatformHandleDispatcher(h.Pass()));
490
491 const std::string hello("hello");
492 DispatcherTransport transport(
493 test::DispatcherTryStartTransport(dispatcher.get()));
494 ASSERT_TRUE(transport.is_valid());
495
496 std::vector<DispatcherTransport> transports;
497 transports.push_back(transport);
498 EXPECT_EQ(MOJO_RESULT_OK,
499 mp->WriteMessage(0,
500 UserPointer<const void>(&hello[0]),
501 static_cast<uint32_t>(hello.size()),
502 &transports,
503 MOJO_WRITE_MESSAGE_FLAG_NONE));
504 transport.End();
505
506 EXPECT_TRUE(dispatcher->HasOneRef());
507 dispatcher = nullptr;
508
509 // Wait for it to become readable, which should fail.
510 HandleSignalsState hss;
511 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
512 test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss));
513 EXPECT_EQ(0u, hss.satisfied_signals);
514 EXPECT_EQ(0u, hss.satisfiable_signals);
515
516 mp->Close(0);
517
518 EXPECT_EQ(0, helper()->WaitForChildShutdown());
519 }
520
521 } // namespace
522 } // namespace system
523 } // namespace mojo
OLDNEW
« no previous file with comments | « mojo/edk/system/message_pipe_unittest.cc ('k') | mojo/edk/system/options_validation.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698