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 "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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 |
OLD | NEW |