?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Disable PrintPreviewTest.TaskManagerNewPrintPreview.
[chromium-blink-merge.git] / mojo / system / local_data_pipe_unittest.cc
blobadcd556d2b472dc0141280fa0cdb9c783f239c1b
1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "mojo/system/local_data_pipe.h"
6
7 #include <string.h>
8
9 #include "base/macros.h"
10 #include "base/memory/ref_counted.h"
11 #include "mojo/system/data_pipe.h"
12 #include "mojo/system/waiter.h"
13 #include "testing/gtest/include/gtest/gtest.h"
14
15 namespace mojo {
16 namespace system {
17 namespace {
18
19 const uint32_t kSizeOfOptions =
20 static_cast<uint32_t>(sizeof(MojoCreateDataPipeOptions));
21
22 // Validate options.
23 TEST(LocalDataPipeTest, Creation) {
24 // Create using default options.
25 {
26 // Get default options.
27 MojoCreateDataPipeOptions default_options = {0};
28 EXPECT_EQ(
29 MOJO_RESULT_OK,
30 DataPipe::ValidateCreateOptions(NullUserPointer(), &default_options));
31 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(default_options));
32 dp->ProducerClose();
33 dp->ConsumerClose();
34 }
35
36 // Create using non-default options.
37 {
38 const MojoCreateDataPipeOptions options = {
39 kSizeOfOptions, // |struct_size|.
40 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|.
41 1, // |element_num_bytes|.
42 1000 // |capacity_num_bytes|.
43 };
44 MojoCreateDataPipeOptions validated_options = {0};
45 EXPECT_EQ(MOJO_RESULT_OK,
46 DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
47 &validated_options));
48 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
49 dp->ProducerClose();
50 dp->ConsumerClose();
51 }
52 {
53 const MojoCreateDataPipeOptions options = {
54 kSizeOfOptions, // |struct_size|.
55 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|.
56 4, // |element_num_bytes|.
57 4000 // |capacity_num_bytes|.
58 };
59 MojoCreateDataPipeOptions validated_options = {0};
60 EXPECT_EQ(MOJO_RESULT_OK,
61 DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
62 &validated_options));
63 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
64 dp->ProducerClose();
65 dp->ConsumerClose();
66 }
67 {
68 const MojoCreateDataPipeOptions options = {
69 kSizeOfOptions, // |struct_size|.
70 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD, // |flags|.
71 7, // |element_num_bytes|.
72 7000000 // |capacity_num_bytes|.
73 };
74 MojoCreateDataPipeOptions validated_options = {0};
75 EXPECT_EQ(MOJO_RESULT_OK,
76 DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
77 &validated_options));
78 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
79 dp->ProducerClose();
80 dp->ConsumerClose();
81 }
82 // Default capacity.
83 {
84 const MojoCreateDataPipeOptions options = {
85 kSizeOfOptions, // |struct_size|.
86 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD, // |flags|.
87 100, // |element_num_bytes|.
88 0 // |capacity_num_bytes|.
89 };
90 MojoCreateDataPipeOptions validated_options = {0};
91 EXPECT_EQ(MOJO_RESULT_OK,
92 DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
93 &validated_options));
94 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
95 dp->ProducerClose();
96 dp->ConsumerClose();
97 }
98 }
99
100 TEST(LocalDataPipeTest, SimpleReadWrite) {
101 const MojoCreateDataPipeOptions options = {
102 kSizeOfOptions, // |struct_size|.
103 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|.
104 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|.
105 1000 * sizeof(int32_t) // |capacity_num_bytes|.
106 };
107 MojoCreateDataPipeOptions validated_options = {0};
108 EXPECT_EQ(MOJO_RESULT_OK,
109 DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
110 &validated_options));
111
112 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
113
114 int32_t elements[10] = {0};
115 uint32_t num_bytes = 0;
116
117 // Try reading; nothing there yet.
118 num_bytes = static_cast<uint32_t>(arraysize(elements) * sizeof(elements[0]));
119 EXPECT_EQ(
120 MOJO_RESULT_SHOULD_WAIT,
121 dp->ConsumerReadData(
122 UserPointer<void>(elements), MakeUserPointer(&num_bytes), false));
123
124 // Query; nothing there yet.
125 num_bytes = 0;
126 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
127 EXPECT_EQ(0u, num_bytes);
128
129 // Discard; nothing there yet.
130 num_bytes = static_cast<uint32_t>(5u * sizeof(elements[0]));
131 EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
132 dp->ConsumerDiscardData(MakeUserPointer(&num_bytes), false));
133
134 // Read with invalid |num_bytes|.
135 num_bytes = sizeof(elements[0]) + 1;
136 EXPECT_EQ(
137 MOJO_RESULT_INVALID_ARGUMENT,
138 dp->ConsumerReadData(
139 UserPointer<void>(elements), MakeUserPointer(&num_bytes), false));
140
141 // Write two elements.
142 elements[0] = 123;
143 elements[1] = 456;
144 num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
145 EXPECT_EQ(MOJO_RESULT_OK,
146 dp->ProducerWriteData(UserPointer<const void>(elements),
147 MakeUserPointer(&num_bytes),
148 false));
149 // It should have written everything (even without "all or none").
150 EXPECT_EQ(2u * sizeof(elements[0]), num_bytes);
151
152 // Query.
153 num_bytes = 0;
154 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
155 EXPECT_EQ(2 * sizeof(elements[0]), num_bytes);
156
157 // Read one element.
158 elements[0] = -1;
159 elements[1] = -1;
160 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
161 EXPECT_EQ(
162 MOJO_RESULT_OK,
163 dp->ConsumerReadData(
164 UserPointer<void>(elements), MakeUserPointer(&num_bytes), false));
165 EXPECT_EQ(1u * sizeof(elements[0]), num_bytes);
166 EXPECT_EQ(123, elements[0]);
167 EXPECT_EQ(-1, elements[1]);
168
169 // Query.
170 num_bytes = 0;
171 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
172 EXPECT_EQ(1 * sizeof(elements[0]), num_bytes);
173
174 // Try to read two elements, with "all or none".
175 elements[0] = -1;
176 elements[1] = -1;
177 num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
178 EXPECT_EQ(
179 MOJO_RESULT_OUT_OF_RANGE,
180 dp->ConsumerReadData(
181 UserPointer<void>(elements), MakeUserPointer(&num_bytes), true));
182 EXPECT_EQ(-1, elements[0]);
183 EXPECT_EQ(-1, elements[1]);
184
185 // Try to read two elements, without "all or none".
186 elements[0] = -1;
187 elements[1] = -1;
188 num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
189 EXPECT_EQ(
190 MOJO_RESULT_OK,
191 dp->ConsumerReadData(
192 UserPointer<void>(elements), MakeUserPointer(&num_bytes), false));
193 EXPECT_EQ(456, elements[0]);
194 EXPECT_EQ(-1, elements[1]);
195
196 // Query.
197 num_bytes = 0;
198 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
199 EXPECT_EQ(0u, num_bytes);
200
201 dp->ProducerClose();
202 dp->ConsumerClose();
203 }
204
205 // Note: The "basic" waiting tests test that the "wait states" are correct in
206 // various situations; they don't test that waiters are properly awoken on state
207 // changes. (For that, we need to use multiple threads.)
208 TEST(LocalDataPipeTest, BasicProducerWaiting) {
209 // Note: We take advantage of the fact that for |LocalDataPipe|, capacities
210 // are strict maximums. This is not guaranteed by the API.
211
212 const MojoCreateDataPipeOptions options = {
213 kSizeOfOptions, // |struct_size|.
214 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|.
215 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|.
216 2 * sizeof(int32_t) // |capacity_num_bytes|.
217 };
218 MojoCreateDataPipeOptions validated_options = {0};
219 EXPECT_EQ(MOJO_RESULT_OK,
220 DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
221 &validated_options));
222
223 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
224 Waiter waiter;
225 uint32_t context = 0;
226 HandleSignalsState hss;
227
228 // Never readable.
229 waiter.Init();
230 hss = HandleSignalsState();
231 EXPECT_EQ(
232 MOJO_RESULT_FAILED_PRECONDITION,
233 dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12, &hss));
234 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
235 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
236
237 // Already writable.
238 waiter.Init();
239 hss = HandleSignalsState();
240 EXPECT_EQ(
241 MOJO_RESULT_ALREADY_EXISTS,
242 dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 34, &hss));
243
244 // Write two elements.
245 int32_t elements[2] = {123, 456};
246 uint32_t num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
247 EXPECT_EQ(MOJO_RESULT_OK,
248 dp->ProducerWriteData(UserPointer<const void>(elements),
249 MakeUserPointer(&num_bytes),
250 true));
251 EXPECT_EQ(static_cast<uint32_t>(2u * sizeof(elements[0])), num_bytes);
252
253 // Adding a waiter should now succeed.
254 waiter.Init();
255 ASSERT_EQ(
256 MOJO_RESULT_OK,
257 dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 56, nullptr));
258 // And it shouldn't be writable yet.
259 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
260 hss = HandleSignalsState();
261 dp->ProducerRemoveWaiter(&waiter, &hss);
262 EXPECT_EQ(0u, hss.satisfied_signals);
263 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
264
265 // Do it again.
266 waiter.Init();
267 ASSERT_EQ(
268 MOJO_RESULT_OK,
269 dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 78, nullptr));
270
271 // Read one element.
272 elements[0] = -1;
273 elements[1] = -1;
274 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
275 EXPECT_EQ(
276 MOJO_RESULT_OK,
277 dp->ConsumerReadData(
278 UserPointer<void>(elements), MakeUserPointer(&num_bytes), true));
279 EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
280 EXPECT_EQ(123, elements[0]);
281 EXPECT_EQ(-1, elements[1]);
282
283 // Waiting should now succeed.
284 EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(1000, &context));
285 EXPECT_EQ(78u, context);
286 hss = HandleSignalsState();
287 dp->ProducerRemoveWaiter(&waiter, &hss);
288 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
289 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
290
291 // Try writing, using a two-phase write.
292 void* buffer = nullptr;
293 num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0]));
294 EXPECT_EQ(MOJO_RESULT_OK,
295 dp->ProducerBeginWriteData(
296 MakeUserPointer(&buffer), MakeUserPointer(&num_bytes), false));
297 EXPECT_TRUE(buffer);
298 EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
299
300 static_cast<int32_t*>(buffer)[0] = 789;
301 EXPECT_EQ(MOJO_RESULT_OK,
302 dp->ProducerEndWriteData(
303 static_cast<uint32_t>(1u * sizeof(elements[0]))));
304
305 // Add a waiter.
306 waiter.Init();
307 ASSERT_EQ(
308 MOJO_RESULT_OK,
309 dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 90, nullptr));
310
311 // Read one element, using a two-phase read.
312 const void* read_buffer = nullptr;
313 num_bytes = 0u;
314 EXPECT_EQ(
315 MOJO_RESULT_OK,
316 dp->ConsumerBeginReadData(
317 MakeUserPointer(&read_buffer), MakeUserPointer(&num_bytes), false));
318 EXPECT_TRUE(read_buffer);
319 // Since we only read one element (after having written three in all), the
320 // two-phase read should only allow us to read one. This checks an
321 // implementation detail!
322 EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
323 EXPECT_EQ(456, static_cast<const int32_t*>(read_buffer)[0]);
324 EXPECT_EQ(
325 MOJO_RESULT_OK,
326 dp->ConsumerEndReadData(static_cast<uint32_t>(1u * sizeof(elements[0]))));
327
328 // Waiting should succeed.
329 EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(1000, &context));
330 EXPECT_EQ(90u, context);
331 hss = HandleSignalsState();
332 dp->ProducerRemoveWaiter(&waiter, &hss);
333 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
334 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
335
336 // Write one element.
337 elements[0] = 123;
338 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
339 EXPECT_EQ(MOJO_RESULT_OK,
340 dp->ProducerWriteData(UserPointer<const void>(elements),
341 MakeUserPointer(&num_bytes),
342 false));
343 EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
344
345 // Add a waiter.
346 waiter.Init();
347 ASSERT_EQ(
348 MOJO_RESULT_OK,
349 dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 12, nullptr));
350
351 // Close the consumer.
352 dp->ConsumerClose();
353
354 // It should now be never-writable.
355 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, waiter.Wait(1000, &context));
356 EXPECT_EQ(12u, context);
357 hss = HandleSignalsState();
358 dp->ProducerRemoveWaiter(&waiter, &hss);
359 EXPECT_EQ(0u, hss.satisfied_signals);
360 EXPECT_EQ(0u, hss.satisfiable_signals);
361
362 dp->ProducerClose();
363 }
364
365 TEST(LocalDataPipeTest, BasicConsumerWaiting) {
366 const MojoCreateDataPipeOptions options = {
367 kSizeOfOptions, // |struct_size|.
368 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|.
369 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|.
370 1000 * sizeof(int32_t) // |capacity_num_bytes|.
371 };
372 MojoCreateDataPipeOptions validated_options = {0};
373 EXPECT_EQ(MOJO_RESULT_OK,
374 DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
375 &validated_options));
376
377 {
378 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
379 Waiter waiter;
380 uint32_t context = 0;
381 HandleSignalsState hss;
382
383 // Never writable.
384 waiter.Init();
385 hss = HandleSignalsState();
386 EXPECT_EQ(
387 MOJO_RESULT_FAILED_PRECONDITION,
388 dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 12, &hss));
389 EXPECT_EQ(0u, hss.satisfied_signals);
390 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
391
392 // Not yet readable.
393 waiter.Init();
394 ASSERT_EQ(MOJO_RESULT_OK,
395 dp->ConsumerAddWaiter(
396 &waiter, MOJO_HANDLE_SIGNAL_READABLE, 34, nullptr));
397 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
398 hss = HandleSignalsState();
399 dp->ConsumerRemoveWaiter(&waiter, &hss);
400 EXPECT_EQ(0u, hss.satisfied_signals);
401 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
402
403 // Write two elements.
404 int32_t elements[2] = {123, 456};
405 uint32_t num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
406 EXPECT_EQ(MOJO_RESULT_OK,
407 dp->ProducerWriteData(UserPointer<const void>(elements),
408 MakeUserPointer(&num_bytes),
409 true));
410
411 // Should already be readable.
412 waiter.Init();
413 hss = HandleSignalsState();
414 EXPECT_EQ(
415 MOJO_RESULT_ALREADY_EXISTS,
416 dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 56, &hss));
417 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
418 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
419
420 // Discard one element.
421 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
422 EXPECT_EQ(MOJO_RESULT_OK,
423 dp->ConsumerDiscardData(MakeUserPointer(&num_bytes), true));
424 EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
425
426 // Should still be readable.
427 waiter.Init();
428 hss = HandleSignalsState();
429 EXPECT_EQ(
430 MOJO_RESULT_ALREADY_EXISTS,
431 dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 78, &hss));
432 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
433 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
434
435 // Read one element.
436 elements[0] = -1;
437 elements[1] = -1;
438 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
439 EXPECT_EQ(
440 MOJO_RESULT_OK,
441 dp->ConsumerReadData(
442 UserPointer<void>(elements), MakeUserPointer(&num_bytes), true));
443 EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
444 EXPECT_EQ(456, elements[0]);
445 EXPECT_EQ(-1, elements[1]);
446
447 // Adding a waiter should now succeed.
448 waiter.Init();
449 ASSERT_EQ(MOJO_RESULT_OK,
450 dp->ConsumerAddWaiter(
451 &waiter, MOJO_HANDLE_SIGNAL_READABLE, 90, nullptr));
452
453 // Write one element.
454 elements[0] = 789;
455 elements[1] = -1;
456 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
457 EXPECT_EQ(MOJO_RESULT_OK,
458 dp->ProducerWriteData(UserPointer<const void>(elements),
459 MakeUserPointer(&num_bytes),
460 true));
461
462 // Waiting should now succeed.
463 EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(1000, &context));
464 EXPECT_EQ(90u, context);
465 hss = HandleSignalsState();
466 dp->ConsumerRemoveWaiter(&waiter, &hss);
467 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
468 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
469
470 // Close the producer.
471 dp->ProducerClose();
472
473 // Should still be readable.
474 waiter.Init();
475 hss = HandleSignalsState();
476 EXPECT_EQ(
477 MOJO_RESULT_ALREADY_EXISTS,
478 dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12, &hss));
479 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
480 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
481
482 // Read one element.
483 elements[0] = -1;
484 elements[1] = -1;
485 num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
486 EXPECT_EQ(
487 MOJO_RESULT_OK,
488 dp->ConsumerReadData(
489 UserPointer<void>(elements), MakeUserPointer(&num_bytes), true));
490 EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
491 EXPECT_EQ(789, elements[0]);
492 EXPECT_EQ(-1, elements[1]);
493
494 // Should be never-readable.
495 waiter.Init();
496 hss = HandleSignalsState();
497 EXPECT_EQ(
498 MOJO_RESULT_FAILED_PRECONDITION,
499 dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34, &hss));
500 EXPECT_EQ(0u, hss.satisfied_signals);
501 EXPECT_EQ(0u, hss.satisfiable_signals);
502
503 dp->ConsumerClose();
504 }
505
506 // Test with two-phase APIs and closing the producer with an active consumer
507 // waiter.
508 {
509 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
510 Waiter waiter;
511 uint32_t context = 0;
512 HandleSignalsState hss;
513
514 // Write two elements.
515 int32_t* elements = nullptr;
516 void* buffer = nullptr;
517 // Request room for three (but we'll only write two).
518 uint32_t num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0]));
519 EXPECT_EQ(MOJO_RESULT_OK,
520 dp->ProducerBeginWriteData(
521 MakeUserPointer(&buffer), MakeUserPointer(&num_bytes), true));
522 EXPECT_TRUE(buffer);
523 EXPECT_GE(num_bytes, static_cast<uint32_t>(3u * sizeof(elements[0])));
524 elements = static_cast<int32_t*>(buffer);
525 elements[0] = 123;
526 elements[1] = 456;
527 EXPECT_EQ(MOJO_RESULT_OK,
528 dp->ProducerEndWriteData(
529 static_cast<uint32_t>(2u * sizeof(elements[0]))));
530
531 // Should already be readable.
532 waiter.Init();
533 hss = HandleSignalsState();
534 EXPECT_EQ(
535 MOJO_RESULT_ALREADY_EXISTS,
536 dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12, &hss));
537 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
538 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
539
540 // Read one element.
541 // Request two in all-or-none mode, but only read one.
542 const void* read_buffer = nullptr;
543 num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
544 EXPECT_EQ(
545 MOJO_RESULT_OK,
546 dp->ConsumerBeginReadData(
547 MakeUserPointer(&read_buffer), MakeUserPointer(&num_bytes), true));
548 EXPECT_TRUE(read_buffer);
549 EXPECT_EQ(static_cast<uint32_t>(2u * sizeof(elements[0])), num_bytes);
550 const int32_t* read_elements = static_cast<const int32_t*>(read_buffer);
551 EXPECT_EQ(123, read_elements[0]);
552 EXPECT_EQ(MOJO_RESULT_OK,
553 dp->ConsumerEndReadData(
554 static_cast<uint32_t>(1u * sizeof(elements[0]))));
555
556 // Should still be readable.
557 waiter.Init();
558 hss = HandleSignalsState();
559 EXPECT_EQ(
560 MOJO_RESULT_ALREADY_EXISTS,
561 dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34, &hss));
562 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
563 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
564
565 // Read one element.
566 // Request three, but not in all-or-none mode.
567 read_buffer = nullptr;
568 num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0]));
569 EXPECT_EQ(
570 MOJO_RESULT_OK,
571 dp->ConsumerBeginReadData(
572 MakeUserPointer(&read_buffer), MakeUserPointer(&num_bytes), false));
573 EXPECT_TRUE(read_buffer);
574 EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
575 read_elements = static_cast<const int32_t*>(read_buffer);
576 EXPECT_EQ(456, read_elements[0]);
577 EXPECT_EQ(MOJO_RESULT_OK,
578 dp->ConsumerEndReadData(
579 static_cast<uint32_t>(1u * sizeof(elements[0]))));
580
581 // Adding a waiter should now succeed.
582 waiter.Init();
583 ASSERT_EQ(MOJO_RESULT_OK,
584 dp->ConsumerAddWaiter(
585 &waiter, MOJO_HANDLE_SIGNAL_READABLE, 56, nullptr));
586
587 // Close the producer.
588 dp->ProducerClose();
589
590 // Should be never-readable.
591 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, waiter.Wait(1000, &context));
592 EXPECT_EQ(56u, context);
593 hss = HandleSignalsState();
594 dp->ConsumerRemoveWaiter(&waiter, &hss);
595 EXPECT_EQ(0u, hss.satisfied_signals);
596 EXPECT_EQ(0u, hss.satisfiable_signals);
597
598 dp->ConsumerClose();
599 }
600 }
601
602 // Tests that data pipes aren't writable/readable during two-phase writes/reads.
603 TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) {
604 const MojoCreateDataPipeOptions options = {
605 kSizeOfOptions, // |struct_size|.
606 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|.
607 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|.
608 1000 * sizeof(int32_t) // |capacity_num_bytes|.
609 };
610 MojoCreateDataPipeOptions validated_options = {0};
611 EXPECT_EQ(MOJO_RESULT_OK,
612 DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
613 &validated_options));
614
615 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
616 Waiter waiter;
617 HandleSignalsState hss;
618
619 // It should be writable.
620 waiter.Init();
621 hss = HandleSignalsState();
622 EXPECT_EQ(
623 MOJO_RESULT_ALREADY_EXISTS,
624 dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss));
625 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
626 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
627
628 uint32_t num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t));
629 void* write_ptr = nullptr;
630 EXPECT_EQ(
631 MOJO_RESULT_OK,
632 dp->ProducerBeginWriteData(
633 MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
634 EXPECT_TRUE(write_ptr);
635 EXPECT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(int32_t)));
636
637 // At this point, it shouldn't be writable.
638 waiter.Init();
639 ASSERT_EQ(
640 MOJO_RESULT_OK,
641 dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 1, nullptr));
642 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
643 hss = HandleSignalsState();
644 dp->ProducerRemoveWaiter(&waiter, &hss);
645 EXPECT_EQ(0u, hss.satisfied_signals);
646 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
647
648 // It shouldn't be readable yet either.
649 waiter.Init();
650 ASSERT_EQ(
651 MOJO_RESULT_OK,
652 dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 2, nullptr));
653 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
654 hss = HandleSignalsState();
655 dp->ConsumerRemoveWaiter(&waiter, &hss);
656 EXPECT_EQ(0u, hss.satisfied_signals);
657 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
658
659 static_cast<int32_t*>(write_ptr)[0] = 123;
660 EXPECT_EQ(
661 MOJO_RESULT_OK,
662 dp->ProducerEndWriteData(static_cast<uint32_t>(1u * sizeof(int32_t))));
663
664 // It should be writable again.
665 waiter.Init();
666 hss = HandleSignalsState();
667 EXPECT_EQ(
668 MOJO_RESULT_ALREADY_EXISTS,
669 dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 3, &hss));
670 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
671 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
672
673 // And readable.
674 waiter.Init();
675 hss = HandleSignalsState();
676 EXPECT_EQ(
677 MOJO_RESULT_ALREADY_EXISTS,
678 dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 4, &hss));
679 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
680 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
681
682 // Start another two-phase write and check that it's readable even in the
683 // middle of it.
684 num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t));
685 write_ptr = nullptr;
686 EXPECT_EQ(
687 MOJO_RESULT_OK,
688 dp->ProducerBeginWriteData(
689 MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
690 EXPECT_TRUE(write_ptr);
691 EXPECT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(int32_t)));
692
693 // It should be readable.
694 waiter.Init();
695 hss = HandleSignalsState();
696 EXPECT_EQ(
697 MOJO_RESULT_ALREADY_EXISTS,
698 dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 5, &hss));
699 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
700 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
701
702 // End the two-phase write without writing anything.
703 EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(0u));
704
705 // Start a two-phase read.
706 num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t));
707 const void* read_ptr = nullptr;
708 EXPECT_EQ(
709 MOJO_RESULT_OK,
710 dp->ConsumerBeginReadData(
711 MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false));
712 EXPECT_TRUE(read_ptr);
713 EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(int32_t)), num_bytes);
714
715 // At this point, it should still be writable.
716 waiter.Init();
717 hss = HandleSignalsState();
718 EXPECT_EQ(
719 MOJO_RESULT_ALREADY_EXISTS,
720 dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 6, &hss));
721 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
722 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
723
724 // But not readable.
725 waiter.Init();
726 ASSERT_EQ(
727 MOJO_RESULT_OK,
728 dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 7, nullptr));
729 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
730 hss = HandleSignalsState();
731 dp->ConsumerRemoveWaiter(&waiter, &hss);
732 EXPECT_EQ(0u, hss.satisfied_signals);
733 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
734
735 // End the two-phase read without reading anything.
736 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(0u));
737
738 // It should be readable again.
739 waiter.Init();
740 hss = HandleSignalsState();
741 EXPECT_EQ(
742 MOJO_RESULT_ALREADY_EXISTS,
743 dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 8, &hss));
744 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
745 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
746
747 dp->ProducerClose();
748 dp->ConsumerClose();
749 }
750
751 // Test that a "may discard" data pipe is writable even when it's full.
752 TEST(LocalDataPipeTest, BasicMayDiscardWaiting) {
753 const MojoCreateDataPipeOptions options = {
754 kSizeOfOptions, // |struct_size|.
755 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD, // |flags|.
756 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|.
757 1 * sizeof(int32_t) // |capacity_num_bytes|.
758 };
759 MojoCreateDataPipeOptions validated_options = {0};
760 EXPECT_EQ(MOJO_RESULT_OK,
761 DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
762 &validated_options));
763
764 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
765 Waiter waiter;
766 HandleSignalsState hss;
767
768 // Writable.
769 waiter.Init();
770 hss = HandleSignalsState();
771 EXPECT_EQ(
772 MOJO_RESULT_ALREADY_EXISTS,
773 dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss));
774 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
775 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
776
777 // Not readable.
778 waiter.Init();
779 ASSERT_EQ(
780 MOJO_RESULT_OK,
781 dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 1, nullptr));
782 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
783 hss = HandleSignalsState();
784 dp->ConsumerRemoveWaiter(&waiter, &hss);
785 EXPECT_EQ(0u, hss.satisfied_signals);
786 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
787
788 uint32_t num_bytes = static_cast<uint32_t>(sizeof(int32_t));
789 int32_t element = 123;
790 EXPECT_EQ(MOJO_RESULT_OK,
791 dp->ProducerWriteData(UserPointer<const void>(&element),
792 MakeUserPointer(&num_bytes),
793 false));
794 EXPECT_EQ(static_cast<uint32_t>(sizeof(int32_t)), num_bytes);
795
796 // Still writable (even though it's full).
797 waiter.Init();
798 hss = HandleSignalsState();
799 EXPECT_EQ(
800 MOJO_RESULT_ALREADY_EXISTS,
801 dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 2, &hss));
802 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
803 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
804
805 // Now readable.
806 waiter.Init();
807 hss = HandleSignalsState();
808 EXPECT_EQ(
809 MOJO_RESULT_ALREADY_EXISTS,
810 dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 3, &hss));
811 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
812 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
813
814 // Overwrite that element.
815 num_bytes = static_cast<uint32_t>(sizeof(int32_t));
816 element = 456;
817 EXPECT_EQ(MOJO_RESULT_OK,
818 dp->ProducerWriteData(UserPointer<const void>(&element),
819 MakeUserPointer(&num_bytes),
820 false));
821 EXPECT_EQ(static_cast<uint32_t>(sizeof(int32_t)), num_bytes);
822
823 // Still writable.
824 waiter.Init();
825 hss = HandleSignalsState();
826 EXPECT_EQ(
827 MOJO_RESULT_ALREADY_EXISTS,
828 dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 4, &hss));
829 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
830 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
831
832 // And still readable.
833 waiter.Init();
834 hss = HandleSignalsState();
835 EXPECT_EQ(
836 MOJO_RESULT_ALREADY_EXISTS,
837 dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 5, &hss));
838 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
839 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
840
841 // Read that element.
842 num_bytes = static_cast<uint32_t>(sizeof(int32_t));
843 element = 0;
844 EXPECT_EQ(
845 MOJO_RESULT_OK,
846 dp->ConsumerReadData(
847 UserPointer<void>(&element), MakeUserPointer(&num_bytes), false));
848 EXPECT_EQ(static_cast<uint32_t>(sizeof(int32_t)), num_bytes);
849 EXPECT_EQ(456, element);
850
851 // Still writable.
852 waiter.Init();
853 hss = HandleSignalsState();
854 EXPECT_EQ(
855 MOJO_RESULT_ALREADY_EXISTS,
856 dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 6, &hss));
857 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
858 EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
859
860 // No longer readable.
861 waiter.Init();
862 ASSERT_EQ(
863 MOJO_RESULT_OK,
864 dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 7, nullptr));
865 EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
866 hss = HandleSignalsState();
867 dp->ConsumerRemoveWaiter(&waiter, &hss);
868 EXPECT_EQ(0u, hss.satisfied_signals);
869 EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
870
871 dp->ProducerClose();
872 dp->ConsumerClose();
873 }
874
875 void Seq(int32_t start, size_t count, int32_t* out) {
876 for (size_t i = 0; i < count; i++)
877 out[i] = start + static_cast<int32_t>(i);
878 }
879
880 TEST(LocalDataPipeTest, MayDiscard) {
881 const MojoCreateDataPipeOptions options = {
882 kSizeOfOptions, // |struct_size|.
883 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD, // |flags|.
884 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|.
885 10 * sizeof(int32_t) // |capacity_num_bytes|.
886 };
887 MojoCreateDataPipeOptions validated_options = {0};
888 EXPECT_EQ(MOJO_RESULT_OK,
889 DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
890 &validated_options));
891
892 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
893
894 int32_t buffer[100] = {0};
895 uint32_t num_bytes = 0;
896
897 num_bytes = 20u * sizeof(int32_t);
898 Seq(0, arraysize(buffer), buffer);
899 // Try writing more than capacity. (This test relies on the implementation
900 // enforcing the capacity strictly.)
901 EXPECT_EQ(
902 MOJO_RESULT_OK,
903 dp->ProducerWriteData(
904 UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), false));
905 EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
906
907 // Read half of what we wrote.
908 num_bytes = 5u * sizeof(int32_t);
909 memset(buffer, 0xab, sizeof(buffer));
910 EXPECT_EQ(MOJO_RESULT_OK,
911 dp->ConsumerReadData(
912 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), false));
913 EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
914 int32_t expected_buffer[100];
915 memset(expected_buffer, 0xab, sizeof(expected_buffer));
916 Seq(0, 5u, expected_buffer);
917 EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
918 // Internally, a circular buffer would now look like:
919 // -, -, -, -, -, 5, 6, 7, 8, 9
920
921 // Write a bit more than the space that's available.
922 num_bytes = 8u * sizeof(int32_t);
923 Seq(100, arraysize(buffer), buffer);
924 EXPECT_EQ(
925 MOJO_RESULT_OK,
926 dp->ProducerWriteData(
927 UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), false));
928 EXPECT_EQ(8u * sizeof(int32_t), num_bytes);
929 // Internally, a circular buffer would now look like:
930 // 100, 101, 102, 103, 104, 105, 106, 107, 8, 9
931
932 // Read half of what's available.
933 num_bytes = 5u * sizeof(int32_t);
934 memset(buffer, 0xab, sizeof(buffer));
935 EXPECT_EQ(MOJO_RESULT_OK,
936 dp->ConsumerReadData(
937 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), false));
938 EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
939 memset(expected_buffer, 0xab, sizeof(expected_buffer));
940 expected_buffer[0] = 8;
941 expected_buffer[1] = 9;
942 expected_buffer[2] = 100;
943 expected_buffer[3] = 101;
944 expected_buffer[4] = 102;
945 EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
946 // Internally, a circular buffer would now look like:
947 // -, -, -, 103, 104, 105, 106, 107, -, -
948
949 // Write one integer.
950 num_bytes = 1u * sizeof(int32_t);
951 Seq(200, arraysize(buffer), buffer);
952 EXPECT_EQ(
953 MOJO_RESULT_OK,
954 dp->ProducerWriteData(
955 UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), false));
956 EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
957 // Internally, a circular buffer would now look like:
958 // -, -, -, 103, 104, 105, 106, 107, 200, -
959
960 // Write five more.
961 num_bytes = 5u * sizeof(int32_t);
962 Seq(300, arraysize(buffer), buffer);
963 EXPECT_EQ(
964 MOJO_RESULT_OK,
965 dp->ProducerWriteData(
966 UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), false));
967 EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
968 // Internally, a circular buffer would now look like:
969 // 301, 302, 303, 304, 104, 105, 106, 107, 200, 300
970
971 // Read it all.
972 num_bytes = sizeof(buffer);
973 memset(buffer, 0xab, sizeof(buffer));
974 EXPECT_EQ(MOJO_RESULT_OK,
975 dp->ConsumerReadData(
976 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), false));
977 EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
978 memset(expected_buffer, 0xab, sizeof(expected_buffer));
979 expected_buffer[0] = 104;
980 expected_buffer[1] = 105;
981 expected_buffer[2] = 106;
982 expected_buffer[3] = 107;
983 expected_buffer[4] = 200;
984 expected_buffer[5] = 300;
985 expected_buffer[6] = 301;
986 expected_buffer[7] = 302;
987 expected_buffer[8] = 303;
988 expected_buffer[9] = 304;
989 EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
990
991 // Test two-phase writes, including in all-or-none mode.
992 // Note: Again, the following depends on an implementation detail -- namely
993 // that the write pointer will point at the 5th element of the buffer (and the
994 // buffer has exactly the capacity requested).
995
996 num_bytes = 0u;
997 void* write_ptr = nullptr;
998 EXPECT_EQ(
999 MOJO_RESULT_OK,
1000 dp->ProducerBeginWriteData(
1001 MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
1002 EXPECT_TRUE(write_ptr);
1003 EXPECT_EQ(6u * sizeof(int32_t), num_bytes);
1004 Seq(400, 6, static_cast<int32_t*>(write_ptr));
1005 EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(6u * sizeof(int32_t)));
1006 // Internally, a circular buffer would now look like:
1007 // -, -, -, -, 400, 401, 402, 403, 404, 405
1008
1009 // |ProducerBeginWriteData()| ignores |*num_bytes| except in "all-or-none"
1010 // mode.
1011 num_bytes = 6u * sizeof(int32_t);
1012 write_ptr = nullptr;
1013 EXPECT_EQ(
1014 MOJO_RESULT_OK,
1015 dp->ProducerBeginWriteData(
1016 MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
1017 EXPECT_EQ(4u * sizeof(int32_t), num_bytes);
1018 static_cast<int32_t*>(write_ptr)[0] = 500;
1019 EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(1u * sizeof(int32_t)));
1020 // Internally, a circular buffer would now look like:
1021 // 500, -, -, -, 400, 401, 402, 403, 404, 405
1022
1023 // Requesting a 10-element buffer in all-or-none mode fails at this point.
1024 num_bytes = 10u * sizeof(int32_t);
1025 write_ptr = nullptr;
1026 EXPECT_EQ(
1027 MOJO_RESULT_OUT_OF_RANGE,
1028 dp->ProducerBeginWriteData(
1029 MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
1030
1031 // But requesting, say, a 5-element (up to 9, really) buffer should be okay.
1032 // It will discard two elements.
1033 num_bytes = 5u * sizeof(int32_t);
1034 write_ptr = nullptr;
1035 EXPECT_EQ(
1036 MOJO_RESULT_OK,
1037 dp->ProducerBeginWriteData(
1038 MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
1039 EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
1040 // Only write 4 elements though.
1041 Seq(600, 4, static_cast<int32_t*>(write_ptr));
1042 EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(4u * sizeof(int32_t)));
1043 // Internally, a circular buffer would now look like:
1044 // 500, 600, 601, 602, 603, -, 402, 403, 404, 405
1045
1046 // Do this again. Make sure we can get a buffer all the way out to the end of
1047 // the internal buffer.
1048 num_bytes = 5u * sizeof(int32_t);
1049 write_ptr = nullptr;
1050 EXPECT_EQ(
1051 MOJO_RESULT_OK,
1052 dp->ProducerBeginWriteData(
1053 MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
1054 EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
1055 // Only write 3 elements though.
1056 Seq(700, 3, static_cast<int32_t*>(write_ptr));
1057 EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(3u * sizeof(int32_t)));
1058 // Internally, a circular buffer would now look like:
1059 // 500, 600, 601, 602, 603, 700, 701, 702, -, -
1060
1061 // Read everything.
1062 num_bytes = sizeof(buffer);
1063 memset(buffer, 0xab, sizeof(buffer));
1064 EXPECT_EQ(MOJO_RESULT_OK,
1065 dp->ConsumerReadData(
1066 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), false));
1067 EXPECT_EQ(8u * sizeof(int32_t), num_bytes);
1068 memset(expected_buffer, 0xab, sizeof(expected_buffer));
1069 expected_buffer[0] = 500;
1070 expected_buffer[1] = 600;
1071 expected_buffer[2] = 601;
1072 expected_buffer[3] = 602;
1073 expected_buffer[4] = 603;
1074 expected_buffer[5] = 700;
1075 expected_buffer[6] = 701;
1076 expected_buffer[7] = 702;
1077 EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
1078
1079 dp->ProducerClose();
1080 dp->ConsumerClose();
1081 }
1082
1083 TEST(LocalDataPipeTest, AllOrNone) {
1084 const MojoCreateDataPipeOptions options = {
1085 kSizeOfOptions, // |struct_size|.
1086 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|.
1087 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|.
1088 10 * sizeof(int32_t) // |capacity_num_bytes|.
1089 };
1090 MojoCreateDataPipeOptions validated_options = {0};
1091 EXPECT_EQ(MOJO_RESULT_OK,
1092 DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
1093 &validated_options));
1094
1095 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
1096
1097 // Try writing way too much.
1098 uint32_t num_bytes = 20u * sizeof(int32_t);
1099 int32_t buffer[100];
1100 Seq(0, arraysize(buffer), buffer);
1101 EXPECT_EQ(
1102 MOJO_RESULT_OUT_OF_RANGE,
1103 dp->ProducerWriteData(
1104 UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
1105
1106 // Should still be empty.
1107 num_bytes = ~0u;
1108 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1109 EXPECT_EQ(0u, num_bytes);
1110
1111 // Write some data.
1112 num_bytes = 5u * sizeof(int32_t);
1113 Seq(100, arraysize(buffer), buffer);
1114 EXPECT_EQ(
1115 MOJO_RESULT_OK,
1116 dp->ProducerWriteData(
1117 UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
1118 EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
1119
1120 // Half full.
1121 num_bytes = 0u;
1122 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1123 EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
1124
1125 // Too much.
1126 num_bytes = 6u * sizeof(int32_t);
1127 Seq(200, arraysize(buffer), buffer);
1128 EXPECT_EQ(
1129 MOJO_RESULT_OUT_OF_RANGE,
1130 dp->ProducerWriteData(
1131 UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
1132
1133 // Try reading too much.
1134 num_bytes = 11u * sizeof(int32_t);
1135 memset(buffer, 0xab, sizeof(buffer));
1136 EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
1137 dp->ConsumerReadData(
1138 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true));
1139 int32_t expected_buffer[100];
1140 memset(expected_buffer, 0xab, sizeof(expected_buffer));
1141 EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
1142
1143 // Try discarding too much.
1144 num_bytes = 11u * sizeof(int32_t);
1145 EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
1146 dp->ConsumerDiscardData(MakeUserPointer(&num_bytes), true));
1147
1148 // Just a little.
1149 num_bytes = 2u * sizeof(int32_t);
1150 Seq(300, arraysize(buffer), buffer);
1151 EXPECT_EQ(
1152 MOJO_RESULT_OK,
1153 dp->ProducerWriteData(
1154 UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
1155 EXPECT_EQ(2u * sizeof(int32_t), num_bytes);
1156
1157 // Just right.
1158 num_bytes = 3u * sizeof(int32_t);
1159 Seq(400, arraysize(buffer), buffer);
1160 EXPECT_EQ(
1161 MOJO_RESULT_OK,
1162 dp->ProducerWriteData(
1163 UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
1164 EXPECT_EQ(3u * sizeof(int32_t), num_bytes);
1165
1166 // Exactly full.
1167 num_bytes = 0u;
1168 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1169 EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
1170
1171 // Read half.
1172 num_bytes = 5u * sizeof(int32_t);
1173 memset(buffer, 0xab, sizeof(buffer));
1174 EXPECT_EQ(MOJO_RESULT_OK,
1175 dp->ConsumerReadData(
1176 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true));
1177 EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
1178 memset(expected_buffer, 0xab, sizeof(expected_buffer));
1179 Seq(100, 5, expected_buffer);
1180 EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
1181
1182 // Try reading too much again.
1183 num_bytes = 6u * sizeof(int32_t);
1184 memset(buffer, 0xab, sizeof(buffer));
1185 EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
1186 dp->ConsumerReadData(
1187 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true));
1188 memset(expected_buffer, 0xab, sizeof(expected_buffer));
1189 EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
1190
1191 // Try discarding too much again.
1192 num_bytes = 6u * sizeof(int32_t);
1193 EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
1194 dp->ConsumerDiscardData(MakeUserPointer(&num_bytes), true));
1195
1196 // Discard a little.
1197 num_bytes = 2u * sizeof(int32_t);
1198 EXPECT_EQ(MOJO_RESULT_OK,
1199 dp->ConsumerDiscardData(MakeUserPointer(&num_bytes), true));
1200 EXPECT_EQ(2u * sizeof(int32_t), num_bytes);
1201
1202 // Three left.
1203 num_bytes = 0u;
1204 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1205 EXPECT_EQ(3u * sizeof(int32_t), num_bytes);
1206
1207 // Close the producer, then test producer-closed cases.
1208 dp->ProducerClose();
1209
1210 // Try reading too much; "failed precondition" since the producer is closed.
1211 num_bytes = 4u * sizeof(int32_t);
1212 memset(buffer, 0xab, sizeof(buffer));
1213 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
1214 dp->ConsumerReadData(
1215 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true));
1216 memset(expected_buffer, 0xab, sizeof(expected_buffer));
1217 EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
1218
1219 // Try discarding too much; "failed precondition" again.
1220 num_bytes = 4u * sizeof(int32_t);
1221 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
1222 dp->ConsumerDiscardData(MakeUserPointer(&num_bytes), true));
1223
1224 // Read a little.
1225 num_bytes = 2u * sizeof(int32_t);
1226 memset(buffer, 0xab, sizeof(buffer));
1227 EXPECT_EQ(MOJO_RESULT_OK,
1228 dp->ConsumerReadData(
1229 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true));
1230 EXPECT_EQ(2u * sizeof(int32_t), num_bytes);
1231 memset(expected_buffer, 0xab, sizeof(expected_buffer));
1232 Seq(400, 2, expected_buffer);
1233 EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
1234
1235 // Discard the remaining element.
1236 num_bytes = 1u * sizeof(int32_t);
1237 EXPECT_EQ(MOJO_RESULT_OK,
1238 dp->ConsumerDiscardData(MakeUserPointer(&num_bytes), true));
1239 EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
1240
1241 // Empty again.
1242 num_bytes = ~0u;
1243 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1244 EXPECT_EQ(0u, num_bytes);
1245
1246 dp->ConsumerClose();
1247 }
1248
1249 TEST(LocalDataPipeTest, AllOrNoneMayDiscard) {
1250 const MojoCreateDataPipeOptions options = {
1251 kSizeOfOptions, // |struct_size|.
1252 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD, // |flags|.
1253 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|.
1254 10 * sizeof(int32_t) // |capacity_num_bytes|.
1255 };
1256 MojoCreateDataPipeOptions validated_options = {0};
1257 EXPECT_EQ(MOJO_RESULT_OK,
1258 DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
1259 &validated_options));
1260
1261 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
1262
1263 // Try writing way too much.
1264 uint32_t num_bytes = 20u * sizeof(int32_t);
1265 int32_t buffer[100];
1266 Seq(0, arraysize(buffer), buffer);
1267 EXPECT_EQ(
1268 MOJO_RESULT_OUT_OF_RANGE,
1269 dp->ProducerWriteData(
1270 UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
1271
1272 // Write some stuff.
1273 num_bytes = 5u * sizeof(int32_t);
1274 Seq(100, arraysize(buffer), buffer);
1275 EXPECT_EQ(
1276 MOJO_RESULT_OK,
1277 dp->ProducerWriteData(
1278 UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
1279 EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
1280
1281 // Write lots of stuff (discarding all but "104").
1282 num_bytes = 9u * sizeof(int32_t);
1283 Seq(200, arraysize(buffer), buffer);
1284 EXPECT_EQ(
1285 MOJO_RESULT_OK,
1286 dp->ProducerWriteData(
1287 UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
1288 EXPECT_EQ(9u * sizeof(int32_t), num_bytes);
1289
1290 // Read one.
1291 num_bytes = 1u * sizeof(int32_t);
1292 memset(buffer, 0xab, sizeof(buffer));
1293 EXPECT_EQ(MOJO_RESULT_OK,
1294 dp->ConsumerReadData(
1295 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true));
1296 EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
1297 int32_t expected_buffer[100];
1298 memset(expected_buffer, 0xab, sizeof(expected_buffer));
1299 expected_buffer[0] = 104;
1300 EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
1301
1302 // Try reading too many.
1303 num_bytes = 10u * sizeof(int32_t);
1304 memset(buffer, 0xab, sizeof(buffer));
1305 EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
1306 dp->ConsumerReadData(
1307 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true));
1308 memset(expected_buffer, 0xab, sizeof(expected_buffer));
1309 EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
1310
1311 // Try discarding too many.
1312 num_bytes = 10u * sizeof(int32_t);
1313 EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
1314 dp->ConsumerDiscardData(MakeUserPointer(&num_bytes), true));
1315
1316 // Discard a bunch.
1317 num_bytes = 4u * sizeof(int32_t);
1318 EXPECT_EQ(MOJO_RESULT_OK,
1319 dp->ConsumerDiscardData(MakeUserPointer(&num_bytes), true));
1320
1321 // Half full.
1322 num_bytes = 0u;
1323 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1324 EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
1325
1326 // Write as much as possible.
1327 num_bytes = 10u * sizeof(int32_t);
1328 Seq(300, arraysize(buffer), buffer);
1329 EXPECT_EQ(
1330 MOJO_RESULT_OK,
1331 dp->ProducerWriteData(
1332 UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
1333 EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
1334
1335 // Read everything.
1336 num_bytes = 10u * sizeof(int32_t);
1337 memset(buffer, 0xab, sizeof(buffer));
1338 EXPECT_EQ(MOJO_RESULT_OK,
1339 dp->ConsumerReadData(
1340 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true));
1341 memset(expected_buffer, 0xab, sizeof(expected_buffer));
1342 EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
1343 Seq(300, 10, expected_buffer);
1344 EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
1345
1346 // Note: All-or-none two-phase writes on a "may discard" data pipe are tested
1347 // in LocalDataPipeTest.MayDiscard.
1348
1349 dp->ProducerClose();
1350 dp->ConsumerClose();
1351 }
1352
1353 TEST(LocalDataPipeTest, TwoPhaseAllOrNone) {
1354 const MojoCreateDataPipeOptions options = {
1355 kSizeOfOptions, // |struct_size|.
1356 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|.
1357 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|.
1358 10 * sizeof(int32_t) // |capacity_num_bytes|.
1359 };
1360 MojoCreateDataPipeOptions validated_options = {0};
1361 EXPECT_EQ(MOJO_RESULT_OK,
1362 DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
1363 &validated_options));
1364
1365 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
1366
1367 // Try writing way too much (two-phase).
1368 uint32_t num_bytes = 20u * sizeof(int32_t);
1369 void* write_ptr = nullptr;
1370 EXPECT_EQ(
1371 MOJO_RESULT_OUT_OF_RANGE,
1372 dp->ProducerBeginWriteData(
1373 MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
1374
1375 // Try writing an amount which isn't a multiple of the element size
1376 // (two-phase).
1377 static_assert(sizeof(int32_t) > 1u, "Wow! int32_t's have size 1");
1378 num_bytes = 1u;
1379 write_ptr = nullptr;
1380 EXPECT_EQ(
1381 MOJO_RESULT_INVALID_ARGUMENT,
1382 dp->ProducerBeginWriteData(
1383 MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
1384
1385 // Try reading way too much (two-phase).
1386 num_bytes = 20u * sizeof(int32_t);
1387 const void* read_ptr = nullptr;
1388 EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
1389 dp->ConsumerBeginReadData(
1390 MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
1391
1392 // Write half (two-phase).
1393 num_bytes = 5u * sizeof(int32_t);
1394 write_ptr = nullptr;
1395 EXPECT_EQ(
1396 MOJO_RESULT_OK,
1397 dp->ProducerBeginWriteData(
1398 MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
1399 // May provide more space than requested.
1400 EXPECT_GE(num_bytes, 5u * sizeof(int32_t));
1401 EXPECT_TRUE(write_ptr);
1402 Seq(0, 5, static_cast<int32_t*>(write_ptr));
1403 EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(5u * sizeof(int32_t)));
1404
1405 // Try reading an amount which isn't a multiple of the element size
1406 // (two-phase).
1407 num_bytes = 1u;
1408 read_ptr = nullptr;
1409 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
1410 dp->ConsumerBeginReadData(
1411 MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
1412
1413 // Read one (two-phase).
1414 num_bytes = 1u * sizeof(int32_t);
1415 read_ptr = nullptr;
1416 EXPECT_EQ(MOJO_RESULT_OK,
1417 dp->ConsumerBeginReadData(
1418 MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
1419 EXPECT_GE(num_bytes, 1u * sizeof(int32_t));
1420 EXPECT_EQ(0, static_cast<const int32_t*>(read_ptr)[0]);
1421 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(1u * sizeof(int32_t)));
1422
1423 // We should have four left, leaving room for six.
1424 num_bytes = 0u;
1425 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1426 EXPECT_EQ(4u * sizeof(int32_t), num_bytes);
1427
1428 // Assuming a tight circular buffer of the specified capacity, we can't do a
1429 // two-phase write of six now.
1430 num_bytes = 6u * sizeof(int32_t);
1431 write_ptr = nullptr;
1432 EXPECT_EQ(
1433 MOJO_RESULT_OUT_OF_RANGE,
1434 dp->ProducerBeginWriteData(
1435 MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
1436
1437 // Write six elements (simple), filling the buffer.
1438 num_bytes = 6u * sizeof(int32_t);
1439 int32_t buffer[100];
1440 Seq(100, 6, buffer);
1441 EXPECT_EQ(
1442 MOJO_RESULT_OK,
1443 dp->ProducerWriteData(
1444 UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
1445 EXPECT_EQ(6u * sizeof(int32_t), num_bytes);
1446
1447 // We have ten.
1448 num_bytes = 0u;
1449 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1450 EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
1451
1452 // But a two-phase read of ten should fail.
1453 num_bytes = 10u * sizeof(int32_t);
1454 read_ptr = nullptr;
1455 EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
1456 dp->ConsumerBeginReadData(
1457 MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
1458
1459 // Close the producer.
1460 dp->ProducerClose();
1461
1462 // A two-phase read of nine should work.
1463 num_bytes = 9u * sizeof(int32_t);
1464 read_ptr = nullptr;
1465 EXPECT_EQ(MOJO_RESULT_OK,
1466 dp->ConsumerBeginReadData(
1467 MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
1468 EXPECT_GE(num_bytes, 9u * sizeof(int32_t));
1469 EXPECT_EQ(1, static_cast<const int32_t*>(read_ptr)[0]);
1470 EXPECT_EQ(2, static_cast<const int32_t*>(read_ptr)[1]);
1471 EXPECT_EQ(3, static_cast<const int32_t*>(read_ptr)[2]);
1472 EXPECT_EQ(4, static_cast<const int32_t*>(read_ptr)[3]);
1473 EXPECT_EQ(100, static_cast<const int32_t*>(read_ptr)[4]);
1474 EXPECT_EQ(101, static_cast<const int32_t*>(read_ptr)[5]);
1475 EXPECT_EQ(102, static_cast<const int32_t*>(read_ptr)[6]);
1476 EXPECT_EQ(103, static_cast<const int32_t*>(read_ptr)[7]);
1477 EXPECT_EQ(104, static_cast<const int32_t*>(read_ptr)[8]);
1478 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(9u * sizeof(int32_t)));
1479
1480 // A two-phase read of two should fail, with "failed precondition".
1481 num_bytes = 2u * sizeof(int32_t);
1482 read_ptr = nullptr;
1483 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
1484 dp->ConsumerBeginReadData(
1485 MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
1486
1487 dp->ConsumerClose();
1488 }
1489
1490 // Tests that |ProducerWriteData()| and |ConsumerReadData()| writes and reads,
1491 // respectively, as much as possible, even if it has to "wrap around" the
1492 // internal circular buffer. (Note that the two-phase write and read do not do
1493 // this.)
1494 TEST(LocalDataPipeTest, WrapAround) {
1495 unsigned char test_data[1000];
1496 for (size_t i = 0; i < arraysize(test_data); i++)
1497 test_data[i] = static_cast<unsigned char>(i);
1498
1499 const MojoCreateDataPipeOptions options = {
1500 kSizeOfOptions, // |struct_size|.
1501 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|.
1502 1u, // |element_num_bytes|.
1503 100u // |capacity_num_bytes|.
1504 };
1505 MojoCreateDataPipeOptions validated_options = {0};
1506 EXPECT_EQ(MOJO_RESULT_OK,
1507 DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
1508 &validated_options));
1509 // This test won't be valid if |ValidateCreateOptions()| decides to give the
1510 // pipe more space.
1511 ASSERT_EQ(100u, validated_options.capacity_num_bytes);
1512
1513 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
1514
1515 // Write 20 bytes.
1516 uint32_t num_bytes = 20u;
1517 EXPECT_EQ(MOJO_RESULT_OK,
1518 dp->ProducerWriteData(UserPointer<const void>(&test_data[0]),
1519 MakeUserPointer(&num_bytes),
1520 false));
1521 EXPECT_EQ(20u, num_bytes);
1522
1523 // Read 10 bytes.
1524 unsigned char read_buffer[1000] = {0};
1525 num_bytes = 10u;
1526 EXPECT_EQ(
1527 MOJO_RESULT_OK,
1528 dp->ConsumerReadData(
1529 UserPointer<void>(read_buffer), MakeUserPointer(&num_bytes), false));
1530 EXPECT_EQ(10u, num_bytes);
1531 EXPECT_EQ(0, memcmp(read_buffer, &test_data[0], 10u));
1532
1533 // Check that a two-phase write can now only write (at most) 80 bytes. (This
1534 // checks an implementation detail; this behavior is not guaranteed, but we
1535 // need it for this test.)
1536 void* write_buffer_ptr = nullptr;
1537 num_bytes = 0u;
1538 EXPECT_EQ(MOJO_RESULT_OK,
1539 dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
1540 MakeUserPointer(&num_bytes),
1541 false));
1542 EXPECT_TRUE(write_buffer_ptr);
1543 EXPECT_EQ(80u, num_bytes);
1544 EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(0u));
1545
1546 // Write as much data as we can (using |ProducerWriteData()|). We should write
1547 // 90 bytes.
1548 num_bytes = 200u;
1549 EXPECT_EQ(MOJO_RESULT_OK,
1550 dp->ProducerWriteData(UserPointer<const void>(&test_data[20]),
1551 MakeUserPointer(&num_bytes),
1552 false));
1553 EXPECT_EQ(90u, num_bytes);
1554
1555 // Check that a two-phase read can now only read (at most) 90 bytes. (This
1556 // checks an implementation detail; this behavior is not guaranteed, but we
1557 // need it for this test.)
1558 const void* read_buffer_ptr = nullptr;
1559 num_bytes = 0u;
1560 EXPECT_EQ(MOJO_RESULT_OK,
1561 dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
1562 MakeUserPointer(&num_bytes),
1563 false));
1564 EXPECT_TRUE(read_buffer_ptr);
1565 EXPECT_EQ(90u, num_bytes);
1566 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(0u));
1567
1568 // Read as much as possible (using |ConsumerReadData()|). We should read 100
1569 // bytes.
1570 num_bytes =
1571 static_cast<uint32_t>(arraysize(read_buffer) * sizeof(read_buffer[0]));
1572 memset(read_buffer, 0, num_bytes);
1573 EXPECT_EQ(
1574 MOJO_RESULT_OK,
1575 dp->ConsumerReadData(
1576 UserPointer<void>(read_buffer), MakeUserPointer(&num_bytes), false));
1577 EXPECT_EQ(100u, num_bytes);
1578 EXPECT_EQ(0, memcmp(read_buffer, &test_data[10], 100u));
1579
1580 dp->ProducerClose();
1581 dp->ConsumerClose();
1582 }
1583
1584 // Tests the behavior of closing the producer or consumer with respect to
1585 // writes and reads (simple and two-phase).
1586 TEST(LocalDataPipeTest, CloseWriteRead) {
1587 const char kTestData[] = "hello world";
1588 const uint32_t kTestDataSize = static_cast<uint32_t>(sizeof(kTestData));
1589
1590 const MojoCreateDataPipeOptions options = {
1591 kSizeOfOptions, // |struct_size|.
1592 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|.
1593 1u, // |element_num_bytes|.
1594 1000u // |capacity_num_bytes|.
1595 };
1596 MojoCreateDataPipeOptions validated_options = {0};
1597 EXPECT_EQ(MOJO_RESULT_OK,
1598 DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
1599 &validated_options));
1600
1601 // Close producer first, then consumer.
1602 {
1603 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
1604
1605 // Write some data, so we'll have something to read.
1606 uint32_t num_bytes = kTestDataSize;
1607 EXPECT_EQ(MOJO_RESULT_OK,
1608 dp->ProducerWriteData(UserPointer<const void>(kTestData),
1609 MakeUserPointer(&num_bytes),
1610 false));
1611 EXPECT_EQ(kTestDataSize, num_bytes);
1612
1613 // Write it again, so we'll have something left over.
1614 num_bytes = kTestDataSize;
1615 EXPECT_EQ(MOJO_RESULT_OK,
1616 dp->ProducerWriteData(UserPointer<const void>(kTestData),
1617 MakeUserPointer(&num_bytes),
1618 false));
1619 EXPECT_EQ(kTestDataSize, num_bytes);
1620
1621 // Start two-phase write.
1622 void* write_buffer_ptr = nullptr;
1623 num_bytes = 0u;
1624 EXPECT_EQ(MOJO_RESULT_OK,
1625 dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
1626 MakeUserPointer(&num_bytes),
1627 false));
1628 EXPECT_TRUE(write_buffer_ptr);
1629 EXPECT_GT(num_bytes, 0u);
1630
1631 // Start two-phase read.
1632 const void* read_buffer_ptr = nullptr;
1633 num_bytes = 0u;
1634 EXPECT_EQ(MOJO_RESULT_OK,
1635 dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
1636 MakeUserPointer(&num_bytes),
1637 false));
1638 EXPECT_TRUE(read_buffer_ptr);
1639 EXPECT_EQ(2u * kTestDataSize, num_bytes);
1640
1641 // Close the producer.
1642 dp->ProducerClose();
1643
1644 // The consumer can finish its two-phase read.
1645 EXPECT_EQ(0, memcmp(read_buffer_ptr, kTestData, kTestDataSize));
1646 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(kTestDataSize));
1647
1648 // And start another.
1649 read_buffer_ptr = nullptr;
1650 num_bytes = 0u;
1651 EXPECT_EQ(MOJO_RESULT_OK,
1652 dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
1653 MakeUserPointer(&num_bytes),
1654 false));
1655 EXPECT_TRUE(read_buffer_ptr);
1656 EXPECT_EQ(kTestDataSize, num_bytes);
1657
1658 // Close the consumer, which cancels the two-phase read.
1659 dp->ConsumerClose();
1660 }
1661
1662 // Close consumer first, then producer.
1663 {
1664 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
1665
1666 // Write some data, so we'll have something to read.
1667 uint32_t num_bytes = kTestDataSize;
1668 EXPECT_EQ(MOJO_RESULT_OK,
1669 dp->ProducerWriteData(UserPointer<const void>(kTestData),
1670 MakeUserPointer(&num_bytes),
1671 false));
1672 EXPECT_EQ(kTestDataSize, num_bytes);
1673
1674 // Start two-phase write.
1675 void* write_buffer_ptr = nullptr;
1676 num_bytes = 0u;
1677 EXPECT_EQ(MOJO_RESULT_OK,
1678 dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
1679 MakeUserPointer(&num_bytes),
1680 false));
1681 EXPECT_TRUE(write_buffer_ptr);
1682 ASSERT_GT(num_bytes, kTestDataSize);
1683
1684 // Start two-phase read.
1685 const void* read_buffer_ptr = nullptr;
1686 num_bytes = 0u;
1687 EXPECT_EQ(MOJO_RESULT_OK,
1688 dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
1689 MakeUserPointer(&num_bytes),
1690 false));
1691 EXPECT_TRUE(read_buffer_ptr);
1692 EXPECT_EQ(kTestDataSize, num_bytes);
1693
1694 // Close the consumer.
1695 dp->ConsumerClose();
1696
1697 // Actually write some data. (Note: Premature freeing of the buffer would
1698 // probably only be detected under ASAN or similar.)
1699 memcpy(write_buffer_ptr, kTestData, kTestDataSize);
1700 // Note: Even though the consumer has been closed, ending the two-phase
1701 // write will report success.
1702 EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(kTestDataSize));
1703
1704 // But trying to write should result in failure.
1705 num_bytes = kTestDataSize;
1706 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
1707 dp->ProducerWriteData(UserPointer<const void>(kTestData),
1708 MakeUserPointer(&num_bytes),
1709 false));
1710
1711 // As will trying to start another two-phase write.
1712 write_buffer_ptr = nullptr;
1713 num_bytes = 0u;
1714 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
1715 dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
1716 MakeUserPointer(&num_bytes),
1717 false));
1718
1719 dp->ProducerClose();
1720 }
1721
1722 // Test closing the consumer first, then the producer, with an active
1723 // two-phase write.
1724 {
1725 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
1726
1727 // Start two-phase write.
1728 void* write_buffer_ptr = nullptr;
1729 uint32_t num_bytes = 0u;
1730 EXPECT_EQ(MOJO_RESULT_OK,
1731 dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
1732 MakeUserPointer(&num_bytes),
1733 false));
1734 EXPECT_TRUE(write_buffer_ptr);
1735 ASSERT_GT(num_bytes, kTestDataSize);
1736
1737 dp->ConsumerClose();
1738 dp->ProducerClose();
1739 }
1740
1741 // Test closing the producer and then trying to read (with no data).
1742 {
1743 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
1744
1745 // Write some data, so we'll have something to read.
1746 uint32_t num_bytes = kTestDataSize;
1747 EXPECT_EQ(MOJO_RESULT_OK,
1748 dp->ProducerWriteData(UserPointer<const void>(kTestData),
1749 MakeUserPointer(&num_bytes),
1750 false));
1751 EXPECT_EQ(kTestDataSize, num_bytes);
1752
1753 // Close the producer.
1754 dp->ProducerClose();
1755
1756 // Read that data.
1757 char buffer[1000];
1758 num_bytes = static_cast<uint32_t>(sizeof(buffer));
1759 EXPECT_EQ(
1760 MOJO_RESULT_OK,
1761 dp->ConsumerReadData(
1762 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), false));
1763 EXPECT_EQ(kTestDataSize, num_bytes);
1764 EXPECT_EQ(0, memcmp(buffer, kTestData, kTestDataSize));
1765
1766 // A second read should fail.
1767 num_bytes = static_cast<uint32_t>(sizeof(buffer));
1768 EXPECT_EQ(
1769 MOJO_RESULT_FAILED_PRECONDITION,
1770 dp->ConsumerReadData(
1771 UserPointer<void>(buffer), MakeUserPointer(&num_bytes), false));
1772
1773 // A two-phase read should also fail.
1774 const void* read_buffer_ptr = nullptr;
1775 num_bytes = 0u;
1776 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
1777 dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
1778 MakeUserPointer(&num_bytes),
1779 false));
1780
1781 // Ditto for discard.
1782 num_bytes = 10u;
1783 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
1784 dp->ConsumerDiscardData(MakeUserPointer(&num_bytes), false));
1785
1786 dp->ConsumerClose();
1787 }
1788 }
1789
1790 TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) {
1791 const MojoCreateDataPipeOptions options = {
1792 kSizeOfOptions, // |struct_size|.
1793 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|.
1794 static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|.
1795 10 * sizeof(int32_t) // |capacity_num_bytes|.
1796 };
1797 MojoCreateDataPipeOptions validated_options = {0};
1798 EXPECT_EQ(MOJO_RESULT_OK,
1799 DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
1800 &validated_options));
1801
1802 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
1803
1804 // No data.
1805 uint32_t num_bytes = 1000u;
1806 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1807 EXPECT_EQ(0u, num_bytes);
1808
1809 // Try "ending" a two-phase write when one isn't active.
1810 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
1811 dp->ProducerEndWriteData(1u * sizeof(int32_t)));
1812
1813 // Still no data.
1814 num_bytes = 1000u;
1815 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1816 EXPECT_EQ(0u, num_bytes);
1817
1818 // Try ending a two-phase write with an invalid amount (too much).
1819 num_bytes = 0u;
1820 void* write_ptr = nullptr;
1821 EXPECT_EQ(
1822 MOJO_RESULT_OK,
1823 dp->ProducerBeginWriteData(
1824 MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
1825 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
1826 dp->ProducerEndWriteData(num_bytes +
1827 static_cast<uint32_t>(sizeof(int32_t))));
1828
1829 // But the two-phase write still ended.
1830 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, dp->ProducerEndWriteData(0u));
1831
1832 // Still no data.
1833 num_bytes = 1000u;
1834 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1835 EXPECT_EQ(0u, num_bytes);
1836
1837 // Try ending a two-phase write with an invalid amount (not a multiple of the
1838 // element size).
1839 num_bytes = 0u;
1840 write_ptr = nullptr;
1841 EXPECT_EQ(
1842 MOJO_RESULT_OK,
1843 dp->ProducerBeginWriteData(
1844 MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
1845 EXPECT_GE(num_bytes, 1u);
1846 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dp->ProducerEndWriteData(1u));
1847
1848 // But the two-phase write still ended.
1849 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, dp->ProducerEndWriteData(0u));
1850
1851 // Still no data.
1852 num_bytes = 1000u;
1853 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1854 EXPECT_EQ(0u, num_bytes);
1855
1856 // Now write some data, so we'll be able to try reading.
1857 int32_t element = 123;
1858 num_bytes = 1u * sizeof(int32_t);
1859 EXPECT_EQ(MOJO_RESULT_OK,
1860 dp->ProducerWriteData(UserPointer<const void>(&element),
1861 MakeUserPointer(&num_bytes),
1862 false));
1863
1864 // One element available.
1865 num_bytes = 0u;
1866 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1867 EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
1868
1869 // Try "ending" a two-phase read when one isn't active.
1870 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
1871 dp->ConsumerEndReadData(1u * sizeof(int32_t)));
1872
1873 // Still one element available.
1874 num_bytes = 0u;
1875 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1876 EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
1877
1878 // Try ending a two-phase read with an invalid amount (too much).
1879 num_bytes = 0u;
1880 const void* read_ptr = nullptr;
1881 EXPECT_EQ(
1882 MOJO_RESULT_OK,
1883 dp->ConsumerBeginReadData(
1884 MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false));
1885 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
1886 dp->ConsumerEndReadData(num_bytes +
1887 static_cast<uint32_t>(sizeof(int32_t))));
1888
1889 // Still one element available.
1890 num_bytes = 0u;
1891 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1892 EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
1893
1894 // Try ending a two-phase read with an invalid amount (not a multiple of the
1895 // element size).
1896 num_bytes = 0u;
1897 read_ptr = nullptr;
1898 EXPECT_EQ(
1899 MOJO_RESULT_OK,
1900 dp->ConsumerBeginReadData(
1901 MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false));
1902 EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
1903 EXPECT_EQ(123, static_cast<const int32_t*>(read_ptr)[0]);
1904 EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dp->ConsumerEndReadData(1u));
1905
1906 // Still one element available.
1907 num_bytes = 0u;
1908 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerQueryData(MakeUserPointer(&num_bytes)));
1909 EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
1910
1911 dp->ProducerClose();
1912 dp->ConsumerClose();
1913 }
1914
1915 // Tests that even with "may discard", the data won't change under a two-phase
1916 // read.
1917 // TODO(vtl): crbug.com/348644: We currently don't pass this. (There are two
1918 // related issues: First, we don't recognize that the data given to
1919 // |ConsumerBeginReadData()| isn't discardable until |ConsumerEndReadData()|,
1920 // and thus we erroneously allow |ProducerWriteData()| to succeed. Second, the
1921 // |ProducerWriteData()| then changes the data underneath the two-phase read.)
1922 TEST(LocalDataPipeTest, DISABLED_MayDiscardTwoPhaseConsistent) {
1923 const MojoCreateDataPipeOptions options = {
1924 kSizeOfOptions, // |struct_size|.
1925 MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD, // |flags|.
1926 1, // |element_num_bytes|.
1927 2 // |capacity_num_bytes|.
1928 };
1929 MojoCreateDataPipeOptions validated_options = {0};
1930 EXPECT_EQ(MOJO_RESULT_OK,
1931 DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
1932 &validated_options));
1933
1934 scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
1935
1936 // Write some elements.
1937 char elements[2] = {'a', 'b'};
1938 uint32_t num_bytes = 2u;
1939 EXPECT_EQ(MOJO_RESULT_OK,
1940 dp->ProducerWriteData(UserPointer<const void>(elements),
1941 MakeUserPointer(&num_bytes),
1942 false));
1943 EXPECT_EQ(2u, num_bytes);
1944
1945 // Begin reading.
1946 const void* read_ptr = nullptr;
1947 num_bytes = 2u;
1948 EXPECT_EQ(
1949 MOJO_RESULT_OK,
1950 dp->ConsumerBeginReadData(
1951 MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false));
1952 EXPECT_EQ(2u, num_bytes);
1953 EXPECT_EQ('a', static_cast<const char*>(read_ptr)[0]);
1954 EXPECT_EQ('b', static_cast<const char*>(read_ptr)[1]);
1955
1956 // Try to write some more. But nothing should be discardable right now.
1957 elements[0] = 'x';
1958 elements[1] = 'y';
1959 num_bytes = 2u;
1960 // TODO(vtl): This should be:
1961 // EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
1962 // dp->ProducerWriteData(elements, &num_bytes, false));
1963 // but we incorrectly think that the bytes being read are discardable. Letting
1964 // this through reveals the significant consequence.
1965 EXPECT_EQ(MOJO_RESULT_OK,
1966 dp->ProducerWriteData(UserPointer<const void>(elements),
1967 MakeUserPointer(&num_bytes),
1968 false));
1969
1970 // Check that our read buffer hasn't changed underneath us.
1971 EXPECT_EQ('a', static_cast<const char*>(read_ptr)[0]);
1972 EXPECT_EQ('b', static_cast<const char*>(read_ptr)[1]);
1973
1974 // End reading.
1975 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(2u));
1976
1977 // Now writing should succeed.
1978 EXPECT_EQ(MOJO_RESULT_OK,
1979 dp->ProducerWriteData(UserPointer<const void>(elements),
1980 MakeUserPointer(&num_bytes),
1981 false));
1982
1983 // And if we read, we should get the new values.
1984 read_ptr = nullptr;
1985 num_bytes = 2u;
1986 EXPECT_EQ(
1987 MOJO_RESULT_OK,
1988 dp->ConsumerBeginReadData(
1989 MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false));
1990 EXPECT_EQ(2u, num_bytes);
1991 EXPECT_EQ('x', static_cast<const char*>(read_ptr)[0]);
1992 EXPECT_EQ('y', static_cast<const char*>(read_ptr)[1]);
1993
1994 // End reading.
1995 EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(2u));
1996
1997 dp->ProducerClose();
1998 dp->ConsumerClose();
1999 }
2000
2001 } // namespace
2002 } // namespace system
2003 } // namespace mojo