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 <stdint.h> | 5 #include <stdint.h> |
6 #include <string.h> | 6 #include <string.h> |
7 | 7 |
8 #include "base/memory/ref_counted.h" | 8 #include "base/memory/ref_counted.h" |
9 #include "mojo/edk/system/test_utils.h" | 9 #include "mojo/edk/system/test_utils.h" |
10 #include "mojo/edk/test/mojo_test_base.h" | 10 #include "mojo/edk/test/mojo_test_base.h" |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
93 buffer[1] = 456; | 93 buffer[1] = 456; |
94 buffer_size = kBufferSize; | 94 buffer_size = kBufferSize; |
95 ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT, ReadMessage(pipe1_, buffer, &buffer_size)); | 95 ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT, ReadMessage(pipe1_, buffer, &buffer_size)); |
96 | 96 |
97 // Write from port 1 (to port 0). | 97 // Write from port 1 (to port 0). |
98 buffer[0] = 789012345; | 98 buffer[0] = 789012345; |
99 buffer[1] = 0; | 99 buffer[1] = 0; |
100 ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe1_, buffer, sizeof(buffer[0]))); | 100 ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe1_, buffer, sizeof(buffer[0]))); |
101 | 101 |
102 MojoHandleSignalsState state; | 102 MojoHandleSignalsState state; |
103 ASSERT_EQ(MOJO_RESULT_OK, | 103 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, |
104 WaitForSignals(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, &state)); | 104 MOJO_DEADLINE_INDEFINITE, &state)); |
105 | 105 |
106 // Read from port 0. | 106 // Read from port 0. |
107 buffer[0] = 123; | 107 buffer[0] = 123; |
108 buffer[1] = 456; | 108 buffer[1] = 456; |
109 buffer_size = kBufferSize; | 109 buffer_size = kBufferSize; |
110 ASSERT_EQ(MOJO_RESULT_OK, ReadMessage(pipe0_, buffer, &buffer_size)); | 110 ASSERT_EQ(MOJO_RESULT_OK, ReadMessage(pipe0_, buffer, &buffer_size)); |
111 ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); | 111 ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); |
112 ASSERT_EQ(789012345, buffer[0]); | 112 ASSERT_EQ(789012345, buffer[0]); |
113 ASSERT_EQ(456, buffer[1]); | 113 ASSERT_EQ(456, buffer[1]); |
114 | 114 |
115 // Read again from port 0 -- it should be empty. | 115 // Read again from port 0 -- it should be empty. |
116 buffer_size = kBufferSize; | 116 buffer_size = kBufferSize; |
117 ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT, ReadMessage(pipe0_, buffer, &buffer_size)); | 117 ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT, ReadMessage(pipe0_, buffer, &buffer_size)); |
118 | 118 |
119 // Write two messages from port 0 (to port 1). | 119 // Write two messages from port 0 (to port 1). |
120 buffer[0] = 123456789; | 120 buffer[0] = 123456789; |
121 buffer[1] = 0; | 121 buffer[1] = 0; |
122 ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe0_, buffer, sizeof(buffer[0]))); | 122 ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe0_, buffer, sizeof(buffer[0]))); |
123 buffer[0] = 234567890; | 123 buffer[0] = 234567890; |
124 buffer[1] = 0; | 124 buffer[1] = 0; |
125 ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe0_, buffer, sizeof(buffer[0]))); | 125 ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe0_, buffer, sizeof(buffer[0]))); |
126 | 126 |
127 ASSERT_EQ(MOJO_RESULT_OK, | 127 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, |
128 WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, &state)); | 128 MOJO_DEADLINE_INDEFINITE, &state)); |
129 | 129 |
130 // Read from port 1 with buffer size 0 (should get the size of next message). | 130 // Read from port 1 with buffer size 0 (should get the size of next message). |
131 // Also test that giving a null buffer is okay when the buffer size is 0. | 131 // Also test that giving a null buffer is okay when the buffer size is 0. |
132 buffer_size = 0; | 132 buffer_size = 0; |
133 ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, | 133 ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, |
134 ReadMessage(pipe1_, nullptr, &buffer_size)); | 134 ReadMessage(pipe1_, nullptr, &buffer_size)); |
135 ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); | 135 ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); |
136 | 136 |
137 // Read from port 1 with buffer size 1 (too small; should get the size of next | 137 // Read from port 1 with buffer size 1 (too small; should get the size of next |
138 // message). | 138 // message). |
139 buffer[0] = 123; | 139 buffer[0] = 123; |
140 buffer[1] = 456; | 140 buffer[1] = 456; |
141 buffer_size = 1; | 141 buffer_size = 1; |
142 ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, | 142 ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, |
143 ReadMessage(pipe1_, buffer, &buffer_size)); | 143 ReadMessage(pipe1_, buffer, &buffer_size)); |
144 ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); | 144 ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); |
145 ASSERT_EQ(123, buffer[0]); | 145 ASSERT_EQ(123, buffer[0]); |
146 ASSERT_EQ(456, buffer[1]); | 146 ASSERT_EQ(456, buffer[1]); |
147 | 147 |
148 // Read from port 1. | 148 // Read from port 1. |
149 buffer[0] = 123; | 149 buffer[0] = 123; |
150 buffer[1] = 456; | 150 buffer[1] = 456; |
151 buffer_size = kBufferSize; | 151 buffer_size = kBufferSize; |
152 ASSERT_EQ(MOJO_RESULT_OK, ReadMessage(pipe1_, buffer, &buffer_size)); | 152 ASSERT_EQ(MOJO_RESULT_OK, ReadMessage(pipe1_, buffer, &buffer_size)); |
153 ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); | 153 ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); |
154 ASSERT_EQ(123456789, buffer[0]); | 154 ASSERT_EQ(123456789, buffer[0]); |
155 ASSERT_EQ(456, buffer[1]); | 155 ASSERT_EQ(456, buffer[1]); |
156 | 156 |
157 ASSERT_EQ(MOJO_RESULT_OK, | 157 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, |
158 WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, &state)); | 158 MOJO_DEADLINE_INDEFINITE, &state)); |
159 | 159 |
160 // Read again from port 1. | 160 // Read again from port 1. |
161 buffer[0] = 123; | 161 buffer[0] = 123; |
162 buffer[1] = 456; | 162 buffer[1] = 456; |
163 buffer_size = kBufferSize; | 163 buffer_size = kBufferSize; |
164 ASSERT_EQ(MOJO_RESULT_OK, ReadMessage(pipe1_, buffer, &buffer_size)); | 164 ASSERT_EQ(MOJO_RESULT_OK, ReadMessage(pipe1_, buffer, &buffer_size)); |
165 ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); | 165 ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); |
166 ASSERT_EQ(234567890, buffer[0]); | 166 ASSERT_EQ(234567890, buffer[0]); |
167 ASSERT_EQ(456, buffer[1]); | 167 ASSERT_EQ(456, buffer[1]); |
168 | 168 |
169 // Read again from port 1 -- it should be empty. | 169 // Read again from port 1 -- it should be empty. |
170 buffer_size = kBufferSize; | 170 buffer_size = kBufferSize; |
171 ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT, ReadMessage(pipe1_, buffer, &buffer_size)); | 171 ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT, ReadMessage(pipe1_, buffer, &buffer_size)); |
172 | 172 |
173 // Write from port 0 (to port 1). | 173 // Write from port 0 (to port 1). |
174 buffer[0] = 345678901; | 174 buffer[0] = 345678901; |
175 buffer[1] = 0; | 175 buffer[1] = 0; |
176 ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe0_, buffer, sizeof(buffer[0]))); | 176 ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe0_, buffer, sizeof(buffer[0]))); |
177 | 177 |
178 // Close port 0. | 178 // Close port 0. |
179 MojoClose(pipe0_); | 179 MojoClose(pipe0_); |
180 pipe0_ = MOJO_HANDLE_INVALID; | 180 pipe0_ = MOJO_HANDLE_INVALID; |
181 | 181 |
182 ASSERT_EQ(MOJO_RESULT_OK, | 182 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
183 WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, &state)); | 183 MOJO_DEADLINE_INDEFINITE, &state)); |
184 | 184 |
185 // Try to write from port 1 (to port 0). | 185 // Try to write from port 1 (to port 0). |
186 buffer[0] = 456789012; | 186 buffer[0] = 456789012; |
187 buffer[1] = 0; | 187 buffer[1] = 0; |
188 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | 188 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
189 WriteMessage(pipe1_, buffer, sizeof(buffer[0]))); | 189 WriteMessage(pipe1_, buffer, sizeof(buffer[0]))); |
190 | 190 |
191 // Read from port 1; should still get message (even though port 0 was closed). | 191 // Read from port 1; should still get message (even though port 0 was closed). |
192 buffer[0] = 123; | 192 buffer[0] = 123; |
193 buffer[1] = 456; | 193 buffer[1] = 456; |
(...skipping 14 matching lines...) Expand all Loading... |
208 const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer)); | 208 const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer)); |
209 uint32_t buffer_size; | 209 uint32_t buffer_size; |
210 | 210 |
211 // Write some messages from port 1 (to port 0). | 211 // Write some messages from port 1 (to port 0). |
212 for (int32_t i = 0; i < 5; i++) { | 212 for (int32_t i = 0; i < 5; i++) { |
213 buffer[0] = i; | 213 buffer[0] = i; |
214 ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe1_, buffer, kBufferSize)); | 214 ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe1_, buffer, kBufferSize)); |
215 } | 215 } |
216 | 216 |
217 MojoHandleSignalsState state; | 217 MojoHandleSignalsState state; |
218 ASSERT_EQ(MOJO_RESULT_OK, | 218 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, |
219 WaitForSignals(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, &state)); | 219 MOJO_DEADLINE_INDEFINITE, &state)); |
220 | 220 |
221 // Port 0 shouldn't be empty. | 221 // Port 0 shouldn't be empty. |
222 buffer_size = 0; | 222 buffer_size = 0; |
223 ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, | 223 ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, |
224 ReadMessage(pipe0_, nullptr, &buffer_size)); | 224 ReadMessage(pipe0_, nullptr, &buffer_size)); |
225 ASSERT_EQ(kBufferSize, buffer_size); | 225 ASSERT_EQ(kBufferSize, buffer_size); |
226 | 226 |
227 // Close port 0 first, which should have outstanding (incoming) messages. | 227 // Close port 0 first, which should have outstanding (incoming) messages. |
228 MojoClose(pipe0_); | 228 MojoClose(pipe0_); |
229 MojoClose(pipe1_); | 229 MojoClose(pipe1_); |
230 pipe0_ = pipe1_ = MOJO_HANDLE_INVALID; | 230 pipe0_ = pipe1_ = MOJO_HANDLE_INVALID; |
231 } | 231 } |
232 | 232 |
233 TEST_F(MessagePipeTest, DiscardMode) { | 233 TEST_F(MessagePipeTest, DiscardMode) { |
234 int32_t buffer[2]; | 234 int32_t buffer[2]; |
235 const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer)); | 235 const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer)); |
236 uint32_t buffer_size; | 236 uint32_t buffer_size; |
237 | 237 |
238 // Write from port 1 (to port 0). | 238 // Write from port 1 (to port 0). |
239 buffer[0] = 789012345; | 239 buffer[0] = 789012345; |
240 buffer[1] = 0; | 240 buffer[1] = 0; |
241 ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe1_, buffer, sizeof(buffer[0]))); | 241 ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe1_, buffer, sizeof(buffer[0]))); |
242 | 242 |
243 MojoHandleSignalsState state; | 243 MojoHandleSignalsState state; |
244 ASSERT_EQ(MOJO_RESULT_OK, | 244 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, |
245 WaitForSignals(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, &state)); | 245 MOJO_DEADLINE_INDEFINITE, &state)); |
246 | 246 |
247 // Read/discard from port 0 (no buffer); get size. | 247 // Read/discard from port 0 (no buffer); get size. |
248 buffer_size = 0; | 248 buffer_size = 0; |
249 ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, | 249 ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, |
250 ReadMessage(pipe0_, nullptr, &buffer_size, true)); | 250 ReadMessage(pipe0_, nullptr, &buffer_size, true)); |
251 ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); | 251 ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); |
252 | 252 |
253 // Read again from port 0 -- it should be empty. | 253 // Read again from port 0 -- it should be empty. |
254 buffer_size = kBufferSize; | 254 buffer_size = kBufferSize; |
255 ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT, | 255 ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT, |
256 ReadMessage(pipe0_, buffer, &buffer_size, true)); | 256 ReadMessage(pipe0_, buffer, &buffer_size, true)); |
257 | 257 |
258 // Write from port 1 (to port 0). | 258 // Write from port 1 (to port 0). |
259 buffer[0] = 890123456; | 259 buffer[0] = 890123456; |
260 buffer[1] = 0; | 260 buffer[1] = 0; |
261 ASSERT_EQ(MOJO_RESULT_OK, | 261 ASSERT_EQ(MOJO_RESULT_OK, |
262 WriteMessage(pipe1_, buffer, sizeof(buffer[0]))); | 262 WriteMessage(pipe1_, buffer, sizeof(buffer[0]))); |
263 | 263 |
264 ASSERT_EQ(MOJO_RESULT_OK, | 264 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, |
265 WaitForSignals(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, &state)); | 265 MOJO_DEADLINE_INDEFINITE, &state)); |
266 | 266 |
267 // Read from port 0 (buffer big enough). | 267 // Read from port 0 (buffer big enough). |
268 buffer[0] = 123; | 268 buffer[0] = 123; |
269 buffer[1] = 456; | 269 buffer[1] = 456; |
270 buffer_size = kBufferSize; | 270 buffer_size = kBufferSize; |
271 ASSERT_EQ(MOJO_RESULT_OK, ReadMessage(pipe0_, buffer, &buffer_size, true)); | 271 ASSERT_EQ(MOJO_RESULT_OK, ReadMessage(pipe0_, buffer, &buffer_size, true)); |
272 ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); | 272 ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); |
273 ASSERT_EQ(890123456, buffer[0]); | 273 ASSERT_EQ(890123456, buffer[0]); |
274 ASSERT_EQ(456, buffer[1]); | 274 ASSERT_EQ(456, buffer[1]); |
275 | 275 |
276 // Read again from port 0 -- it should be empty. | 276 // Read again from port 0 -- it should be empty. |
277 buffer_size = kBufferSize; | 277 buffer_size = kBufferSize; |
278 ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT, | 278 ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT, |
279 ReadMessage(pipe0_, buffer, &buffer_size, true)); | 279 ReadMessage(pipe0_, buffer, &buffer_size, true)); |
280 | 280 |
281 // Write from port 1 (to port 0). | 281 // Write from port 1 (to port 0). |
282 buffer[0] = 901234567; | 282 buffer[0] = 901234567; |
283 buffer[1] = 0; | 283 buffer[1] = 0; |
284 ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe1_, buffer, sizeof(buffer[0]))); | 284 ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe1_, buffer, sizeof(buffer[0]))); |
285 | 285 |
286 ASSERT_EQ(MOJO_RESULT_OK, | 286 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, |
287 WaitForSignals(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, &state)); | 287 MOJO_DEADLINE_INDEFINITE, &state)); |
288 | 288 |
289 // Read/discard from port 0 (buffer too small); get size. | 289 // Read/discard from port 0 (buffer too small); get size. |
290 buffer_size = 1; | 290 buffer_size = 1; |
291 ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, | 291 ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, |
292 ReadMessage(pipe0_, buffer, &buffer_size, true)); | 292 ReadMessage(pipe0_, buffer, &buffer_size, true)); |
293 ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); | 293 ASSERT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); |
294 | 294 |
295 // Read again from port 0 -- it should be empty. | 295 // Read again from port 0 -- it should be empty. |
296 buffer_size = kBufferSize; | 296 buffer_size = kBufferSize; |
297 ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT, | 297 ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT, |
298 ReadMessage(pipe0_, buffer, &buffer_size, true)); | 298 ReadMessage(pipe0_, buffer, &buffer_size, true)); |
299 | 299 |
300 // Write from port 1 (to port 0). | 300 // Write from port 1 (to port 0). |
301 buffer[0] = 123456789; | 301 buffer[0] = 123456789; |
302 buffer[1] = 0; | 302 buffer[1] = 0; |
303 ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe1_, buffer, sizeof(buffer[0]))); | 303 ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe1_, buffer, sizeof(buffer[0]))); |
304 | 304 |
305 ASSERT_EQ(MOJO_RESULT_OK, | 305 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, |
306 WaitForSignals(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, &state)); | 306 MOJO_DEADLINE_INDEFINITE, &state)); |
307 | 307 |
308 // Discard from port 0. | 308 // Discard from port 0. |
309 buffer_size = 1; | 309 buffer_size = 1; |
310 ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, | 310 ASSERT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, |
311 ReadMessage(pipe0_, nullptr, 0, true)); | 311 ReadMessage(pipe0_, nullptr, 0, true)); |
312 | 312 |
313 // Read again from port 0 -- it should be empty. | 313 // Read again from port 0 -- it should be empty. |
314 buffer_size = kBufferSize; | 314 buffer_size = kBufferSize; |
315 ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT, | 315 ASSERT_EQ(MOJO_RESULT_SHOULD_WAIT, |
316 ReadMessage(pipe0_, buffer, &buffer_size, true)); | 316 ReadMessage(pipe0_, buffer, &buffer_size, true)); |
317 } | 317 } |
318 | 318 |
319 TEST_F(MessagePipeTest, BasicWaiting) { | 319 TEST_F(MessagePipeTest, BasicWaiting) { |
320 MojoHandleSignalsState hss; | 320 MojoHandleSignalsState hss; |
321 | 321 |
322 int32_t buffer[1]; | 322 int32_t buffer[1]; |
323 const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer)); | 323 const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer)); |
324 uint32_t buffer_size; | 324 uint32_t buffer_size; |
325 | 325 |
326 // Always writable (until the other port is closed). Not yet readable. Peer | 326 // Always writable (until the other port is closed). |
327 // not closed. | 327 hss = MojoHandleSignalsState(); |
328 hss = GetSignalsState(pipe0_); | 328 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_WRITABLE, 0, |
| 329 &hss)); |
329 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); | 330 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); |
330 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); | 331 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); |
331 hss = MojoHandleSignalsState(); | 332 hss = MojoHandleSignalsState(); |
332 | 333 |
| 334 // Not yet readable. |
| 335 ASSERT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, |
| 336 MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss)); |
| 337 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); |
| 338 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); |
| 339 |
| 340 // The peer is not closed. |
| 341 hss = MojoHandleSignalsState(); |
| 342 ASSERT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, |
| 343 MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 0, &hss)); |
| 344 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); |
| 345 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); |
| 346 |
333 // Write from port 0 (to port 1), to make port 1 readable. | 347 // Write from port 0 (to port 1), to make port 1 readable. |
334 buffer[0] = 123456789; | 348 buffer[0] = 123456789; |
335 ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe0_, buffer, kBufferSize)); | 349 ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe0_, buffer, kBufferSize)); |
336 | 350 |
337 // Port 1 should already be readable now. | 351 // Port 1 should already be readable now. |
338 ASSERT_EQ(MOJO_RESULT_OK, | 352 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, |
339 WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 353 MOJO_DEADLINE_INDEFINITE, &hss)); |
340 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | 354 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, |
341 hss.satisfied_signals); | 355 hss.satisfied_signals); |
342 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); | 356 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); |
343 // ... and still writable. | 357 // ... and still writable. |
344 hss = MojoHandleSignalsState(); | 358 hss = MojoHandleSignalsState(); |
345 ASSERT_EQ(MOJO_RESULT_OK, | 359 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_WRITABLE, |
346 WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_WRITABLE, &hss)); | 360 MOJO_DEADLINE_INDEFINITE, &hss)); |
347 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | 361 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, |
348 hss.satisfied_signals); | 362 hss.satisfied_signals); |
349 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); | 363 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); |
350 | 364 |
351 // Close port 0. | 365 // Close port 0. |
352 MojoClose(pipe0_); | 366 MojoClose(pipe0_); |
353 pipe0_ = MOJO_HANDLE_INVALID; | 367 pipe0_ = MOJO_HANDLE_INVALID; |
354 | 368 |
355 // Port 1 should be signaled with peer closed. | 369 // Port 1 should be signaled with peer closed. |
356 hss = MojoHandleSignalsState(); | 370 hss = MojoHandleSignalsState(); |
357 ASSERT_EQ(MOJO_RESULT_OK, | 371 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
358 WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, &hss)); | 372 MOJO_DEADLINE_INDEFINITE, &hss)); |
359 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 373 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
360 hss.satisfied_signals); | 374 hss.satisfied_signals); |
361 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 375 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
362 hss.satisfiable_signals); | 376 hss.satisfiable_signals); |
363 | 377 |
364 // Port 1 should not be writable. | 378 // Port 1 should not be writable. |
365 hss = MojoHandleSignalsState(); | 379 hss = MojoHandleSignalsState(); |
366 | 380 |
367 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | 381 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
368 WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_WRITABLE, &hss)); | 382 MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_WRITABLE, |
| 383 MOJO_DEADLINE_INDEFINITE, &hss)); |
369 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 384 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
370 hss.satisfied_signals); | 385 hss.satisfied_signals); |
371 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 386 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
372 hss.satisfiable_signals); | 387 hss.satisfiable_signals); |
373 | 388 |
374 // But it should still be readable. | 389 // But it should still be readable. |
375 hss = MojoHandleSignalsState(); | 390 hss = MojoHandleSignalsState(); |
376 ASSERT_EQ(MOJO_RESULT_OK, | 391 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, |
377 WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 392 MOJO_DEADLINE_INDEFINITE, &hss)); |
378 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 393 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
379 hss.satisfied_signals); | 394 hss.satisfied_signals); |
380 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 395 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
381 hss.satisfiable_signals); | 396 hss.satisfiable_signals); |
382 | 397 |
383 // Read from port 1. | 398 // Read from port 1. |
384 buffer[0] = 0; | 399 buffer[0] = 0; |
385 buffer_size = kBufferSize; | 400 buffer_size = kBufferSize; |
386 ASSERT_EQ(MOJO_RESULT_OK, ReadMessage(pipe1_, buffer, &buffer_size)); | 401 ASSERT_EQ(MOJO_RESULT_OK, ReadMessage(pipe1_, buffer, &buffer_size)); |
387 ASSERT_EQ(123456789, buffer[0]); | 402 ASSERT_EQ(123456789, buffer[0]); |
388 | 403 |
389 // Now port 1 should no longer be readable. | 404 // Now port 1 should no longer be readable. |
390 hss = MojoHandleSignalsState(); | 405 hss = MojoHandleSignalsState(); |
391 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | 406 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
392 WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); | 407 MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, |
| 408 MOJO_DEADLINE_INDEFINITE, &hss)); |
393 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); | 409 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); |
394 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); | 410 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); |
395 } | 411 } |
396 | 412 |
397 TEST_F(MessagePipeTest, InvalidMessageObjects) { | 413 TEST_F(MessagePipeTest, InvalidMessageObjects) { |
398 // null message | 414 // null message |
399 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 415 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
400 MojoFreeMessage(MOJO_MESSAGE_HANDLE_INVALID)); | 416 MojoFreeMessage(MOJO_MESSAGE_HANDLE_INVALID)); |
401 | 417 |
402 // null message | 418 // null message |
(...skipping 27 matching lines...) Expand all Loading... |
430 void* buffer = nullptr; | 446 void* buffer = nullptr; |
431 EXPECT_EQ(MOJO_RESULT_OK, MojoGetMessageBuffer(message, &buffer)); | 447 EXPECT_EQ(MOJO_RESULT_OK, MojoGetMessageBuffer(message, &buffer)); |
432 ASSERT_TRUE(buffer); | 448 ASSERT_TRUE(buffer); |
433 memcpy(buffer, kMessage.data(), kMessage.size()); | 449 memcpy(buffer, kMessage.data(), kMessage.size()); |
434 | 450 |
435 MojoHandle a, b; | 451 MojoHandle a, b; |
436 CreateMessagePipe(&a, &b); | 452 CreateMessagePipe(&a, &b); |
437 EXPECT_EQ(MOJO_RESULT_OK, | 453 EXPECT_EQ(MOJO_RESULT_OK, |
438 MojoWriteMessageNew(a, message, MOJO_WRITE_MESSAGE_FLAG_NONE)); | 454 MojoWriteMessageNew(a, message, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
439 | 455 |
440 EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(b, MOJO_HANDLE_SIGNAL_READABLE)); | 456 EXPECT_EQ(MOJO_RESULT_OK, |
| 457 MojoWait(b, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, |
| 458 nullptr)); |
441 uint32_t num_bytes = 0; | 459 uint32_t num_bytes = 0; |
442 uint32_t num_handles = 0; | 460 uint32_t num_handles = 0; |
443 EXPECT_EQ(MOJO_RESULT_OK, | 461 EXPECT_EQ(MOJO_RESULT_OK, |
444 MojoReadMessageNew(b, &message, &num_bytes, nullptr, &num_handles, | 462 MojoReadMessageNew(b, &message, &num_bytes, nullptr, &num_handles, |
445 MOJO_READ_MESSAGE_FLAG_NONE)); | 463 MOJO_READ_MESSAGE_FLAG_NONE)); |
446 ASSERT_NE(MOJO_MESSAGE_HANDLE_INVALID, message); | 464 ASSERT_NE(MOJO_MESSAGE_HANDLE_INVALID, message); |
447 EXPECT_EQ(static_cast<uint32_t>(kMessage.size()), num_bytes); | 465 EXPECT_EQ(static_cast<uint32_t>(kMessage.size()), num_bytes); |
448 EXPECT_EQ(0u, num_handles); | 466 EXPECT_EQ(0u, num_handles); |
449 | 467 |
450 EXPECT_EQ(MOJO_RESULT_OK, MojoGetMessageBuffer(message, &buffer)); | 468 EXPECT_EQ(MOJO_RESULT_OK, MojoGetMessageBuffer(message, &buffer)); |
(...skipping 13 matching lines...) Expand all Loading... |
464 const size_t kPingPongIterations = 500; | 482 const size_t kPingPongIterations = 500; |
465 | 483 |
466 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(HandlePingPong, MessagePipeTest, h) { | 484 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(HandlePingPong, MessagePipeTest, h) { |
467 // Waits for a handle to become readable and writes it back to the sender. | 485 // Waits for a handle to become readable and writes it back to the sender. |
468 for (size_t i = 0; i < kPingPongIterations; i++) { | 486 for (size_t i = 0; i < kPingPongIterations; i++) { |
469 MojoHandle handles[kPingPongHandlesPerIteration]; | 487 MojoHandle handles[kPingPongHandlesPerIteration]; |
470 ReadMessageWithHandles(h, handles, kPingPongHandlesPerIteration); | 488 ReadMessageWithHandles(h, handles, kPingPongHandlesPerIteration); |
471 WriteMessageWithHandles(h, "", handles, kPingPongHandlesPerIteration); | 489 WriteMessageWithHandles(h, "", handles, kPingPongHandlesPerIteration); |
472 } | 490 } |
473 | 491 |
474 EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE)); | 492 EXPECT_EQ(MOJO_RESULT_OK, MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE, |
| 493 MOJO_DEADLINE_INDEFINITE, nullptr)); |
475 char msg[4]; | 494 char msg[4]; |
476 uint32_t num_bytes = 4; | 495 uint32_t num_bytes = 4; |
477 EXPECT_EQ(MOJO_RESULT_OK, ReadMessage(h, msg, &num_bytes)); | 496 EXPECT_EQ(MOJO_RESULT_OK, ReadMessage(h, msg, &num_bytes)); |
478 } | 497 } |
479 | 498 |
480 // This test is flaky: http://crbug.com/585784 | 499 // This test is flaky: http://crbug.com/585784 |
481 TEST_F(MessagePipeTest, DISABLED_DataPipeConsumerHandlePingPong) { | 500 TEST_F(MessagePipeTest, DISABLED_DataPipeConsumerHandlePingPong) { |
482 MojoHandle p, c[kPingPongHandlesPerIteration]; | 501 MojoHandle p, c[kPingPongHandlesPerIteration]; |
483 for (size_t i = 0; i < kPingPongHandlesPerIteration; ++i) { | 502 for (size_t i = 0; i < kPingPongHandlesPerIteration; ++i) { |
484 EXPECT_EQ(MOJO_RESULT_OK, MojoCreateDataPipe(nullptr, &p, &c[i])); | 503 EXPECT_EQ(MOJO_RESULT_OK, MojoCreateDataPipe(nullptr, &p, &c[i])); |
(...skipping 164 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
649 CreateMessagePipe(&a, &b); | 668 CreateMessagePipe(&a, &b); |
650 CreateMessagePipe(&c, &d); | 669 CreateMessagePipe(&c, &d); |
651 | 670 |
652 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a)); | 671 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a)); |
653 EXPECT_EQ(MOJO_RESULT_OK, MojoFuseMessagePipes(b, c)); | 672 EXPECT_EQ(MOJO_RESULT_OK, MojoFuseMessagePipes(b, c)); |
654 | 673 |
655 // Handles b and c should be closed. | 674 // Handles b and c should be closed. |
656 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(b)); | 675 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(b)); |
657 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(c)); | 676 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(c)); |
658 | 677 |
659 EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(d, MOJO_HANDLE_SIGNAL_PEER_CLOSED)); | 678 EXPECT_EQ(MOJO_RESULT_OK, MojoWait(d, MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| 679 MOJO_DEADLINE_INDEFINITE, nullptr)); |
| 680 |
660 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(d)); | 681 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(d)); |
661 } | 682 } |
662 | 683 |
663 TEST_F(FuseMessagePipeTest, FuseAfterPeerWriteAndClosure) { | 684 TEST_F(FuseMessagePipeTest, FuseAfterPeerWriteAndClosure) { |
664 // Test that peer write and closure prior to fusion still results in the | 685 // Test that peer write and closure prior to fusion still results in the |
665 // both message arrival and awareness of peer closure. | 686 // both message arrival and awareness of peer closure. |
666 | 687 |
667 MojoHandle a, b, c, d; | 688 MojoHandle a, b, c, d; |
668 CreateMessagePipe(&a, &b); | 689 CreateMessagePipe(&a, &b); |
669 CreateMessagePipe(&c, &d); | 690 CreateMessagePipe(&c, &d); |
670 | 691 |
671 const std::string kTestMessage = "ayyy lmao"; | 692 const std::string kTestMessage = "ayyy lmao"; |
672 WriteMessage(a, kTestMessage); | 693 WriteMessage(a, kTestMessage); |
673 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a)); | 694 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a)); |
674 | 695 |
675 EXPECT_EQ(MOJO_RESULT_OK, MojoFuseMessagePipes(b, c)); | 696 EXPECT_EQ(MOJO_RESULT_OK, MojoFuseMessagePipes(b, c)); |
676 | 697 |
677 // Handles b and c should be closed. | 698 // Handles b and c should be closed. |
678 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(b)); | 699 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(b)); |
679 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(c)); | 700 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(c)); |
680 | 701 |
681 EXPECT_EQ(kTestMessage, ReadMessage(d)); | 702 EXPECT_EQ(kTestMessage, ReadMessage(d)); |
682 EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(d, MOJO_HANDLE_SIGNAL_PEER_CLOSED)); | 703 EXPECT_EQ(MOJO_RESULT_OK, MojoWait(d, MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
| 704 MOJO_DEADLINE_INDEFINITE, nullptr)); |
| 705 |
683 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(d)); | 706 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(d)); |
684 } | 707 } |
685 | 708 |
686 TEST_F(MessagePipeTest, ClosePipesStressTest) { | 709 TEST_F(MessagePipeTest, ClosePipesStressTest) { |
687 // Stress test to exercise https://crbug.com/665869. | 710 // Stress test to exercise https://crbug.com/665869. |
688 const size_t kNumPipes = 100000; | 711 const size_t kNumPipes = 100000; |
689 for (size_t i = 0; i < kNumPipes; ++i) { | 712 for (size_t i = 0; i < kNumPipes; ++i) { |
690 MojoHandle a, b; | 713 MojoHandle a, b; |
691 CreateMessagePipe(&a, &b); | 714 CreateMessagePipe(&a, &b); |
692 MojoClose(a); | 715 MojoClose(a); |
693 MojoClose(b); | 716 MojoClose(b); |
694 } | 717 } |
695 } | 718 } |
696 | 719 |
697 } // namespace | 720 } // namespace |
698 } // namespace edk | 721 } // namespace edk |
699 } // namespace mojo | 722 } // namespace mojo |
OLD | NEW |