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

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

Issue 2744943002: Mojo: Move waiting APIs to public library (Closed)
Patch Set: . Created 3 years, 9 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/core_test_base.cc ('k') | mojo/edk/system/data_pipe_consumer_dispatcher.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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 "mojo/edk/system/core.h" 5 #include "mojo/edk/system/core.h"
6 6
7 #include <stdint.h> 7 #include <stdint.h>
8 8
9 #include <limits> 9 #include <limits>
10 10
11 #include "base/bind.h" 11 #include "base/bind.h"
12 #include "mojo/edk/embedder/embedder_internal.h" 12 #include "mojo/edk/embedder/embedder_internal.h"
13 #include "mojo/edk/system/awakable.h"
14 #include "mojo/edk/system/core_test_base.h" 13 #include "mojo/edk/system/core_test_base.h"
15 #include "mojo/edk/system/test_utils.h" 14 #include "mojo/edk/system/test_utils.h"
15 #include "mojo/public/cpp/system/wait.h"
16 16
17 #if defined(OS_WIN) 17 #if defined(OS_WIN)
18 #include "base/win/windows_version.h" 18 #include "base/win/windows_version.h"
19 #endif 19 #endif
20 20
21 namespace mojo { 21 namespace mojo {
22 namespace edk { 22 namespace edk {
23 namespace { 23 namespace {
24 24
25 const MojoHandleSignalsState kEmptyMojoHandleSignalsState = {0u, 0u}; 25 const MojoHandleSignalsState kEmptyMojoHandleSignalsState = {0u, 0u};
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after
90 ASSERT_EQ(0u, info.GetBeginReadDataCallCount()); 90 ASSERT_EQ(0u, info.GetBeginReadDataCallCount());
91 ASSERT_EQ(MOJO_RESULT_UNIMPLEMENTED, 91 ASSERT_EQ(MOJO_RESULT_UNIMPLEMENTED,
92 core()->BeginReadData(h, nullptr, nullptr, 92 core()->BeginReadData(h, nullptr, nullptr,
93 MOJO_READ_DATA_FLAG_NONE)); 93 MOJO_READ_DATA_FLAG_NONE));
94 ASSERT_EQ(1u, info.GetBeginReadDataCallCount()); 94 ASSERT_EQ(1u, info.GetBeginReadDataCallCount());
95 95
96 ASSERT_EQ(0u, info.GetEndReadDataCallCount()); 96 ASSERT_EQ(0u, info.GetEndReadDataCallCount());
97 ASSERT_EQ(MOJO_RESULT_UNIMPLEMENTED, core()->EndReadData(h, 0)); 97 ASSERT_EQ(MOJO_RESULT_UNIMPLEMENTED, core()->EndReadData(h, 0));
98 ASSERT_EQ(1u, info.GetEndReadDataCallCount()); 98 ASSERT_EQ(1u, info.GetEndReadDataCallCount());
99 99
100 ASSERT_EQ(0u, info.GetAddAwakableCallCount());
101 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
102 core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE,
103 nullptr));
104 ASSERT_EQ(1u, info.GetAddAwakableCallCount());
105 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
106 core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 0, nullptr));
107 ASSERT_EQ(2u, info.GetAddAwakableCallCount());
108 MojoHandleSignalsState hss = kFullMojoHandleSignalsState;
109 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
110 core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE,
111 &hss));
112 ASSERT_EQ(3u, info.GetAddAwakableCallCount());
113 ASSERT_EQ(0u, hss.satisfied_signals);
114 ASSERT_EQ(0u, hss.satisfiable_signals);
115 ASSERT_EQ(
116 MOJO_RESULT_FAILED_PRECONDITION,
117 core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000, nullptr));
118 ASSERT_EQ(4u, info.GetAddAwakableCallCount());
119 hss = kFullMojoHandleSignalsState;
120 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
121 core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000, &hss));
122 ASSERT_EQ(5u, info.GetAddAwakableCallCount());
123 ASSERT_EQ(0u, hss.satisfied_signals);
124 ASSERT_EQ(0u, hss.satisfiable_signals);
125
126 MojoHandleSignals handle_signals = ~MOJO_HANDLE_SIGNAL_NONE;
127 ASSERT_EQ(
128 MOJO_RESULT_FAILED_PRECONDITION,
129 core()->WaitMany(&h, &handle_signals, 1, MOJO_DEADLINE_INDEFINITE,
130 nullptr, nullptr));
131 ASSERT_EQ(6u, info.GetAddAwakableCallCount());
132 uint32_t result_index = static_cast<uint32_t>(-1);
133 ASSERT_EQ(
134 MOJO_RESULT_FAILED_PRECONDITION,
135 core()->WaitMany(&h, &handle_signals, 1, MOJO_DEADLINE_INDEFINITE,
136 &result_index, nullptr));
137 ASSERT_EQ(7u, info.GetAddAwakableCallCount());
138 ASSERT_EQ(0u, result_index);
139 hss = kFullMojoHandleSignalsState;
140 ASSERT_EQ(
141 MOJO_RESULT_FAILED_PRECONDITION,
142 core()->WaitMany(&h, &handle_signals, 1, MOJO_DEADLINE_INDEFINITE,
143 nullptr, &hss));
144 ASSERT_EQ(8u, info.GetAddAwakableCallCount());
145 ASSERT_EQ(0u, hss.satisfied_signals);
146 ASSERT_EQ(0u, hss.satisfiable_signals);
147 result_index = static_cast<uint32_t>(-1);
148 hss = kFullMojoHandleSignalsState;
149 ASSERT_EQ(
150 MOJO_RESULT_FAILED_PRECONDITION,
151 core()->WaitMany(&h, &handle_signals, 1, MOJO_DEADLINE_INDEFINITE,
152 &result_index, &hss));
153 ASSERT_EQ(9u, info.GetAddAwakableCallCount());
154 ASSERT_EQ(0u, result_index);
155 ASSERT_EQ(0u, hss.satisfied_signals);
156 ASSERT_EQ(0u, hss.satisfiable_signals);
157
158 ASSERT_EQ(0u, info.GetDtorCallCount()); 100 ASSERT_EQ(0u, info.GetDtorCallCount());
159 ASSERT_EQ(0u, info.GetCloseCallCount()); 101 ASSERT_EQ(0u, info.GetCloseCallCount());
160 ASSERT_EQ(MOJO_RESULT_OK, core()->Close(h)); 102 ASSERT_EQ(MOJO_RESULT_OK, core()->Close(h));
161 ASSERT_EQ(1u, info.GetCloseCallCount()); 103 ASSERT_EQ(1u, info.GetCloseCallCount());
162 ASSERT_EQ(1u, info.GetDtorCallCount()); 104 ASSERT_EQ(1u, info.GetDtorCallCount());
163
164 // No awakables should ever have ever been added.
165 ASSERT_EQ(0u, info.GetRemoveAwakableCallCount());
166 } 105 }
167 106
168 TEST_F(CoreTest, InvalidArguments) { 107 TEST_F(CoreTest, InvalidArguments) {
169 // |Close()|: 108 // |Close()|:
170 { 109 {
171 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(MOJO_HANDLE_INVALID)); 110 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(MOJO_HANDLE_INVALID));
172 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(10)); 111 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(10));
173 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(1000000000)); 112 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(1000000000));
174 113
175 // Test a double-close. 114 // Test a double-close.
176 MockHandleInfo info; 115 MockHandleInfo info;
177 MojoHandle h = CreateMockHandle(&info); 116 MojoHandle h = CreateMockHandle(&info);
178 ASSERT_EQ(MOJO_RESULT_OK, core()->Close(h)); 117 ASSERT_EQ(MOJO_RESULT_OK, core()->Close(h));
179 ASSERT_EQ(1u, info.GetCloseCallCount()); 118 ASSERT_EQ(1u, info.GetCloseCallCount());
180 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(h)); 119 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(h));
181 ASSERT_EQ(1u, info.GetCloseCallCount()); 120 ASSERT_EQ(1u, info.GetCloseCallCount());
182 } 121 }
183 122
184 // |Wait()|:
185 {
186 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
187 core()->Wait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE,
188 MOJO_DEADLINE_INDEFINITE, nullptr));
189 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
190 core()->Wait(10, ~MOJO_HANDLE_SIGNAL_NONE,
191 MOJO_DEADLINE_INDEFINITE, nullptr));
192
193 MojoHandleSignalsState hss = kFullMojoHandleSignalsState;
194 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
195 core()->Wait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE,
196 MOJO_DEADLINE_INDEFINITE, &hss));
197 // On invalid argument, it shouldn't modify the handle signals state.
198 ASSERT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
199 hss.satisfied_signals);
200 ASSERT_EQ(kFullMojoHandleSignalsState.satisfiable_signals,
201 hss.satisfiable_signals);
202 hss = kFullMojoHandleSignalsState;
203 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
204 core()->Wait(10, ~MOJO_HANDLE_SIGNAL_NONE,
205 MOJO_DEADLINE_INDEFINITE, &hss));
206 // On invalid argument, it shouldn't modify the handle signals state.
207 ASSERT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
208 hss.satisfied_signals);
209 ASSERT_EQ(kFullMojoHandleSignalsState.satisfiable_signals,
210 hss.satisfiable_signals);
211 }
212
213 // |WaitMany()|:
214 {
215 MojoHandle handles[2] = {MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID};
216 MojoHandleSignals signals[2] = {~MOJO_HANDLE_SIGNAL_NONE,
217 ~MOJO_HANDLE_SIGNAL_NONE};
218 ASSERT_EQ(
219 MOJO_RESULT_INVALID_ARGUMENT,
220 core()->WaitMany(handles, signals, 0, MOJO_DEADLINE_INDEFINITE,
221 nullptr, nullptr));
222 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
223 core()->WaitMany(nullptr, signals, 0, MOJO_DEADLINE_INDEFINITE,
224 nullptr, nullptr));
225 // If |num_handles| is invalid, it should leave |result_index| and
226 // |signals_states| alone.
227 // (We use -1 internally; make sure that doesn't leak.)
228 uint32_t result_index = 123;
229 MojoHandleSignalsState hss = kFullMojoHandleSignalsState;
230 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
231 core()->WaitMany(nullptr, signals, 0, MOJO_DEADLINE_INDEFINITE,
232 &result_index, &hss));
233 ASSERT_EQ(123u, result_index);
234 ASSERT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
235 hss.satisfied_signals);
236 ASSERT_EQ(kFullMojoHandleSignalsState.satisfiable_signals,
237 hss.satisfiable_signals);
238
239 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
240 core()->WaitMany(handles, nullptr, 0, MOJO_DEADLINE_INDEFINITE,
241 nullptr, nullptr));
242 ASSERT_EQ(
243 MOJO_RESULT_INVALID_ARGUMENT,
244 core()->WaitMany(handles, signals, 1, MOJO_DEADLINE_INDEFINITE, nullptr,
245 nullptr));
246 // But if a handle is bad, then it should set |result_index| but still leave
247 // |signals_states| alone.
248 result_index = static_cast<uint32_t>(-1);
249 hss = kFullMojoHandleSignalsState;
250 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
251 core()->WaitMany(
252 handles, signals, 1, MOJO_DEADLINE_INDEFINITE, &result_index,
253 &hss));
254 ASSERT_EQ(0u, result_index);
255 ASSERT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
256 hss.satisfied_signals);
257 ASSERT_EQ(kFullMojoHandleSignalsState.satisfiable_signals,
258 hss.satisfiable_signals);
259
260 MockHandleInfo info[2];
261 handles[0] = CreateMockHandle(&info[0]);
262
263 result_index = static_cast<uint32_t>(-1);
264 hss = kFullMojoHandleSignalsState;
265 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
266 core()->WaitMany(
267 handles, signals, 1, MOJO_DEADLINE_INDEFINITE, &result_index,
268 &hss));
269 ASSERT_EQ(0u, result_index);
270 ASSERT_EQ(0u, hss.satisfied_signals);
271 ASSERT_EQ(0u, hss.satisfiable_signals);
272
273 // On invalid argument, it'll leave |signals_states| alone.
274 result_index = static_cast<uint32_t>(-1);
275 hss = kFullMojoHandleSignalsState;
276 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
277 core()->WaitMany(
278 handles, signals, 2, MOJO_DEADLINE_INDEFINITE, &result_index,
279 &hss));
280 ASSERT_EQ(1u, result_index);
281 ASSERT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
282 hss.satisfied_signals);
283 ASSERT_EQ(kFullMojoHandleSignalsState.satisfiable_signals,
284 hss.satisfiable_signals);
285 handles[1] = handles[0] + 1; // Invalid handle.
286 ASSERT_EQ(
287 MOJO_RESULT_INVALID_ARGUMENT,
288 core()->WaitMany(handles, signals, 2, MOJO_DEADLINE_INDEFINITE, nullptr,
289 nullptr));
290 handles[1] = CreateMockHandle(&info[1]);
291 ASSERT_EQ(
292 MOJO_RESULT_FAILED_PRECONDITION,
293 core()->WaitMany(handles, signals, 2, MOJO_DEADLINE_INDEFINITE, nullptr,
294 nullptr));
295
296 // TODO(vtl): Test one where we get "failed precondition" only for the
297 // second handle (and the first one is valid to wait on).
298
299 ASSERT_EQ(MOJO_RESULT_OK, core()->Close(handles[0]));
300 ASSERT_EQ(MOJO_RESULT_OK, core()->Close(handles[1]));
301 }
302
303 // |CreateMessagePipe()|: Nothing to check (apart from things that cause 123 // |CreateMessagePipe()|: Nothing to check (apart from things that cause
304 // death). 124 // death).
305 125
306 // |WriteMessage()|: 126 // |WriteMessage()|:
307 // Only check arguments checked by |Core|, namely |handle|, |handles|, and 127 // Only check arguments checked by |Core|, namely |handle|, |handles|, and
308 // |num_handles|. 128 // |num_handles|.
309 { 129 {
310 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, 130 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
311 core()->WriteMessage(MOJO_HANDLE_INVALID, nullptr, 0, 131 core()->WriteMessage(MOJO_HANDLE_INVALID, nullptr, 0,
312 nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); 132 nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
(...skipping 131 matching lines...) Expand 10 before | Expand all | Expand 10 after
444 // performance reasons). Probably blatant errors like passing in null pointers 264 // performance reasons). Probably blatant errors like passing in null pointers
445 // (for required pointer arguments) will still cause death, but perhaps not 265 // (for required pointer arguments) will still cause death, but perhaps not
446 // predictably. 266 // predictably.
447 TEST_F(CoreTest, InvalidArgumentsDeath) { 267 TEST_F(CoreTest, InvalidArgumentsDeath) {
448 #if defined(OFFICIAL_BUILD) 268 #if defined(OFFICIAL_BUILD)
449 const char kMemoryCheckFailedRegex[] = ""; 269 const char kMemoryCheckFailedRegex[] = "";
450 #else 270 #else
451 const char kMemoryCheckFailedRegex[] = "Check failed"; 271 const char kMemoryCheckFailedRegex[] = "Check failed";
452 #endif 272 #endif
453 273
454 // |WaitMany()|:
455 {
456 MojoHandle handle = MOJO_HANDLE_INVALID;
457 MojoHandleSignals signals = ~MOJO_HANDLE_SIGNAL_NONE;
458 ASSERT_DEATH_IF_SUPPORTED(
459 core()->WaitMany(nullptr, &signals, 1, MOJO_DEADLINE_INDEFINITE,
460 nullptr, nullptr),
461 kMemoryCheckFailedRegex);
462 ASSERT_DEATH_IF_SUPPORTED(
463 core()->WaitMany(&handle, nullptr, 1, MOJO_DEADLINE_INDEFINITE, nullptr,
464 nullptr),
465 kMemoryCheckFailedRegex);
466 // TODO(vtl): |result_index| and |signals_states| are optional. Test them
467 // with non-null invalid pointers?
468 }
469
470 // |CreateMessagePipe()|: 274 // |CreateMessagePipe()|:
471 { 275 {
472 MojoHandle h; 276 MojoHandle h;
473 ASSERT_DEATH_IF_SUPPORTED( 277 ASSERT_DEATH_IF_SUPPORTED(
474 core()->CreateMessagePipe(nullptr, nullptr, nullptr), 278 core()->CreateMessagePipe(nullptr, nullptr, nullptr),
475 kMemoryCheckFailedRegex); 279 kMemoryCheckFailedRegex);
476 ASSERT_DEATH_IF_SUPPORTED( 280 ASSERT_DEATH_IF_SUPPORTED(
477 core()->CreateMessagePipe(nullptr, &h, nullptr), 281 core()->CreateMessagePipe(nullptr, &h, nullptr),
478 kMemoryCheckFailedRegex); 282 kMemoryCheckFailedRegex);
479 ASSERT_DEATH_IF_SUPPORTED( 283 ASSERT_DEATH_IF_SUPPORTED(
(...skipping 11 matching lines...) Expand all
491 uint32_t handle_count = 1; 295 uint32_t handle_count = 1;
492 ASSERT_DEATH_IF_SUPPORTED( 296 ASSERT_DEATH_IF_SUPPORTED(
493 core()->ReadMessage(h, nullptr, nullptr, nullptr, &handle_count, 297 core()->ReadMessage(h, nullptr, nullptr, nullptr, &handle_count,
494 MOJO_READ_MESSAGE_FLAG_NONE), 298 MOJO_READ_MESSAGE_FLAG_NONE),
495 kMemoryCheckFailedRegex); 299 kMemoryCheckFailedRegex);
496 300
497 ASSERT_EQ(MOJO_RESULT_OK, core()->Close(h)); 301 ASSERT_EQ(MOJO_RESULT_OK, core()->Close(h));
498 } 302 }
499 } 303 }
500 304
501 // TODO(vtl): test |Wait()| and |WaitMany()| properly
502 // - including |WaitMany()| with the same handle more than once (with
503 // same/different signals)
504
505 TEST_F(CoreTest, MessagePipe) { 305 TEST_F(CoreTest, MessagePipe) {
506 MojoHandle h[2]; 306 MojoHandle h[2];
507 MojoHandleSignalsState hss[2]; 307 MojoHandleSignalsState hss[2];
508 uint32_t result_index;
509 308
510 ASSERT_EQ(MOJO_RESULT_OK, core()->CreateMessagePipe(nullptr, &h[0], &h[1])); 309 ASSERT_EQ(MOJO_RESULT_OK, core()->CreateMessagePipe(nullptr, &h[0], &h[1]));
511 // Should get two distinct, valid handles. 310 // Should get two distinct, valid handles.
512 ASSERT_NE(h[0], MOJO_HANDLE_INVALID); 311 ASSERT_NE(h[0], MOJO_HANDLE_INVALID);
513 ASSERT_NE(h[1], MOJO_HANDLE_INVALID); 312 ASSERT_NE(h[1], MOJO_HANDLE_INVALID);
514 ASSERT_NE(h[0], h[1]); 313 ASSERT_NE(h[0], h[1]);
515 314
516 // Neither should be readable. 315 // Neither should be readable.
517 MojoHandleSignals signals[2] = {MOJO_HANDLE_SIGNAL_READABLE,
518 MOJO_HANDLE_SIGNAL_READABLE};
519 result_index = static_cast<uint32_t>(-1);
520 hss[0] = kEmptyMojoHandleSignalsState; 316 hss[0] = kEmptyMojoHandleSignalsState;
521 hss[1] = kEmptyMojoHandleSignalsState; 317 hss[1] = kEmptyMojoHandleSignalsState;
522 ASSERT_EQ( 318 EXPECT_EQ(MOJO_RESULT_OK, core()->QueryHandleSignalsState(h[0], &hss[0]));
523 MOJO_RESULT_DEADLINE_EXCEEDED, 319 EXPECT_EQ(MOJO_RESULT_OK, core()->QueryHandleSignalsState(h[1], &hss[1]));
524 core()->WaitMany(h, signals, 2, 0, &result_index, hss));
525 ASSERT_EQ(static_cast<uint32_t>(-1), result_index);
526 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals); 320 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
527 ASSERT_EQ(kAllSignals, hss[0].satisfiable_signals); 321 ASSERT_EQ(kAllSignals, hss[0].satisfiable_signals);
528 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[1].satisfied_signals); 322 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[1].satisfied_signals);
529 ASSERT_EQ(kAllSignals, hss[1].satisfiable_signals); 323 ASSERT_EQ(kAllSignals, hss[1].satisfiable_signals);
530 324
531 // Try to read anyway. 325 // Try to read anyway.
532 char buffer[1] = {'a'}; 326 char buffer[1] = {'a'};
533 uint32_t buffer_size = 1; 327 uint32_t buffer_size = 1;
534 ASSERT_EQ( 328 ASSERT_EQ(
535 MOJO_RESULT_SHOULD_WAIT, 329 MOJO_RESULT_SHOULD_WAIT,
536 core()->ReadMessage(h[0], buffer, &buffer_size, nullptr, nullptr, 330 core()->ReadMessage(h[0], buffer, &buffer_size, nullptr, nullptr,
537 MOJO_READ_MESSAGE_FLAG_NONE)); 331 MOJO_READ_MESSAGE_FLAG_NONE));
538 // Check that it left its inputs alone. 332 // Check that it left its inputs alone.
539 ASSERT_EQ('a', buffer[0]); 333 ASSERT_EQ('a', buffer[0]);
540 ASSERT_EQ(1u, buffer_size); 334 ASSERT_EQ(1u, buffer_size);
541 335
542 // Both should be writable.
543 hss[0] = kEmptyMojoHandleSignalsState;
544 ASSERT_EQ(MOJO_RESULT_OK, core()->Wait(h[0], MOJO_HANDLE_SIGNAL_WRITABLE,
545 1000000000, &hss[0]));
546 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
547 ASSERT_EQ(kAllSignals, hss[0].satisfiable_signals);
548 hss[0] = kEmptyMojoHandleSignalsState;
549 ASSERT_EQ(MOJO_RESULT_OK, core()->Wait(h[1], MOJO_HANDLE_SIGNAL_WRITABLE,
550 1000000000, &hss[0]));
551 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
552 ASSERT_EQ(kAllSignals, hss[0].satisfiable_signals);
553
554 // Also check that |h[1]| is writable using |WaitMany()|.
555 signals[0] = MOJO_HANDLE_SIGNAL_READABLE;
556 signals[1] = MOJO_HANDLE_SIGNAL_WRITABLE;
557 result_index = static_cast<uint32_t>(-1);
558 hss[0] = kEmptyMojoHandleSignalsState;
559 hss[1] = kEmptyMojoHandleSignalsState;
560 ASSERT_EQ(
561 MOJO_RESULT_OK,
562 core()->WaitMany(h, signals, 2, MOJO_DEADLINE_INDEFINITE, &result_index,
563 hss));
564 ASSERT_EQ(1u, result_index);
565 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
566 ASSERT_EQ(kAllSignals, hss[0].satisfiable_signals);
567 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[1].satisfied_signals);
568 ASSERT_EQ(kAllSignals, hss[1].satisfiable_signals);
569
570 // Write to |h[1]|. 336 // Write to |h[1]|.
571 buffer[0] = 'b'; 337 buffer[0] = 'b';
572 ASSERT_EQ( 338 ASSERT_EQ(
573 MOJO_RESULT_OK, 339 MOJO_RESULT_OK,
574 core()->WriteMessage(h[1], buffer, 1, nullptr, 0, 340 core()->WriteMessage(h[1], buffer, 1, nullptr, 0,
575 MOJO_WRITE_MESSAGE_FLAG_NONE)); 341 MOJO_WRITE_MESSAGE_FLAG_NONE));
576 342
577 // Check that |h[0]| is now readable. 343 // Wait for |h[0]| to become readable.
578 signals[0] = MOJO_HANDLE_SIGNAL_READABLE; 344 EXPECT_EQ(MOJO_RESULT_OK, mojo::Wait(mojo::Handle(h[0]),
579 signals[1] = MOJO_HANDLE_SIGNAL_READABLE; 345 MOJO_HANDLE_SIGNAL_READABLE, &hss[0]));
580 result_index = static_cast<uint32_t>(-1);
581 hss[0] = kEmptyMojoHandleSignalsState;
582 hss[1] = kEmptyMojoHandleSignalsState;
583 ASSERT_EQ(
584 MOJO_RESULT_OK,
585 core()->WaitMany(h, signals, 2, MOJO_DEADLINE_INDEFINITE, &result_index,
586 hss));
587 ASSERT_EQ(0u, result_index);
588 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
589 hss[0].satisfied_signals);
590 ASSERT_EQ(kAllSignals, hss[0].satisfiable_signals);
591 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[1].satisfied_signals);
592 ASSERT_EQ(kAllSignals, hss[1].satisfiable_signals);
593 346
594 // Read from |h[0]|. 347 // Read from |h[0]|.
595 // First, get only the size. 348 // First, get only the size.
596 buffer_size = 0; 349 buffer_size = 0;
597 ASSERT_EQ( 350 ASSERT_EQ(
598 MOJO_RESULT_RESOURCE_EXHAUSTED, 351 MOJO_RESULT_RESOURCE_EXHAUSTED,
599 core()->ReadMessage(h[0], nullptr, &buffer_size, nullptr, nullptr, 352 core()->ReadMessage(h[0], nullptr, &buffer_size, nullptr, nullptr,
600 MOJO_READ_MESSAGE_FLAG_NONE)); 353 MOJO_READ_MESSAGE_FLAG_NONE));
601 ASSERT_EQ(1u, buffer_size); 354 ASSERT_EQ(1u, buffer_size);
602 // Then actually read it. 355 // Then actually read it.
603 buffer[0] = 'c'; 356 buffer[0] = 'c';
604 buffer_size = 1; 357 buffer_size = 1;
605 ASSERT_EQ( 358 ASSERT_EQ(
606 MOJO_RESULT_OK, 359 MOJO_RESULT_OK,
607 core()->ReadMessage(h[0], buffer, &buffer_size, nullptr, nullptr, 360 core()->ReadMessage(h[0], buffer, &buffer_size, nullptr, nullptr,
608 MOJO_READ_MESSAGE_FLAG_NONE)); 361 MOJO_READ_MESSAGE_FLAG_NONE));
609 ASSERT_EQ('b', buffer[0]); 362 ASSERT_EQ('b', buffer[0]);
610 ASSERT_EQ(1u, buffer_size); 363 ASSERT_EQ(1u, buffer_size);
611 364
612 // |h[0]| should no longer be readable. 365 // |h[0]| should no longer be readable.
613 hss[0] = kEmptyMojoHandleSignalsState; 366 hss[0] = kEmptyMojoHandleSignalsState;
614 ASSERT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, 367 EXPECT_EQ(MOJO_RESULT_OK, core()->QueryHandleSignalsState(h[0], &hss[0]));
615 core()->Wait(h[0], MOJO_HANDLE_SIGNAL_READABLE, 0, &hss[0]));
616 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals); 368 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
617 ASSERT_EQ(kAllSignals, hss[0].satisfiable_signals); 369 ASSERT_EQ(kAllSignals, hss[0].satisfiable_signals);
618 370
619 // Write to |h[0]|. 371 // Write to |h[0]|.
620 buffer[0] = 'd'; 372 buffer[0] = 'd';
621 ASSERT_EQ( 373 ASSERT_EQ(
622 MOJO_RESULT_OK, 374 MOJO_RESULT_OK,
623 core()->WriteMessage(h[0], buffer, 1, nullptr, 0, 375 core()->WriteMessage(h[0], buffer, 1, nullptr, 0,
624 MOJO_WRITE_MESSAGE_FLAG_NONE)); 376 MOJO_WRITE_MESSAGE_FLAG_NONE));
625 377
626 // Close |h[0]|. 378 // Close |h[0]|.
627 ASSERT_EQ(MOJO_RESULT_OK, core()->Close(h[0])); 379 ASSERT_EQ(MOJO_RESULT_OK, core()->Close(h[0]));
628 380
629 // Wait for |h[1]| to learn about the other end's closure. 381 // Wait for |h[1]| to learn about the other end's closure.
630 ASSERT_EQ(MOJO_RESULT_OK, 382 EXPECT_EQ(
631 core()->Wait(h[1], MOJO_HANDLE_SIGNAL_PEER_CLOSED, 1000000000, 383 MOJO_RESULT_OK,
632 &hss[0])); 384 mojo::Wait(mojo::Handle(h[1]), MOJO_HANDLE_SIGNAL_PEER_CLOSED, &hss[1]));
633 385
634 // Check that |h[1]| is no longer writable (and will never be). 386 // Check that |h[1]| is no longer writable (and will never be).
635 hss[0] = kEmptyMojoHandleSignalsState; 387 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
636 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, 388 hss[1].satisfied_signals);
637 core()->Wait(h[1], MOJO_HANDLE_SIGNAL_WRITABLE, 1000000000, 389 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
638 &hss[0])); 390 hss[1].satisfiable_signals);
639 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
640 hss[0].satisfied_signals);
641 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
642 hss[0].satisfiable_signals);
643 391
644 // Check that |h[1]| is still readable (for the moment). 392 // Check that |h[1]| is still readable (for the moment).
645 hss[0] = kEmptyMojoHandleSignalsState; 393 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
646 ASSERT_EQ(MOJO_RESULT_OK, core()->Wait(h[1], MOJO_HANDLE_SIGNAL_READABLE, 394 hss[1].satisfied_signals);
647 1000000000, &hss[0])); 395 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
648 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, 396 hss[1].satisfiable_signals);
649 hss[0].satisfied_signals);
650 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
651 hss[0].satisfiable_signals);
652 397
653 // Discard a message from |h[1]|. 398 // Discard a message from |h[1]|.
654 ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, 399 ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
655 core()->ReadMessage(h[1], nullptr, nullptr, nullptr, nullptr, 400 core()->ReadMessage(h[1], nullptr, nullptr, nullptr, nullptr,
656 MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); 401 MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
657 402
658 // |h[1]| is no longer readable (and will never be). 403 // |h[1]| is no longer readable (and will never be).
659 hss[0] = kFullMojoHandleSignalsState; 404 hss[1] = kFullMojoHandleSignalsState;
660 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, 405 EXPECT_EQ(MOJO_RESULT_OK, core()->QueryHandleSignalsState(h[1], &hss[1]));
661 core()->Wait(h[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, 406 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss[1].satisfied_signals);
662 &hss[0])); 407 EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss[1].satisfiable_signals);
663 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss[0].satisfied_signals);
664 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss[0].satisfiable_signals);
665 408
666 // Try writing to |h[1]|. 409 // Try writing to |h[1]|.
667 buffer[0] = 'e'; 410 buffer[0] = 'e';
668 ASSERT_EQ( 411 ASSERT_EQ(
669 MOJO_RESULT_FAILED_PRECONDITION, 412 MOJO_RESULT_FAILED_PRECONDITION,
670 core()->WriteMessage(h[1], buffer, 1, nullptr, 0, 413 core()->WriteMessage(h[1], buffer, 1, nullptr, 0,
671 MOJO_WRITE_MESSAGE_FLAG_NONE)); 414 MOJO_WRITE_MESSAGE_FLAG_NONE));
672 415
673 ASSERT_EQ(MOJO_RESULT_OK, core()->Close(h[1])); 416 ASSERT_EQ(MOJO_RESULT_OK, core()->Close(h[1]));
674 } 417 }
(...skipping 14 matching lines...) Expand all
689 432
690 MojoHandle h_passing[2]; 433 MojoHandle h_passing[2];
691 ASSERT_EQ(MOJO_RESULT_OK, 434 ASSERT_EQ(MOJO_RESULT_OK,
692 core()->CreateMessagePipe(nullptr, &h_passing[0], &h_passing[1])); 435 core()->CreateMessagePipe(nullptr, &h_passing[0], &h_passing[1]));
693 436
694 // Make sure that |h_passing[]| work properly. 437 // Make sure that |h_passing[]| work properly.
695 ASSERT_EQ(MOJO_RESULT_OK, 438 ASSERT_EQ(MOJO_RESULT_OK,
696 core()->WriteMessage(h_passing[0], kHello, kHelloSize, nullptr, 0, 439 core()->WriteMessage(h_passing[0], kHello, kHelloSize, nullptr, 0,
697 MOJO_WRITE_MESSAGE_FLAG_NONE)); 440 MOJO_WRITE_MESSAGE_FLAG_NONE));
698 hss = kEmptyMojoHandleSignalsState; 441 hss = kEmptyMojoHandleSignalsState;
699 ASSERT_EQ(MOJO_RESULT_OK, 442 EXPECT_EQ(MOJO_RESULT_OK, mojo::Wait(mojo::Handle(h_passing[1]),
700 core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, 443 MOJO_HANDLE_SIGNAL_READABLE, &hss));
701 &hss));
702 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, 444 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
703 hss.satisfied_signals); 445 hss.satisfied_signals);
704 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); 446 ASSERT_EQ(kAllSignals, hss.satisfiable_signals);
705 num_bytes = kBufferSize; 447 num_bytes = kBufferSize;
706 num_handles = arraysize(handles); 448 num_handles = arraysize(handles);
707 ASSERT_EQ(MOJO_RESULT_OK, 449 ASSERT_EQ(MOJO_RESULT_OK,
708 core()->ReadMessage( 450 core()->ReadMessage(
709 h_passing[1], buffer, &num_bytes, handles, &num_handles, 451 h_passing[1], buffer, &num_bytes, handles, &num_handles,
710 MOJO_READ_MESSAGE_FLAG_NONE)); 452 MOJO_READ_MESSAGE_FLAG_NONE));
711 ASSERT_EQ(kHelloSize, num_bytes); 453 ASSERT_EQ(kHelloSize, num_bytes);
(...skipping 18 matching lines...) Expand all
730 472
731 MojoHandle h_passed[2]; 473 MojoHandle h_passed[2];
732 ASSERT_EQ(MOJO_RESULT_OK, 474 ASSERT_EQ(MOJO_RESULT_OK,
733 core()->CreateMessagePipe(nullptr, &h_passed[0], &h_passed[1])); 475 core()->CreateMessagePipe(nullptr, &h_passed[0], &h_passed[1]));
734 476
735 // Make sure that |h_passed[]| work properly. 477 // Make sure that |h_passed[]| work properly.
736 ASSERT_EQ(MOJO_RESULT_OK, 478 ASSERT_EQ(MOJO_RESULT_OK,
737 core()->WriteMessage(h_passed[0], kHello, kHelloSize, nullptr, 0, 479 core()->WriteMessage(h_passed[0], kHello, kHelloSize, nullptr, 0,
738 MOJO_WRITE_MESSAGE_FLAG_NONE)); 480 MOJO_WRITE_MESSAGE_FLAG_NONE));
739 hss = kEmptyMojoHandleSignalsState; 481 hss = kEmptyMojoHandleSignalsState;
740 ASSERT_EQ(MOJO_RESULT_OK, 482 ASSERT_EQ(MOJO_RESULT_OK, mojo::Wait(mojo::Handle(h_passed[1]),
741 core()->Wait(h_passed[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, 483 MOJO_HANDLE_SIGNAL_READABLE, &hss));
742 &hss));
743 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, 484 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
744 hss.satisfied_signals); 485 hss.satisfied_signals);
745 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); 486 ASSERT_EQ(kAllSignals, hss.satisfiable_signals);
746 num_bytes = kBufferSize; 487 num_bytes = kBufferSize;
747 num_handles = arraysize(handles); 488 num_handles = arraysize(handles);
748 ASSERT_EQ(MOJO_RESULT_OK, 489 ASSERT_EQ(MOJO_RESULT_OK,
749 core()->ReadMessage( 490 core()->ReadMessage(
750 h_passed[1], buffer, &num_bytes, handles, &num_handles, 491 h_passed[1], buffer, &num_bytes, handles, &num_handles,
751 MOJO_READ_MESSAGE_FLAG_NONE)); 492 MOJO_READ_MESSAGE_FLAG_NONE));
752 ASSERT_EQ(kHelloSize, num_bytes); 493 ASSERT_EQ(kHelloSize, num_bytes);
753 ASSERT_STREQ(kHello, buffer); 494 ASSERT_STREQ(kHello, buffer);
754 ASSERT_EQ(0u, num_handles); 495 ASSERT_EQ(0u, num_handles);
755 496
756 // Send |h_passed[1]| from |h_passing[0]| to |h_passing[1]|. 497 // Send |h_passed[1]| from |h_passing[0]| to |h_passing[1]|.
757 ASSERT_EQ(MOJO_RESULT_OK, 498 ASSERT_EQ(MOJO_RESULT_OK,
758 core()->WriteMessage(h_passing[0], kWorld, kWorldSize, 499 core()->WriteMessage(h_passing[0], kWorld, kWorldSize,
759 &h_passed[1], 1, 500 &h_passed[1], 1,
760 MOJO_WRITE_MESSAGE_FLAG_NONE)); 501 MOJO_WRITE_MESSAGE_FLAG_NONE));
761 hss = kEmptyMojoHandleSignalsState; 502 hss = kEmptyMojoHandleSignalsState;
762 ASSERT_EQ(MOJO_RESULT_OK, 503 ASSERT_EQ(MOJO_RESULT_OK, mojo::Wait(mojo::Handle(h_passing[1]),
763 core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, 504 MOJO_HANDLE_SIGNAL_READABLE, &hss));
764 &hss));
765 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, 505 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
766 hss.satisfied_signals); 506 hss.satisfied_signals);
767 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); 507 ASSERT_EQ(kAllSignals, hss.satisfiable_signals);
768 num_bytes = kBufferSize; 508 num_bytes = kBufferSize;
769 num_handles = arraysize(handles); 509 num_handles = arraysize(handles);
770 ASSERT_EQ(MOJO_RESULT_OK, 510 ASSERT_EQ(MOJO_RESULT_OK,
771 core()->ReadMessage( 511 core()->ReadMessage(
772 h_passing[1], buffer, &num_bytes, handles, &num_handles, 512 h_passing[1], buffer, &num_bytes, handles, &num_handles,
773 MOJO_READ_MESSAGE_FLAG_NONE)); 513 MOJO_READ_MESSAGE_FLAG_NONE));
774 ASSERT_EQ(kWorldSize, num_bytes); 514 ASSERT_EQ(kWorldSize, num_bytes);
(...skipping 10 matching lines...) Expand all
785 525
786 // |h_passed[1]| should no longer be valid; check that trying to close it 526 // |h_passed[1]| should no longer be valid; check that trying to close it
787 // fails. See above note. 527 // fails. See above note.
788 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(h_passed[1])); 528 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(h_passed[1]));
789 529
790 // Write to |h_passed[0]|. Should receive on |h_received|. 530 // Write to |h_passed[0]|. Should receive on |h_received|.
791 ASSERT_EQ(MOJO_RESULT_OK, 531 ASSERT_EQ(MOJO_RESULT_OK,
792 core()->WriteMessage(h_passed[0], kHello, kHelloSize, nullptr, 0, 532 core()->WriteMessage(h_passed[0], kHello, kHelloSize, nullptr, 0,
793 MOJO_WRITE_MESSAGE_FLAG_NONE)); 533 MOJO_WRITE_MESSAGE_FLAG_NONE));
794 hss = kEmptyMojoHandleSignalsState; 534 hss = kEmptyMojoHandleSignalsState;
795 ASSERT_EQ(MOJO_RESULT_OK, 535 ASSERT_EQ(MOJO_RESULT_OK, mojo::Wait(mojo::Handle(h_received),
796 core()->Wait(h_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, 536 MOJO_HANDLE_SIGNAL_READABLE, &hss));
797 &hss));
798 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, 537 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
799 hss.satisfied_signals); 538 hss.satisfied_signals);
800 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); 539 ASSERT_EQ(kAllSignals, hss.satisfiable_signals);
801 num_bytes = kBufferSize; 540 num_bytes = kBufferSize;
802 num_handles = arraysize(handles); 541 num_handles = arraysize(handles);
803 ASSERT_EQ(MOJO_RESULT_OK, 542 ASSERT_EQ(MOJO_RESULT_OK,
804 core()->ReadMessage( 543 core()->ReadMessage(
805 h_received, buffer, &num_bytes, handles, &num_handles, 544 h_received, buffer, &num_bytes, handles, &num_handles,
806 MOJO_READ_MESSAGE_FLAG_NONE)); 545 MOJO_READ_MESSAGE_FLAG_NONE));
807 ASSERT_EQ(kHelloSize, num_bytes); 546 ASSERT_EQ(kHelloSize, num_bytes);
(...skipping 12 matching lines...) Expand all
820 559
821 ASSERT_EQ(MOJO_RESULT_OK, 560 ASSERT_EQ(MOJO_RESULT_OK,
822 core()->CreateDataPipe(nullptr, &ph, &ch)); 561 core()->CreateDataPipe(nullptr, &ph, &ch));
823 // Should get two distinct, valid handles. 562 // Should get two distinct, valid handles.
824 ASSERT_NE(ph, MOJO_HANDLE_INVALID); 563 ASSERT_NE(ph, MOJO_HANDLE_INVALID);
825 ASSERT_NE(ch, MOJO_HANDLE_INVALID); 564 ASSERT_NE(ch, MOJO_HANDLE_INVALID);
826 ASSERT_NE(ph, ch); 565 ASSERT_NE(ph, ch);
827 566
828 // Producer should be never-readable, but already writable. 567 // Producer should be never-readable, but already writable.
829 hss = kEmptyMojoHandleSignalsState; 568 hss = kEmptyMojoHandleSignalsState;
830 ASSERT_EQ( 569 EXPECT_EQ(MOJO_RESULT_OK, core()->QueryHandleSignalsState(ph, &hss));
831 MOJO_RESULT_FAILED_PRECONDITION,
832 core()->Wait(ph, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss));
833 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
834 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
835 hss.satisfiable_signals);
836 hss = kEmptyMojoHandleSignalsState;
837 ASSERT_EQ(MOJO_RESULT_OK, core()->Wait(ph, MOJO_HANDLE_SIGNAL_WRITABLE, 0,
838 &hss));
839 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); 570 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
840 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, 571 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
841 hss.satisfiable_signals); 572 hss.satisfiable_signals);
842 573
843 // Consumer should be never-writable, and not yet readable. 574 // Consumer should be never-writable, and not yet readable.
844 hss = kFullMojoHandleSignalsState; 575 hss = kFullMojoHandleSignalsState;
845 ASSERT_EQ( 576 EXPECT_EQ(MOJO_RESULT_OK, core()->QueryHandleSignalsState(ch, &hss));
846 MOJO_RESULT_FAILED_PRECONDITION, 577 EXPECT_EQ(0u, hss.satisfied_signals);
847 core()->Wait(ch, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss));
848 ASSERT_EQ(0u, hss.satisfied_signals);
849 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | 578 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
850 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, 579 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
851 hss.satisfiable_signals); 580 hss.satisfiable_signals);
852 hss = kFullMojoHandleSignalsState;
853 ASSERT_EQ(
854 MOJO_RESULT_DEADLINE_EXCEEDED,
855 core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss));
856 ASSERT_EQ(0u, hss.satisfied_signals);
857 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
858 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
859 hss.satisfiable_signals);
860 581
861 // Write. 582 // Write.
862 signed char elements[2] = {'A', 'B'}; 583 signed char elements[2] = {'A', 'B'};
863 uint32_t num_bytes = 2u; 584 uint32_t num_bytes = 2u;
864 ASSERT_EQ(MOJO_RESULT_OK, 585 ASSERT_EQ(MOJO_RESULT_OK,
865 core()->WriteData(ph, elements, &num_bytes, 586 core()->WriteData(ph, elements, &num_bytes,
866 MOJO_WRITE_DATA_FLAG_NONE)); 587 MOJO_WRITE_DATA_FLAG_NONE));
867 ASSERT_EQ(2u, num_bytes); 588 ASSERT_EQ(2u, num_bytes);
868 589
869 // Wait for the data to arrive to the consumer. 590 // Wait for the data to arrive to the consumer.
870 ASSERT_EQ(MOJO_RESULT_OK, 591 EXPECT_EQ(MOJO_RESULT_OK,
871 core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, &hss)); 592 mojo::Wait(mojo::Handle(ch), MOJO_HANDLE_SIGNAL_READABLE, &hss));
872 593
873 // Consumer should now be readable. 594 // Consumer should now be readable.
874 hss = kEmptyMojoHandleSignalsState; 595 hss = kEmptyMojoHandleSignalsState;
875 ASSERT_EQ(MOJO_RESULT_OK, core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, 596 EXPECT_EQ(MOJO_RESULT_OK, core()->QueryHandleSignalsState(ch, &hss));
876 &hss));
877 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, 597 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
878 hss.satisfied_signals); 598 hss.satisfied_signals);
879 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | 599 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
880 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, 600 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
881 hss.satisfiable_signals); 601 hss.satisfiable_signals);
882 602
883 // Peek one character. 603 // Peek one character.
884 elements[0] = -1; 604 elements[0] = -1;
885 elements[1] = -1; 605 elements[1] = -1;
886 num_bytes = 1u; 606 num_bytes = 1u;
(...skipping 30 matching lines...) Expand all
917 MOJO_WRITE_DATA_FLAG_NONE)); 637 MOJO_WRITE_DATA_FLAG_NONE));
918 638
919 // Actually write the data, and complete it now. 639 // Actually write the data, and complete it now.
920 static_cast<char*>(write_ptr)[0] = 'C'; 640 static_cast<char*>(write_ptr)[0] = 'C';
921 static_cast<char*>(write_ptr)[1] = 'D'; 641 static_cast<char*>(write_ptr)[1] = 'D';
922 static_cast<char*>(write_ptr)[2] = 'E'; 642 static_cast<char*>(write_ptr)[2] = 'E';
923 ASSERT_EQ(MOJO_RESULT_OK, core()->EndWriteData(ph, 3u)); 643 ASSERT_EQ(MOJO_RESULT_OK, core()->EndWriteData(ph, 3u));
924 644
925 // Wait for the data to arrive to the consumer. 645 // Wait for the data to arrive to the consumer.
926 ASSERT_EQ(MOJO_RESULT_OK, 646 ASSERT_EQ(MOJO_RESULT_OK,
927 core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, &hss)); 647 mojo::Wait(mojo::Handle(ch), MOJO_HANDLE_SIGNAL_READABLE, &hss));
928 648
929 // Query how much data we have. 649 // Query how much data we have.
930 num_bytes = 0; 650 num_bytes = 0;
931 ASSERT_EQ(MOJO_RESULT_OK, 651 ASSERT_EQ(MOJO_RESULT_OK,
932 core()->ReadData(ch, nullptr, &num_bytes, 652 core()->ReadData(ch, nullptr, &num_bytes,
933 MOJO_READ_DATA_FLAG_QUERY)); 653 MOJO_READ_DATA_FLAG_QUERY));
934 ASSERT_GE(num_bytes, 1u); 654 ASSERT_GE(num_bytes, 1u);
935 655
936 // Try to query with peek. Should fail. 656 // Try to query with peek. Should fail.
937 num_bytes = 0; 657 num_bytes = 0;
(...skipping 19 matching lines...) Expand all
957 677
958 // Discard a character. 678 // Discard a character.
959 num_bytes = 1; 679 num_bytes = 1;
960 ASSERT_EQ(MOJO_RESULT_OK, 680 ASSERT_EQ(MOJO_RESULT_OK,
961 core()->ReadData( 681 core()->ReadData(
962 ch, nullptr, &num_bytes, 682 ch, nullptr, &num_bytes,
963 MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_ALL_OR_NONE)); 683 MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_ALL_OR_NONE));
964 684
965 // Ensure the 3 bytes were read. 685 // Ensure the 3 bytes were read.
966 ASSERT_EQ(MOJO_RESULT_OK, 686 ASSERT_EQ(MOJO_RESULT_OK,
967 core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, &hss)); 687 mojo::Wait(mojo::Handle(ch), MOJO_HANDLE_SIGNAL_READABLE, &hss));
968 688
969 // Try a two-phase read of the remaining three bytes with peek. Should fail. 689 // Try a two-phase read of the remaining three bytes with peek. Should fail.
970 const void* read_ptr = nullptr; 690 const void* read_ptr = nullptr;
971 num_bytes = 3; 691 num_bytes = 3;
972 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, 692 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
973 core()->BeginReadData(ch, &read_ptr, &num_bytes, 693 core()->BeginReadData(ch, &read_ptr, &num_bytes,
974 MOJO_READ_DATA_FLAG_PEEK)); 694 MOJO_READ_DATA_FLAG_PEEK));
975 695
976 // Read the remaining two characters, in two-phase mode (all-or-none). 696 // Read the remaining two characters, in two-phase mode (all-or-none).
977 num_bytes = 3; 697 num_bytes = 3;
(...skipping 10 matching lines...) Expand all
988 MOJO_READ_DATA_FLAG_DISCARD)); 708 MOJO_READ_DATA_FLAG_DISCARD));
989 709
990 // Actually check our data and end the two-phase read. 710 // Actually check our data and end the two-phase read.
991 ASSERT_EQ('C', static_cast<const char*>(read_ptr)[0]); 711 ASSERT_EQ('C', static_cast<const char*>(read_ptr)[0]);
992 ASSERT_EQ('D', static_cast<const char*>(read_ptr)[1]); 712 ASSERT_EQ('D', static_cast<const char*>(read_ptr)[1]);
993 ASSERT_EQ('E', static_cast<const char*>(read_ptr)[2]); 713 ASSERT_EQ('E', static_cast<const char*>(read_ptr)[2]);
994 ASSERT_EQ(MOJO_RESULT_OK, core()->EndReadData(ch, 3u)); 714 ASSERT_EQ(MOJO_RESULT_OK, core()->EndReadData(ch, 3u));
995 715
996 // Consumer should now be no longer readable. 716 // Consumer should now be no longer readable.
997 hss = kFullMojoHandleSignalsState; 717 hss = kFullMojoHandleSignalsState;
998 ASSERT_EQ( 718 EXPECT_EQ(MOJO_RESULT_OK, core()->QueryHandleSignalsState(ch, &hss));
999 MOJO_RESULT_DEADLINE_EXCEEDED,
1000 core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss));
1001 EXPECT_EQ(0u, hss.satisfied_signals); 719 EXPECT_EQ(0u, hss.satisfied_signals);
1002 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | 720 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
1003 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, 721 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
1004 hss.satisfiable_signals); 722 hss.satisfiable_signals);
1005 723
1006 // TODO(vtl): More. 724 // TODO(vtl): More.
1007 725
1008 // Close the producer. 726 // Close the producer.
1009 ASSERT_EQ(MOJO_RESULT_OK, core()->Close(ph)); 727 ASSERT_EQ(MOJO_RESULT_OK, core()->Close(ph));
1010 728
1011 // Wait for this to get to the consumer. 729 // Wait for this to get to the consumer.
1012 ASSERT_EQ(MOJO_RESULT_OK, 730 EXPECT_EQ(MOJO_RESULT_OK,
1013 core()->Wait(ch, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 1000000000, &hss)); 731 mojo::Wait(mojo::Handle(ch), MOJO_HANDLE_SIGNAL_PEER_CLOSED, &hss));
1014 732
1015 // The consumer should now be never-readable. 733 // The consumer should now be never-readable.
1016 hss = kFullMojoHandleSignalsState; 734 hss = kFullMojoHandleSignalsState;
1017 ASSERT_EQ( 735 EXPECT_EQ(MOJO_RESULT_OK, core()->QueryHandleSignalsState(ch, &hss));
1018 MOJO_RESULT_FAILED_PRECONDITION,
1019 core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss));
1020 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); 736 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
1021 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); 737 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
1022 738
1023 ASSERT_EQ(MOJO_RESULT_OK, core()->Close(ch)); 739 ASSERT_EQ(MOJO_RESULT_OK, core()->Close(ch));
1024 } 740 }
1025 741
1026 // Tests passing data pipe producer and consumer handles. 742 // Tests passing data pipe producer and consumer handles.
1027 TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { 743 TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) {
1028 const char kHello[] = "hello"; 744 const char kHello[] = "hello";
1029 const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello)); 745 const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
(...skipping 12 matching lines...) Expand all
1042 758
1043 MojoHandle ph, ch; 759 MojoHandle ph, ch;
1044 ASSERT_EQ(MOJO_RESULT_OK, 760 ASSERT_EQ(MOJO_RESULT_OK,
1045 core()->CreateDataPipe(nullptr, &ph, &ch)); 761 core()->CreateDataPipe(nullptr, &ph, &ch));
1046 762
1047 // Send |ch| from |h_passing[0]| to |h_passing[1]|. 763 // Send |ch| from |h_passing[0]| to |h_passing[1]|.
1048 ASSERT_EQ(MOJO_RESULT_OK, 764 ASSERT_EQ(MOJO_RESULT_OK,
1049 core()->WriteMessage(h_passing[0], kHello, kHelloSize, &ch, 1, 765 core()->WriteMessage(h_passing[0], kHello, kHelloSize, &ch, 1,
1050 MOJO_WRITE_MESSAGE_FLAG_NONE)); 766 MOJO_WRITE_MESSAGE_FLAG_NONE));
1051 hss = kEmptyMojoHandleSignalsState; 767 hss = kEmptyMojoHandleSignalsState;
1052 ASSERT_EQ(MOJO_RESULT_OK, 768 ASSERT_EQ(MOJO_RESULT_OK, mojo::Wait(mojo::Handle(h_passing[1]),
1053 core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, 769 MOJO_HANDLE_SIGNAL_READABLE, &hss));
1054 &hss));
1055 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, 770 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
1056 hss.satisfied_signals); 771 hss.satisfied_signals);
1057 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); 772 ASSERT_EQ(kAllSignals, hss.satisfiable_signals);
1058 num_bytes = kBufferSize; 773 num_bytes = kBufferSize;
1059 num_handles = arraysize(handles); 774 num_handles = arraysize(handles);
1060 ASSERT_EQ(MOJO_RESULT_OK, 775 ASSERT_EQ(MOJO_RESULT_OK,
1061 core()->ReadMessage( 776 core()->ReadMessage(
1062 h_passing[1], buffer, &num_bytes, handles, &num_handles, 777 h_passing[1], buffer, &num_bytes, handles, &num_handles,
1063 MOJO_READ_MESSAGE_FLAG_NONE)); 778 MOJO_READ_MESSAGE_FLAG_NONE));
1064 ASSERT_EQ(kHelloSize, num_bytes); 779 ASSERT_EQ(kHelloSize, num_bytes);
(...skipping 11 matching lines...) Expand all
1076 // |ch| should no longer be valid; check that trying to close it fails. See 791 // |ch| should no longer be valid; check that trying to close it fails. See
1077 // above note. 792 // above note.
1078 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(ch)); 793 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(ch));
1079 794
1080 // Write to |ph|. Should receive on |ch_received|. 795 // Write to |ph|. Should receive on |ch_received|.
1081 num_bytes = kWorldSize; 796 num_bytes = kWorldSize;
1082 ASSERT_EQ(MOJO_RESULT_OK, 797 ASSERT_EQ(MOJO_RESULT_OK,
1083 core()->WriteData(ph, kWorld, &num_bytes, 798 core()->WriteData(ph, kWorld, &num_bytes,
1084 MOJO_WRITE_DATA_FLAG_ALL_OR_NONE)); 799 MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
1085 hss = kEmptyMojoHandleSignalsState; 800 hss = kEmptyMojoHandleSignalsState;
1086 ASSERT_EQ(MOJO_RESULT_OK, 801 EXPECT_EQ(MOJO_RESULT_OK, mojo::Wait(mojo::Handle(ch_received),
1087 core()->Wait(ch_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, 802 MOJO_HANDLE_SIGNAL_READABLE, &hss));
1088 &hss));
1089 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, 803 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
1090 hss.satisfied_signals); 804 hss.satisfied_signals);
1091 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | 805 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
1092 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, 806 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
1093 hss.satisfiable_signals); 807 hss.satisfiable_signals);
1094 num_bytes = kBufferSize; 808 num_bytes = kBufferSize;
1095 ASSERT_EQ(MOJO_RESULT_OK, 809 ASSERT_EQ(MOJO_RESULT_OK,
1096 core()->ReadData(ch_received, buffer, &num_bytes, 810 core()->ReadData(ch_received, buffer, &num_bytes,
1097 MOJO_READ_MESSAGE_FLAG_NONE)); 811 MOJO_READ_MESSAGE_FLAG_NONE));
1098 ASSERT_EQ(kWorldSize, num_bytes); 812 ASSERT_EQ(kWorldSize, num_bytes);
1099 ASSERT_STREQ(kWorld, buffer); 813 ASSERT_STREQ(kWorld, buffer);
1100 814
1101 // Now pass |ph| in the same direction. 815 // Now pass |ph| in the same direction.
1102 ASSERT_EQ(MOJO_RESULT_OK, 816 ASSERT_EQ(MOJO_RESULT_OK,
1103 core()->WriteMessage(h_passing[0], kWorld, kWorldSize, &ph, 1, 817 core()->WriteMessage(h_passing[0], kWorld, kWorldSize, &ph, 1,
1104 MOJO_WRITE_MESSAGE_FLAG_NONE)); 818 MOJO_WRITE_MESSAGE_FLAG_NONE));
1105 hss = kEmptyMojoHandleSignalsState; 819 hss = kEmptyMojoHandleSignalsState;
1106 ASSERT_EQ(MOJO_RESULT_OK, 820 ASSERT_EQ(MOJO_RESULT_OK, mojo::Wait(mojo::Handle(h_passing[1]),
1107 core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, 821 MOJO_HANDLE_SIGNAL_READABLE, &hss));
1108 &hss));
1109 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, 822 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
1110 hss.satisfied_signals); 823 hss.satisfied_signals);
1111 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); 824 ASSERT_EQ(kAllSignals, hss.satisfiable_signals);
1112 num_bytes = kBufferSize; 825 num_bytes = kBufferSize;
1113 num_handles = arraysize(handles); 826 num_handles = arraysize(handles);
1114 ASSERT_EQ(MOJO_RESULT_OK, 827 ASSERT_EQ(MOJO_RESULT_OK,
1115 core()->ReadMessage( 828 core()->ReadMessage(
1116 h_passing[1], buffer, &num_bytes, handles, &num_handles, 829 h_passing[1], buffer, &num_bytes, handles, &num_handles,
1117 MOJO_READ_MESSAGE_FLAG_NONE)); 830 MOJO_READ_MESSAGE_FLAG_NONE));
1118 ASSERT_EQ(kWorldSize, num_bytes); 831 ASSERT_EQ(kWorldSize, num_bytes);
(...skipping 11 matching lines...) Expand all
1130 // |ph| should no longer be valid; check that trying to close it fails. See 843 // |ph| should no longer be valid; check that trying to close it fails. See
1131 // above note. 844 // above note.
1132 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(ph)); 845 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->Close(ph));
1133 846
1134 // Write to |ph_received|. Should receive on |ch_received|. 847 // Write to |ph_received|. Should receive on |ch_received|.
1135 num_bytes = kHelloSize; 848 num_bytes = kHelloSize;
1136 ASSERT_EQ(MOJO_RESULT_OK, 849 ASSERT_EQ(MOJO_RESULT_OK,
1137 core()->WriteData(ph_received, kHello, &num_bytes, 850 core()->WriteData(ph_received, kHello, &num_bytes,
1138 MOJO_WRITE_DATA_FLAG_ALL_OR_NONE)); 851 MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
1139 hss = kEmptyMojoHandleSignalsState; 852 hss = kEmptyMojoHandleSignalsState;
1140 ASSERT_EQ(MOJO_RESULT_OK, 853 EXPECT_EQ(MOJO_RESULT_OK, mojo::Wait(mojo::Handle(ch_received),
1141 core()->Wait(ch_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, 854 MOJO_HANDLE_SIGNAL_READABLE, &hss));
1142 &hss));
1143 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, 855 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
1144 hss.satisfied_signals); 856 hss.satisfied_signals);
1145 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | 857 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
1146 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, 858 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
1147 hss.satisfiable_signals); 859 hss.satisfiable_signals);
1148 num_bytes = kBufferSize; 860 num_bytes = kBufferSize;
1149 ASSERT_EQ(MOJO_RESULT_OK, 861 ASSERT_EQ(MOJO_RESULT_OK,
1150 core()->ReadData(ch_received, buffer, &num_bytes, 862 core()->ReadData(ch_received, buffer, &num_bytes,
1151 MOJO_READ_MESSAGE_FLAG_NONE)); 863 MOJO_READ_MESSAGE_FLAG_NONE));
1152 ASSERT_EQ(kHelloSize, num_bytes); 864 ASSERT_EQ(kHelloSize, num_bytes);
(...skipping 13 matching lines...) Expand all
1166 ASSERT_GE(num_bytes, 1u); 878 ASSERT_GE(num_bytes, 1u);
1167 ASSERT_EQ(MOJO_RESULT_BUSY, 879 ASSERT_EQ(MOJO_RESULT_BUSY,
1168 core()->WriteMessage(h_passing[0], kHello, kHelloSize, &ph, 1, 880 core()->WriteMessage(h_passing[0], kHello, kHelloSize, &ph, 1,
1169 MOJO_WRITE_MESSAGE_FLAG_NONE)); 881 MOJO_WRITE_MESSAGE_FLAG_NONE));
1170 882
1171 // But |ch| can, even if |ph| is in a two-phase write. 883 // But |ch| can, even if |ph| is in a two-phase write.
1172 ASSERT_EQ(MOJO_RESULT_OK, 884 ASSERT_EQ(MOJO_RESULT_OK,
1173 core()->WriteMessage(h_passing[0], kHello, kHelloSize, &ch, 1, 885 core()->WriteMessage(h_passing[0], kHello, kHelloSize, &ch, 1,
1174 MOJO_WRITE_MESSAGE_FLAG_NONE)); 886 MOJO_WRITE_MESSAGE_FLAG_NONE));
1175 ch = MOJO_HANDLE_INVALID; 887 ch = MOJO_HANDLE_INVALID;
1176 ASSERT_EQ(MOJO_RESULT_OK, 888 EXPECT_EQ(MOJO_RESULT_OK, mojo::Wait(mojo::Handle(h_passing[1]),
1177 core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, 889 MOJO_HANDLE_SIGNAL_READABLE));
1178 nullptr));
1179 num_bytes = kBufferSize; 890 num_bytes = kBufferSize;
1180 num_handles = arraysize(handles); 891 num_handles = arraysize(handles);
1181 ASSERT_EQ(MOJO_RESULT_OK, 892 ASSERT_EQ(MOJO_RESULT_OK,
1182 core()->ReadMessage( 893 core()->ReadMessage(
1183 h_passing[1], buffer, &num_bytes, handles, &num_handles, 894 h_passing[1], buffer, &num_bytes, handles, &num_handles,
1184 MOJO_READ_MESSAGE_FLAG_NONE)); 895 MOJO_READ_MESSAGE_FLAG_NONE));
1185 ASSERT_EQ(kHelloSize, num_bytes); 896 ASSERT_EQ(kHelloSize, num_bytes);
1186 ASSERT_STREQ(kHello, buffer); 897 ASSERT_STREQ(kHello, buffer);
1187 ASSERT_EQ(1u, num_handles); 898 ASSERT_EQ(1u, num_handles);
1188 ch = handles[0]; 899 ch = handles[0];
1189 ASSERT_NE(ch, MOJO_HANDLE_INVALID); 900 ASSERT_NE(ch, MOJO_HANDLE_INVALID);
1190 901
1191 // Complete the two-phase write. 902 // Complete the two-phase write.
1192 static_cast<char*>(write_ptr)[0] = 'x'; 903 static_cast<char*>(write_ptr)[0] = 'x';
1193 ASSERT_EQ(MOJO_RESULT_OK, core()->EndWriteData(ph, 1)); 904 ASSERT_EQ(MOJO_RESULT_OK, core()->EndWriteData(ph, 1));
1194 905
1195 // Wait for |ch| to be readable. 906 // Wait for |ch| to be readable.
1196 hss = kEmptyMojoHandleSignalsState; 907 hss = kEmptyMojoHandleSignalsState;
1197 ASSERT_EQ(MOJO_RESULT_OK, core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 908 EXPECT_EQ(MOJO_RESULT_OK,
1198 1000000000, &hss)); 909 mojo::Wait(mojo::Handle(ch), MOJO_HANDLE_SIGNAL_READABLE, &hss));
1199 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, 910 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
1200 hss.satisfied_signals); 911 hss.satisfied_signals);
1201 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED | 912 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
1202 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE, 913 MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE,
1203 hss.satisfiable_signals); 914 hss.satisfiable_signals);
1204 915
1205 // Make sure that |ch| can't be sent if it's in a two-phase read. 916 // Make sure that |ch| can't be sent if it's in a two-phase read.
1206 const void* read_ptr = nullptr; 917 const void* read_ptr = nullptr;
1207 num_bytes = 1; 918 num_bytes = 1;
1208 ASSERT_EQ(MOJO_RESULT_OK, 919 ASSERT_EQ(MOJO_RESULT_OK,
1209 core()->BeginReadData(ch, &read_ptr, &num_bytes, 920 core()->BeginReadData(ch, &read_ptr, &num_bytes,
1210 MOJO_READ_DATA_FLAG_ALL_OR_NONE)); 921 MOJO_READ_DATA_FLAG_ALL_OR_NONE));
1211 ASSERT_EQ(MOJO_RESULT_BUSY, 922 ASSERT_EQ(MOJO_RESULT_BUSY,
1212 core()->WriteMessage(h_passing[0], kHello, kHelloSize, &ch, 1, 923 core()->WriteMessage(h_passing[0], kHello, kHelloSize, &ch, 1,
1213 MOJO_WRITE_MESSAGE_FLAG_NONE)); 924 MOJO_WRITE_MESSAGE_FLAG_NONE));
1214 925
1215 // But |ph| can, even if |ch| is in a two-phase read. 926 // But |ph| can, even if |ch| is in a two-phase read.
1216 ASSERT_EQ(MOJO_RESULT_OK, 927 ASSERT_EQ(MOJO_RESULT_OK,
1217 core()->WriteMessage(h_passing[0], kWorld, kWorldSize, &ph, 1, 928 core()->WriteMessage(h_passing[0], kWorld, kWorldSize, &ph, 1,
1218 MOJO_WRITE_MESSAGE_FLAG_NONE)); 929 MOJO_WRITE_MESSAGE_FLAG_NONE));
1219 ph = MOJO_HANDLE_INVALID; 930 ph = MOJO_HANDLE_INVALID;
1220 hss = kEmptyMojoHandleSignalsState; 931 hss = kEmptyMojoHandleSignalsState;
1221 ASSERT_EQ(MOJO_RESULT_OK, 932 EXPECT_EQ(MOJO_RESULT_OK, mojo::Wait(mojo::Handle(h_passing[1]),
1222 core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, 933 MOJO_HANDLE_SIGNAL_READABLE, &hss));
1223 &hss));
1224 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, 934 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
1225 hss.satisfied_signals); 935 hss.satisfied_signals);
1226 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); 936 ASSERT_EQ(kAllSignals, hss.satisfiable_signals);
1227 num_bytes = kBufferSize; 937 num_bytes = kBufferSize;
1228 num_handles = arraysize(handles); 938 num_handles = arraysize(handles);
1229 ASSERT_EQ(MOJO_RESULT_OK, 939 ASSERT_EQ(MOJO_RESULT_OK,
1230 core()->ReadMessage( 940 core()->ReadMessage(
1231 h_passing[1], buffer, &num_bytes, handles, &num_handles, 941 h_passing[1], buffer, &num_bytes, handles, &num_handles,
1232 MOJO_READ_MESSAGE_FLAG_NONE)); 942 MOJO_READ_MESSAGE_FLAG_NONE));
1233 ASSERT_EQ(kWorldSize, num_bytes); 943 ASSERT_EQ(kWorldSize, num_bytes);
(...skipping 18 matching lines...) Expand all
1252 void Awake(MojoResult r) { result = r; } 962 void Awake(MojoResult r) { result = r; }
1253 963
1254 MojoResult result; 964 MojoResult result;
1255 }; 965 };
1256 966
1257 // TODO(vtl): Test |DuplicateBufferHandle()| and |MapBuffer()|. 967 // TODO(vtl): Test |DuplicateBufferHandle()| and |MapBuffer()|.
1258 968
1259 } // namespace 969 } // namespace
1260 } // namespace edk 970 } // namespace edk
1261 } // namespace mojo 971 } // namespace mojo
OLDNEW
« no previous file with comments | « mojo/edk/system/core_test_base.cc ('k') | mojo/edk/system/data_pipe_consumer_dispatcher.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698