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, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, | 103 ASSERT_EQ(MOJO_RESULT_OK, |
104 MOJO_DEADLINE_INDEFINITE, &state)); | 104 WaitForSignals(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, &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, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, | 127 ASSERT_EQ(MOJO_RESULT_OK, |
128 MOJO_DEADLINE_INDEFINITE, &state)); | 128 WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, &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, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, | 157 ASSERT_EQ(MOJO_RESULT_OK, |
158 MOJO_DEADLINE_INDEFINITE, &state)); | 158 WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, &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, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 182 ASSERT_EQ(MOJO_RESULT_OK, |
183 MOJO_DEADLINE_INDEFINITE, &state)); | 183 WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, &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, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, | 218 ASSERT_EQ(MOJO_RESULT_OK, |
219 MOJO_DEADLINE_INDEFINITE, &state)); | 219 WaitForSignals(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, &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, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, | 244 ASSERT_EQ(MOJO_RESULT_OK, |
245 MOJO_DEADLINE_INDEFINITE, &state)); | 245 WaitForSignals(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, &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, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, | 264 ASSERT_EQ(MOJO_RESULT_OK, |
265 MOJO_DEADLINE_INDEFINITE, &state)); | 265 WaitForSignals(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, &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, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, | 286 ASSERT_EQ(MOJO_RESULT_OK, |
287 MOJO_DEADLINE_INDEFINITE, &state)); | 287 WaitForSignals(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, &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, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, | 305 ASSERT_EQ(MOJO_RESULT_OK, |
306 MOJO_DEADLINE_INDEFINITE, &state)); | 306 WaitForSignals(pipe0_, MOJO_HANDLE_SIGNAL_READABLE, &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). | 326 // Always writable (until the other port is closed). Not yet readable. Peer |
327 hss = MojoHandleSignalsState(); | 327 // not closed. |
328 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe0_, MOJO_HANDLE_SIGNAL_WRITABLE, 0, | 328 hss = GetSignalsState(pipe0_); |
329 &hss)); | |
330 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); | 329 ASSERT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); |
331 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); | 330 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); |
332 hss = MojoHandleSignalsState(); | 331 hss = MojoHandleSignalsState(); |
333 | 332 |
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 | |
347 // Write from port 0 (to port 1), to make port 1 readable. | 333 // Write from port 0 (to port 1), to make port 1 readable. |
348 buffer[0] = 123456789; | 334 buffer[0] = 123456789; |
349 ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe0_, buffer, kBufferSize)); | 335 ASSERT_EQ(MOJO_RESULT_OK, WriteMessage(pipe0_, buffer, kBufferSize)); |
350 | 336 |
351 // Port 1 should already be readable now. | 337 // Port 1 should already be readable now. |
352 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, | 338 ASSERT_EQ(MOJO_RESULT_OK, |
353 MOJO_DEADLINE_INDEFINITE, &hss)); | 339 WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); |
354 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | 340 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, |
355 hss.satisfied_signals); | 341 hss.satisfied_signals); |
356 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); | 342 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); |
357 // ... and still writable. | 343 // ... and still writable. |
358 hss = MojoHandleSignalsState(); | 344 hss = MojoHandleSignalsState(); |
359 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_WRITABLE, | 345 ASSERT_EQ(MOJO_RESULT_OK, |
360 MOJO_DEADLINE_INDEFINITE, &hss)); | 346 WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_WRITABLE, &hss)); |
361 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, | 347 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, |
362 hss.satisfied_signals); | 348 hss.satisfied_signals); |
363 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); | 349 ASSERT_EQ(kAllSignals, hss.satisfiable_signals); |
364 | 350 |
365 // Close port 0. | 351 // Close port 0. |
366 MojoClose(pipe0_); | 352 MojoClose(pipe0_); |
367 pipe0_ = MOJO_HANDLE_INVALID; | 353 pipe0_ = MOJO_HANDLE_INVALID; |
368 | 354 |
369 // Port 1 should be signaled with peer closed. | 355 // Port 1 should be signaled with peer closed. |
370 hss = MojoHandleSignalsState(); | 356 hss = MojoHandleSignalsState(); |
371 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 357 ASSERT_EQ(MOJO_RESULT_OK, |
372 MOJO_DEADLINE_INDEFINITE, &hss)); | 358 WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_PEER_CLOSED, &hss)); |
373 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 359 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
374 hss.satisfied_signals); | 360 hss.satisfied_signals); |
375 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 361 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
376 hss.satisfiable_signals); | 362 hss.satisfiable_signals); |
377 | 363 |
378 // Port 1 should not be writable. | 364 // Port 1 should not be writable. |
379 hss = MojoHandleSignalsState(); | 365 hss = MojoHandleSignalsState(); |
380 | 366 |
381 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | 367 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
382 MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_WRITABLE, | 368 WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_WRITABLE, &hss)); |
383 MOJO_DEADLINE_INDEFINITE, &hss)); | |
384 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 369 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
385 hss.satisfied_signals); | 370 hss.satisfied_signals); |
386 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 371 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
387 hss.satisfiable_signals); | 372 hss.satisfiable_signals); |
388 | 373 |
389 // But it should still be readable. | 374 // But it should still be readable. |
390 hss = MojoHandleSignalsState(); | 375 hss = MojoHandleSignalsState(); |
391 ASSERT_EQ(MOJO_RESULT_OK, MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, | 376 ASSERT_EQ(MOJO_RESULT_OK, |
392 MOJO_DEADLINE_INDEFINITE, &hss)); | 377 WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); |
393 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 378 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
394 hss.satisfied_signals); | 379 hss.satisfied_signals); |
395 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 380 ASSERT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, |
396 hss.satisfiable_signals); | 381 hss.satisfiable_signals); |
397 | 382 |
398 // Read from port 1. | 383 // Read from port 1. |
399 buffer[0] = 0; | 384 buffer[0] = 0; |
400 buffer_size = kBufferSize; | 385 buffer_size = kBufferSize; |
401 ASSERT_EQ(MOJO_RESULT_OK, ReadMessage(pipe1_, buffer, &buffer_size)); | 386 ASSERT_EQ(MOJO_RESULT_OK, ReadMessage(pipe1_, buffer, &buffer_size)); |
402 ASSERT_EQ(123456789, buffer[0]); | 387 ASSERT_EQ(123456789, buffer[0]); |
403 | 388 |
404 // Now port 1 should no longer be readable. | 389 // Now port 1 should no longer be readable. |
405 hss = MojoHandleSignalsState(); | 390 hss = MojoHandleSignalsState(); |
406 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, | 391 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
407 MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, | 392 WaitForSignals(pipe1_, MOJO_HANDLE_SIGNAL_READABLE, &hss)); |
408 MOJO_DEADLINE_INDEFINITE, &hss)); | |
409 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); | 393 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); |
410 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); | 394 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); |
411 } | 395 } |
412 | 396 |
413 TEST_F(MessagePipeTest, InvalidMessageObjects) { | 397 TEST_F(MessagePipeTest, InvalidMessageObjects) { |
414 // null message | 398 // null message |
415 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, | 399 ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, |
416 MojoFreeMessage(MOJO_MESSAGE_HANDLE_INVALID)); | 400 MojoFreeMessage(MOJO_MESSAGE_HANDLE_INVALID)); |
417 | 401 |
418 // null message | 402 // null message |
(...skipping 27 matching lines...) Expand all Loading... |
446 void* buffer = nullptr; | 430 void* buffer = nullptr; |
447 EXPECT_EQ(MOJO_RESULT_OK, MojoGetMessageBuffer(message, &buffer)); | 431 EXPECT_EQ(MOJO_RESULT_OK, MojoGetMessageBuffer(message, &buffer)); |
448 ASSERT_TRUE(buffer); | 432 ASSERT_TRUE(buffer); |
449 memcpy(buffer, kMessage.data(), kMessage.size()); | 433 memcpy(buffer, kMessage.data(), kMessage.size()); |
450 | 434 |
451 MojoHandle a, b; | 435 MojoHandle a, b; |
452 CreateMessagePipe(&a, &b); | 436 CreateMessagePipe(&a, &b); |
453 EXPECT_EQ(MOJO_RESULT_OK, | 437 EXPECT_EQ(MOJO_RESULT_OK, |
454 MojoWriteMessageNew(a, message, MOJO_WRITE_MESSAGE_FLAG_NONE)); | 438 MojoWriteMessageNew(a, message, MOJO_WRITE_MESSAGE_FLAG_NONE)); |
455 | 439 |
456 EXPECT_EQ(MOJO_RESULT_OK, | 440 EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(b, MOJO_HANDLE_SIGNAL_READABLE)); |
457 MojoWait(b, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, | |
458 nullptr)); | |
459 uint32_t num_bytes = 0; | 441 uint32_t num_bytes = 0; |
460 uint32_t num_handles = 0; | 442 uint32_t num_handles = 0; |
461 EXPECT_EQ(MOJO_RESULT_OK, | 443 EXPECT_EQ(MOJO_RESULT_OK, |
462 MojoReadMessageNew(b, &message, &num_bytes, nullptr, &num_handles, | 444 MojoReadMessageNew(b, &message, &num_bytes, nullptr, &num_handles, |
463 MOJO_READ_MESSAGE_FLAG_NONE)); | 445 MOJO_READ_MESSAGE_FLAG_NONE)); |
464 ASSERT_NE(MOJO_MESSAGE_HANDLE_INVALID, message); | 446 ASSERT_NE(MOJO_MESSAGE_HANDLE_INVALID, message); |
465 EXPECT_EQ(static_cast<uint32_t>(kMessage.size()), num_bytes); | 447 EXPECT_EQ(static_cast<uint32_t>(kMessage.size()), num_bytes); |
466 EXPECT_EQ(0u, num_handles); | 448 EXPECT_EQ(0u, num_handles); |
467 | 449 |
468 EXPECT_EQ(MOJO_RESULT_OK, MojoGetMessageBuffer(message, &buffer)); | 450 EXPECT_EQ(MOJO_RESULT_OK, MojoGetMessageBuffer(message, &buffer)); |
(...skipping 13 matching lines...) Expand all Loading... |
482 const size_t kPingPongIterations = 500; | 464 const size_t kPingPongIterations = 500; |
483 | 465 |
484 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(HandlePingPong, MessagePipeTest, h) { | 466 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(HandlePingPong, MessagePipeTest, h) { |
485 // Waits for a handle to become readable and writes it back to the sender. | 467 // Waits for a handle to become readable and writes it back to the sender. |
486 for (size_t i = 0; i < kPingPongIterations; i++) { | 468 for (size_t i = 0; i < kPingPongIterations; i++) { |
487 MojoHandle handles[kPingPongHandlesPerIteration]; | 469 MojoHandle handles[kPingPongHandlesPerIteration]; |
488 ReadMessageWithHandles(h, handles, kPingPongHandlesPerIteration); | 470 ReadMessageWithHandles(h, handles, kPingPongHandlesPerIteration); |
489 WriteMessageWithHandles(h, "", handles, kPingPongHandlesPerIteration); | 471 WriteMessageWithHandles(h, "", handles, kPingPongHandlesPerIteration); |
490 } | 472 } |
491 | 473 |
492 EXPECT_EQ(MOJO_RESULT_OK, MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE, | 474 EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(h, MOJO_HANDLE_SIGNAL_READABLE)); |
493 MOJO_DEADLINE_INDEFINITE, nullptr)); | |
494 char msg[4]; | 475 char msg[4]; |
495 uint32_t num_bytes = 4; | 476 uint32_t num_bytes = 4; |
496 EXPECT_EQ(MOJO_RESULT_OK, ReadMessage(h, msg, &num_bytes)); | 477 EXPECT_EQ(MOJO_RESULT_OK, ReadMessage(h, msg, &num_bytes)); |
497 } | 478 } |
498 | 479 |
499 // This test is flaky: http://crbug.com/585784 | 480 // This test is flaky: http://crbug.com/585784 |
500 TEST_F(MessagePipeTest, DISABLED_DataPipeConsumerHandlePingPong) { | 481 TEST_F(MessagePipeTest, DISABLED_DataPipeConsumerHandlePingPong) { |
501 MojoHandle p, c[kPingPongHandlesPerIteration]; | 482 MojoHandle p, c[kPingPongHandlesPerIteration]; |
502 for (size_t i = 0; i < kPingPongHandlesPerIteration; ++i) { | 483 for (size_t i = 0; i < kPingPongHandlesPerIteration; ++i) { |
503 EXPECT_EQ(MOJO_RESULT_OK, MojoCreateDataPipe(nullptr, &p, &c[i])); | 484 EXPECT_EQ(MOJO_RESULT_OK, MojoCreateDataPipe(nullptr, &p, &c[i])); |
(...skipping 164 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
668 CreateMessagePipe(&a, &b); | 649 CreateMessagePipe(&a, &b); |
669 CreateMessagePipe(&c, &d); | 650 CreateMessagePipe(&c, &d); |
670 | 651 |
671 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a)); | 652 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a)); |
672 EXPECT_EQ(MOJO_RESULT_OK, MojoFuseMessagePipes(b, c)); | 653 EXPECT_EQ(MOJO_RESULT_OK, MojoFuseMessagePipes(b, c)); |
673 | 654 |
674 // Handles b and c should be closed. | 655 // Handles b and c should be closed. |
675 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(b)); | 656 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(b)); |
676 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(c)); | 657 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(c)); |
677 | 658 |
678 EXPECT_EQ(MOJO_RESULT_OK, MojoWait(d, MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 659 EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(d, MOJO_HANDLE_SIGNAL_PEER_CLOSED)); |
679 MOJO_DEADLINE_INDEFINITE, nullptr)); | |
680 | |
681 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(d)); | 660 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(d)); |
682 } | 661 } |
683 | 662 |
684 TEST_F(FuseMessagePipeTest, FuseAfterPeerWriteAndClosure) { | 663 TEST_F(FuseMessagePipeTest, FuseAfterPeerWriteAndClosure) { |
685 // Test that peer write and closure prior to fusion still results in the | 664 // Test that peer write and closure prior to fusion still results in the |
686 // both message arrival and awareness of peer closure. | 665 // both message arrival and awareness of peer closure. |
687 | 666 |
688 MojoHandle a, b, c, d; | 667 MojoHandle a, b, c, d; |
689 CreateMessagePipe(&a, &b); | 668 CreateMessagePipe(&a, &b); |
690 CreateMessagePipe(&c, &d); | 669 CreateMessagePipe(&c, &d); |
691 | 670 |
692 const std::string kTestMessage = "ayyy lmao"; | 671 const std::string kTestMessage = "ayyy lmao"; |
693 WriteMessage(a, kTestMessage); | 672 WriteMessage(a, kTestMessage); |
694 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a)); | 673 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a)); |
695 | 674 |
696 EXPECT_EQ(MOJO_RESULT_OK, MojoFuseMessagePipes(b, c)); | 675 EXPECT_EQ(MOJO_RESULT_OK, MojoFuseMessagePipes(b, c)); |
697 | 676 |
698 // Handles b and c should be closed. | 677 // Handles b and c should be closed. |
699 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(b)); | 678 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(b)); |
700 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(c)); | 679 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(c)); |
701 | 680 |
702 EXPECT_EQ(kTestMessage, ReadMessage(d)); | 681 EXPECT_EQ(kTestMessage, ReadMessage(d)); |
703 EXPECT_EQ(MOJO_RESULT_OK, MojoWait(d, MOJO_HANDLE_SIGNAL_PEER_CLOSED, | 682 EXPECT_EQ(MOJO_RESULT_OK, WaitForSignals(d, MOJO_HANDLE_SIGNAL_PEER_CLOSED)); |
704 MOJO_DEADLINE_INDEFINITE, nullptr)); | |
705 | |
706 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(d)); | 683 EXPECT_EQ(MOJO_RESULT_OK, MojoClose(d)); |
707 } | 684 } |
708 | 685 |
709 TEST_F(MessagePipeTest, ClosePipesStressTest) { | 686 TEST_F(MessagePipeTest, ClosePipesStressTest) { |
710 // Stress test to exercise https://crbug.com/665869. | 687 // Stress test to exercise https://crbug.com/665869. |
711 const size_t kNumPipes = 100000; | 688 const size_t kNumPipes = 100000; |
712 for (size_t i = 0; i < kNumPipes; ++i) { | 689 for (size_t i = 0; i < kNumPipes; ++i) { |
713 MojoHandle a, b; | 690 MojoHandle a, b; |
714 CreateMessagePipe(&a, &b); | 691 CreateMessagePipe(&a, &b); |
715 MojoClose(a); | 692 MojoClose(a); |
716 MojoClose(b); | 693 MojoClose(b); |
717 } | 694 } |
718 } | 695 } |
719 | 696 |
720 } // namespace | 697 } // namespace |
721 } // namespace edk | 698 } // namespace edk |
722 } // namespace mojo | 699 } // namespace mojo |
OLD | NEW |