xref: /spdk/test/unit/lib/util/pipe.c/pipe_ut.c (revision 83ba9086796471697a4975a58f60e2392bccd08c) 
1 /*   SPDX-License-Identifier: BSD-3-Clause
2  *   Copyright (C) 2019 Intel Corporation.
3  *   All rights reserved.
4  */
5 
6 #include "spdk/stdinc.h"
7 
8 #include "spdk_internal/cunit.h"
9 
10 #include "util/pipe.c"
11 #include "common/lib/test_env.c"
12 
13 static void
14 test_create_destroy(void)
15 {
16 	struct spdk_pipe *pipe;
17 	uint8_t mem[10];
18 
19 	pipe = spdk_pipe_create(mem, sizeof(mem));
20 	SPDK_CU_ASSERT_FATAL(pipe != NULL);
21 
22 	spdk_pipe_destroy(pipe);
23 }
24 
25 static void
26 test_write_get_buffer(void)
27 {
28 	struct spdk_pipe *pipe;
29 	uint8_t mem[10];
30 	struct iovec iovs[2];
31 	int rc;
32 
33 	pipe = spdk_pipe_create(mem, sizeof(mem));
34 	SPDK_CU_ASSERT_FATAL(pipe != NULL);
35 
36 	/* Get some available memory. */
37 	rc = spdk_pipe_writer_get_buffer(pipe, 5, iovs);
38 	CU_ASSERT(rc == 5);
39 	CU_ASSERT(iovs[0].iov_base == mem);
40 	CU_ASSERT(iovs[0].iov_len == 5);
41 	CU_ASSERT(iovs[1].iov_base == NULL);
42 	CU_ASSERT(iovs[1].iov_len == 0);
43 	CU_ASSERT(pipe->write == 0);
44 	CU_ASSERT(pipe->read == 0);
45 
46 	memset(iovs, 0, sizeof(iovs));
47 
48 	/* Get 0 bytes. */
49 	rc = spdk_pipe_writer_get_buffer(pipe, 0, iovs);
50 	CU_ASSERT(rc == 0);
51 	CU_ASSERT(iovs[0].iov_base == NULL);
52 	CU_ASSERT(iovs[0].iov_len == 0);
53 	CU_ASSERT(iovs[1].iov_base == NULL);
54 	CU_ASSERT(iovs[1].iov_len == 0);
55 	CU_ASSERT(pipe->write == 0);
56 	CU_ASSERT(pipe->read == 0);
57 
58 	memset(iovs, 0, sizeof(iovs));
59 
60 	/* Get all available memory */
61 	rc = spdk_pipe_writer_get_buffer(pipe, 10, iovs);
62 	CU_ASSERT(rc == 10);
63 	CU_ASSERT(iovs[0].iov_base == mem);
64 	CU_ASSERT(iovs[0].iov_len == 10);
65 	CU_ASSERT(iovs[1].iov_base == NULL);
66 	CU_ASSERT(iovs[1].iov_len == 0);
67 	CU_ASSERT(pipe->write == 0);
68 	CU_ASSERT(pipe->read == 0);
69 
70 	memset(iovs, 0, sizeof(iovs));
71 
72 	/* Advance the write pointer 7 bytes in. */
73 	pipe->write = 7;
74 
75 	/* Get all of the available memory. */
76 	rc = spdk_pipe_writer_get_buffer(pipe, 3, iovs);
77 	CU_ASSERT(rc == 3);
78 	CU_ASSERT(iovs[0].iov_base == (mem + 7));
79 	CU_ASSERT(iovs[0].iov_len == 3);
80 	CU_ASSERT(iovs[1].iov_base == NULL);
81 	CU_ASSERT(iovs[1].iov_len == 0);
82 	CU_ASSERT(pipe->write == 7);
83 	CU_ASSERT(pipe->read == 0);
84 
85 	memset(iovs, 0, sizeof(iovs));
86 
87 	/* Get more than the available memory */
88 	rc = spdk_pipe_writer_get_buffer(pipe, 4, iovs);
89 	CU_ASSERT(rc == 3);
90 	CU_ASSERT(iovs[0].iov_base == (mem + 7));
91 	CU_ASSERT(iovs[0].iov_len == 3);
92 	CU_ASSERT(iovs[1].iov_base == NULL);
93 	CU_ASSERT(iovs[1].iov_len == 0);
94 	CU_ASSERT(pipe->write == 7);
95 	CU_ASSERT(pipe->read == 0);
96 
97 	memset(iovs, 0, sizeof(iovs));
98 
99 	/* Advance the read pointer 3 bytes in. */
100 	pipe->read = 3;
101 
102 	/* Get all of the available memory. */
103 	rc = spdk_pipe_writer_get_buffer(pipe, 6, iovs);
104 	CU_ASSERT(rc == 6);
105 	CU_ASSERT(iovs[0].iov_base == (mem + 7));
106 	CU_ASSERT(iovs[0].iov_len == 3);
107 	CU_ASSERT(iovs[1].iov_base == mem);
108 	CU_ASSERT(iovs[1].iov_len == 3);
109 	CU_ASSERT(pipe->write == 7);
110 	CU_ASSERT(pipe->read == 3);
111 
112 	memset(iovs, 0, sizeof(iovs));
113 
114 	/* Get more than the available memory */
115 	rc = spdk_pipe_writer_get_buffer(pipe, 7, iovs);
116 	CU_ASSERT(rc == 6);
117 	CU_ASSERT(iovs[0].iov_base == (mem + 7));
118 	CU_ASSERT(iovs[0].iov_len == 3);
119 	CU_ASSERT(iovs[1].iov_base == mem);
120 	CU_ASSERT(iovs[1].iov_len == 3);
121 	CU_ASSERT(pipe->write == 7);
122 	CU_ASSERT(pipe->read == 3);
123 
124 	memset(iovs, 0, sizeof(iovs));
125 
126 	/* Advance the read pointer past the write pointer */
127 	pipe->read = 9;
128 
129 	/* Get all of the available memory. */
130 	rc = spdk_pipe_writer_get_buffer(pipe, 2, iovs);
131 	CU_ASSERT(rc == 2);
132 	CU_ASSERT(iovs[0].iov_base == (mem + 7));
133 	CU_ASSERT(iovs[0].iov_len == 2);
134 	CU_ASSERT(iovs[1].iov_base == NULL);
135 	CU_ASSERT(iovs[1].iov_len == 0);
136 	CU_ASSERT(pipe->write == 7);
137 	CU_ASSERT(pipe->read == 9);
138 
139 	memset(iovs, 0, sizeof(iovs));
140 
141 	/* Get more than the available memory */
142 	rc = spdk_pipe_writer_get_buffer(pipe, 3, iovs);
143 	CU_ASSERT(rc == 2);
144 	CU_ASSERT(iovs[0].iov_base == (mem + 7));
145 	CU_ASSERT(iovs[0].iov_len == 2);
146 	CU_ASSERT(iovs[1].iov_base == NULL);
147 	CU_ASSERT(iovs[1].iov_len == 0);
148 	CU_ASSERT(pipe->write == 7);
149 	CU_ASSERT(pipe->read == 9);
150 
151 	memset(iovs, 0, sizeof(iovs));
152 
153 	/* Fill the pipe */
154 	pipe->write = 9;
155 	pipe->full = true;
156 
157 	/* Get data while the pipe is full */
158 	rc = spdk_pipe_writer_get_buffer(pipe, 1, iovs);
159 	CU_ASSERT(rc == 0);
160 	CU_ASSERT(iovs[0].iov_base == NULL);
161 	CU_ASSERT(iovs[0].iov_len == 0);
162 	CU_ASSERT(iovs[1].iov_base == NULL);
163 	CU_ASSERT(iovs[1].iov_len == 0);
164 	CU_ASSERT(pipe->write == 9);
165 	CU_ASSERT(pipe->read == 9);
166 
167 	spdk_pipe_destroy(pipe);
168 }
169 
170 static void
171 test_write_advance(void)
172 {
173 	struct spdk_pipe *pipe;
174 	uint8_t mem[10];
175 	int rc;
176 
177 	pipe = spdk_pipe_create(mem, sizeof(mem));
178 	SPDK_CU_ASSERT_FATAL(pipe != NULL);
179 
180 	/* Advance half way through the pipe */
181 	rc = spdk_pipe_writer_advance(pipe, 5);
182 	CU_ASSERT(rc == 0);
183 	CU_ASSERT(pipe->write == 5);
184 	CU_ASSERT(pipe->read == 0);
185 	CU_ASSERT(!pipe->full);
186 
187 	pipe->write = 0;
188 	pipe->full = false;
189 
190 	/* Advance to the end of the pipe */
191 	rc = spdk_pipe_writer_advance(pipe, 10);
192 	CU_ASSERT(rc == 0);
193 	CU_ASSERT(pipe->write == 0);
194 	CU_ASSERT(pipe->read == 0);
195 	CU_ASSERT(pipe->full);
196 
197 	pipe->write = 0;
198 	pipe->full = false;
199 
200 	/* Advance beyond the end */
201 	rc = spdk_pipe_writer_advance(pipe, 11);
202 	CU_ASSERT(rc == -EINVAL);
203 	CU_ASSERT(pipe->write == 0);
204 	CU_ASSERT(pipe->read == 0);
205 	CU_ASSERT(!pipe->full);
206 
207 	/* Move the read pointer forward */
208 	pipe->write = 0;
209 	pipe->read = 5;
210 	pipe->full = false;
211 
212 	/* Advance to the end of the pipe */
213 	rc = spdk_pipe_writer_advance(pipe, 5);
214 	CU_ASSERT(rc == 0);
215 	CU_ASSERT(pipe->write == 5);
216 	CU_ASSERT(pipe->read == 5);
217 	CU_ASSERT(pipe->full);
218 
219 	pipe->write = 0;
220 	pipe->read = 5;
221 	pipe->full = false;
222 
223 	/* Advance beyond the end */
224 	rc = spdk_pipe_writer_advance(pipe, 6);
225 	CU_ASSERT(rc == -EINVAL);
226 	CU_ASSERT(pipe->write == 0);
227 	CU_ASSERT(pipe->read == 5);
228 	CU_ASSERT(!pipe->full);
229 
230 	/* Test wrap around */
231 	pipe->write = 7;
232 	pipe->read = 3;
233 	pipe->full = false;
234 
235 	/* Advance to the end of the pipe */
236 	rc = spdk_pipe_writer_advance(pipe, 6);
237 	CU_ASSERT(rc == 0);
238 	CU_ASSERT(pipe->write == 3);
239 	CU_ASSERT(pipe->read == 3);
240 	CU_ASSERT(pipe->full);
241 
242 	pipe->write = 7;
243 	pipe->read = 3;
244 	pipe->full = false;
245 
246 	/* Advance beyond the end */
247 	rc = spdk_pipe_writer_advance(pipe, 7);
248 	CU_ASSERT(rc == -EINVAL);
249 	CU_ASSERT(pipe->write == 7);
250 	CU_ASSERT(pipe->read == 3);
251 	CU_ASSERT(!pipe->full);
252 
253 	spdk_pipe_destroy(pipe);
254 }
255 
256 static void
257 test_read_get_buffer(void)
258 {
259 	struct spdk_pipe *pipe;
260 	uint8_t mem[10];
261 	struct iovec iovs[2];
262 	int rc;
263 
264 	pipe = spdk_pipe_create(mem, sizeof(mem));
265 	SPDK_CU_ASSERT_FATAL(pipe != NULL);
266 
267 	/* Set the write pointer to the end, making all data available. */
268 	pipe->write = 9;
269 
270 	/* Get half the available memory. */
271 	rc = spdk_pipe_reader_get_buffer(pipe, 5, iovs);
272 	CU_ASSERT(rc == 5);
273 	CU_ASSERT(iovs[0].iov_base == mem);
274 	CU_ASSERT(iovs[0].iov_len == 5);
275 	CU_ASSERT(iovs[1].iov_base == NULL);
276 	CU_ASSERT(iovs[1].iov_len == 0);
277 	CU_ASSERT(pipe->write == 9);
278 	CU_ASSERT(pipe->read == 0);
279 
280 	memset(iovs, 0, sizeof(iovs));
281 
282 	/* Get 0 bytes. */
283 	rc = spdk_pipe_reader_get_buffer(pipe, 0, iovs);
284 	CU_ASSERT(rc == 0);
285 	CU_ASSERT(iovs[0].iov_base == NULL);
286 	CU_ASSERT(iovs[0].iov_len == 0);
287 	CU_ASSERT(iovs[1].iov_base == NULL);
288 	CU_ASSERT(iovs[1].iov_len == 0);
289 	CU_ASSERT(pipe->write == 9);
290 	CU_ASSERT(pipe->read == 0);
291 
292 	memset(iovs, 0, sizeof(iovs));
293 
294 	/* Get all available memory */
295 	rc = spdk_pipe_reader_get_buffer(pipe, 9, iovs);
296 	CU_ASSERT(rc == 9);
297 	CU_ASSERT(iovs[0].iov_base == mem);
298 	CU_ASSERT(iovs[0].iov_len == 9);
299 	CU_ASSERT(iovs[1].iov_base == NULL);
300 	CU_ASSERT(iovs[1].iov_len == 0);
301 	CU_ASSERT(pipe->write == 9);
302 	CU_ASSERT(pipe->read == 0);
303 
304 	memset(iovs, 0, sizeof(iovs));
305 
306 	/* Get more bytes than exist */
307 	rc = spdk_pipe_reader_get_buffer(pipe, 10, iovs);
308 	CU_ASSERT(rc == 9);
309 	CU_ASSERT(iovs[0].iov_base == mem);
310 	CU_ASSERT(iovs[0].iov_len == 9);
311 	CU_ASSERT(iovs[1].iov_base == NULL);
312 	CU_ASSERT(iovs[1].iov_len == 0);
313 	CU_ASSERT(pipe->write == 9);
314 	CU_ASSERT(pipe->read == 0);
315 
316 	memset(iovs, 0, sizeof(iovs));
317 
318 	/* Advance the read pointer 5 bytes in. */
319 	pipe->read = 5;
320 	pipe->write = 0;
321 
322 	/* Get all of the available memory. */
323 	rc = spdk_pipe_reader_get_buffer(pipe, 5, iovs);
324 	CU_ASSERT(rc == 5);
325 	CU_ASSERT(iovs[0].iov_base == (mem + 5));
326 	CU_ASSERT(iovs[0].iov_len == 5);
327 	CU_ASSERT(iovs[1].iov_base == NULL);
328 	CU_ASSERT(iovs[1].iov_len == 0);
329 	CU_ASSERT(pipe->write == 0);
330 	CU_ASSERT(pipe->read == 5);
331 
332 	memset(iovs, 0, sizeof(iovs));
333 
334 	/* Get more than the available memory */
335 	rc = spdk_pipe_reader_get_buffer(pipe, 6, iovs);
336 	CU_ASSERT(rc == 5);
337 	CU_ASSERT(iovs[0].iov_base == (mem + 5));
338 	CU_ASSERT(iovs[0].iov_len == 5);
339 	CU_ASSERT(iovs[1].iov_base == NULL);
340 	CU_ASSERT(iovs[1].iov_len == 0);
341 	CU_ASSERT(pipe->write == 0);
342 	CU_ASSERT(pipe->read == 5);
343 
344 	memset(iovs, 0, sizeof(iovs));
345 
346 	/* Invert the write and read pointers */
347 	pipe->read = 7;
348 	pipe->write = 3;
349 
350 	/* Get all of the available memory. */
351 	rc = spdk_pipe_reader_get_buffer(pipe, 6, iovs);
352 	CU_ASSERT(rc == 6);
353 	CU_ASSERT(iovs[0].iov_base == (mem + 7));
354 	CU_ASSERT(iovs[0].iov_len == 3);
355 	CU_ASSERT(iovs[1].iov_base == mem);
356 	CU_ASSERT(iovs[1].iov_len == 3);
357 	CU_ASSERT(pipe->write == 3);
358 	CU_ASSERT(pipe->read == 7);
359 
360 	memset(iovs, 0, sizeof(iovs));
361 
362 	/* Get more than the available memory */
363 	rc = spdk_pipe_reader_get_buffer(pipe, 7, iovs);
364 	CU_ASSERT(rc == 6);
365 	CU_ASSERT(iovs[0].iov_base == (mem + 7));
366 	CU_ASSERT(iovs[0].iov_len == 3);
367 	CU_ASSERT(iovs[1].iov_base == mem);
368 	CU_ASSERT(iovs[1].iov_len == 3);
369 	CU_ASSERT(pipe->write == 3);
370 	CU_ASSERT(pipe->read == 7);
371 
372 	memset(iovs, 0, sizeof(iovs));
373 
374 	/* Empty the pipe */
375 	pipe->read = 8;
376 	pipe->write = 8;
377 
378 	/* Get data while the pipe is empty */
379 	rc = spdk_pipe_reader_get_buffer(pipe, 1, iovs);
380 	CU_ASSERT(rc == 0);
381 	CU_ASSERT(iovs[0].iov_base == NULL);
382 	CU_ASSERT(iovs[0].iov_len == 0);
383 	CU_ASSERT(iovs[1].iov_base == NULL);
384 	CU_ASSERT(iovs[1].iov_len == 0);
385 	CU_ASSERT(pipe->write == 8);
386 	CU_ASSERT(pipe->read == 8);
387 
388 	spdk_pipe_destroy(pipe);
389 }
390 
391 static void
392 test_read_advance(void)
393 {
394 	struct spdk_pipe *pipe;
395 	uint8_t mem[10];
396 	int rc;
397 
398 	pipe = spdk_pipe_create(mem, sizeof(mem));
399 	SPDK_CU_ASSERT_FATAL(pipe != NULL);
400 
401 	pipe->read = 0;
402 	pipe->write = 9;
403 
404 	/* Advance half way through the pipe */
405 	rc = spdk_pipe_reader_advance(pipe, 5);
406 	CU_ASSERT(rc == 0);
407 	CU_ASSERT(pipe->read == 5);
408 	CU_ASSERT(pipe->write == 9);
409 
410 	pipe->read = 0;
411 	pipe->write = 9;
412 
413 	/* Advance to the end of the pipe, which resets
414 	 * it back to the beginning */
415 	rc = spdk_pipe_reader_advance(pipe, 9);
416 	CU_ASSERT(rc == 0);
417 	CU_ASSERT(pipe->read == 0);
418 	CU_ASSERT(pipe->write == 0);
419 
420 	pipe->read = 0;
421 	pipe->write = 9;
422 
423 	/* Advance beyond the end */
424 	rc = spdk_pipe_reader_advance(pipe, 10);
425 	CU_ASSERT(rc == -EINVAL);
426 	CU_ASSERT(pipe->read == 0);
427 	CU_ASSERT(pipe->write == 9);
428 
429 	/* Move the write pointer forward */
430 	pipe->read = 0;
431 	pipe->write = 5;
432 
433 	/* Advance to the end of the pipe, which resets
434 	 * it back to the beginning */
435 	rc = spdk_pipe_reader_advance(pipe, 5);
436 	CU_ASSERT(rc == 0);
437 	CU_ASSERT(pipe->write == 0);
438 	CU_ASSERT(pipe->read == 0);
439 
440 	pipe->read = 0;
441 	pipe->write = 5;
442 
443 	/* Advance beyond the end */
444 	rc = spdk_pipe_reader_advance(pipe, 6);
445 	CU_ASSERT(rc == -EINVAL);
446 	CU_ASSERT(pipe->read == 0);
447 	CU_ASSERT(pipe->write == 5);
448 
449 	/* Test wrap around */
450 	pipe->read = 7;
451 	pipe->write = 3;
452 
453 	/* Advance to the end of the pipe, which resets
454 	 * it back to the beginning */
455 	rc = spdk_pipe_reader_advance(pipe, 6);
456 	CU_ASSERT(rc == 0);
457 	CU_ASSERT(pipe->read == 0);
458 	CU_ASSERT(pipe->write == 0);
459 
460 	pipe->read = 7;
461 	pipe->write = 3;
462 
463 	/* Advance beyond the end */
464 	rc = spdk_pipe_writer_advance(pipe, 7);
465 	CU_ASSERT(rc == -EINVAL);
466 	CU_ASSERT(pipe->read == 7);
467 	CU_ASSERT(pipe->write == 3);
468 
469 	spdk_pipe_destroy(pipe);
470 }
471 
472 static void
473 test_data(void)
474 {
475 	struct spdk_pipe *pipe;
476 	uint8_t mem[10];
477 	struct iovec iovs[2];
478 	uint8_t *data;
479 	int rc;
480 	size_t i;
481 
482 	memset(mem, 0, sizeof(mem));
483 	memset(iovs, 0, sizeof(iovs));
484 
485 	pipe = spdk_pipe_create(mem, sizeof(mem));
486 	SPDK_CU_ASSERT_FATAL(pipe != NULL);
487 
488 	/* Place 1 byte in the pipe */
489 	rc = spdk_pipe_writer_get_buffer(pipe, 1, iovs);
490 	CU_ASSERT(rc == 1);
491 	CU_ASSERT(iovs[0].iov_base == mem);
492 	CU_ASSERT(iovs[0].iov_len == 1);
493 
494 	memset(iovs[0].iov_base, 'A', 1);
495 
496 	rc = spdk_pipe_writer_advance(pipe, 1);
497 	CU_ASSERT(rc == 0);
498 
499 	CU_ASSERT(mem[0] == 'A');
500 	CU_ASSERT(mem[1] == 0);
501 	CU_ASSERT(mem[2] == 0);
502 	CU_ASSERT(mem[3] == 0);
503 	CU_ASSERT(mem[4] == 0);
504 	CU_ASSERT(mem[5] == 0);
505 	CU_ASSERT(mem[6] == 0);
506 	CU_ASSERT(mem[7] == 0);
507 	CU_ASSERT(mem[8] == 0);
508 	CU_ASSERT(mem[9] == 0);
509 
510 	memset(iovs, 0, sizeof(iovs));
511 
512 	/* Get 1 byte from the pipe */
513 	CU_ASSERT(spdk_pipe_reader_bytes_available(pipe) == 1);
514 	rc = spdk_pipe_reader_get_buffer(pipe, 10, iovs);
515 	CU_ASSERT(rc == 1);
516 
517 	data = iovs[0].iov_base;
518 	CU_ASSERT(*data == 'A');
519 
520 	spdk_pipe_reader_advance(pipe, 1);
521 
522 	/* Put 9 more bytes in the pipe. The previous advance
523 	 * should have reset the pipe to the beginning. */
524 	rc = spdk_pipe_writer_get_buffer(pipe, 9, iovs);
525 	CU_ASSERT(rc == 9);
526 	CU_ASSERT(iovs[0].iov_len == 9);
527 	CU_ASSERT(iovs[1].iov_len == 0);
528 
529 	memset(iovs[0].iov_base, 'B', iovs[0].iov_len);
530 
531 	rc = spdk_pipe_writer_advance(pipe, 9);
532 	CU_ASSERT(rc == 0);
533 
534 	CU_ASSERT(mem[0] == 'B');
535 	CU_ASSERT(mem[1] == 'B');
536 	CU_ASSERT(mem[2] == 'B');
537 	CU_ASSERT(mem[3] == 'B');
538 	CU_ASSERT(mem[4] == 'B');
539 	CU_ASSERT(mem[5] == 'B');
540 	CU_ASSERT(mem[6] == 'B');
541 	CU_ASSERT(mem[7] == 'B');
542 	CU_ASSERT(mem[8] == 'B');
543 	CU_ASSERT(mem[9] == 0);
544 
545 	memset(iovs, 0, sizeof(iovs));
546 
547 	/* Get 7 bytes of the previously written 9. */
548 	CU_ASSERT(spdk_pipe_reader_bytes_available(pipe) == 9);
549 	rc = spdk_pipe_reader_get_buffer(pipe, 7, iovs);
550 	CU_ASSERT(rc == 7);
551 
552 	CU_ASSERT(iovs[0].iov_len == 7);
553 	data = iovs[0].iov_base;
554 	for (i = 0; i < iovs[0].iov_len; i++) {
555 		CU_ASSERT(data[i] == 'B');
556 	}
557 
558 	spdk_pipe_reader_advance(pipe, 7);
559 
560 	memset(iovs, 0, sizeof(iovs));
561 
562 	/* Put 1 more byte in the pipe */
563 	rc = spdk_pipe_writer_get_buffer(pipe, 1, iovs);
564 	CU_ASSERT(rc == 1);
565 	CU_ASSERT(iovs[0].iov_len == 1);
566 	CU_ASSERT(iovs[1].iov_len == 0);
567 
568 	memset(iovs[0].iov_base, 'C', iovs[0].iov_len);
569 
570 	rc = spdk_pipe_writer_advance(pipe, 1);
571 	CU_ASSERT(rc == 0);
572 
573 	CU_ASSERT(mem[0] == 'B');
574 	CU_ASSERT(mem[1] == 'B');
575 	CU_ASSERT(mem[2] == 'B');
576 	CU_ASSERT(mem[3] == 'B');
577 	CU_ASSERT(mem[4] == 'B');
578 	CU_ASSERT(mem[5] == 'B');
579 	CU_ASSERT(mem[6] == 'B');
580 	CU_ASSERT(mem[7] == 'B');
581 	CU_ASSERT(mem[8] == 'B');
582 	CU_ASSERT(mem[9] == 'C');
583 
584 	memset(iovs, 0, sizeof(iovs));
585 
586 	/* Get all of the data out of the pipe */
587 	CU_ASSERT(spdk_pipe_reader_bytes_available(pipe) == 3);
588 	rc = spdk_pipe_reader_get_buffer(pipe, 3, iovs);
589 	CU_ASSERT(rc == 3);
590 	CU_ASSERT(iovs[0].iov_len == 3);
591 	CU_ASSERT(iovs[1].iov_len == 0);
592 
593 	data = iovs[0].iov_base;
594 	CU_ASSERT(data[0] == 'B');
595 	CU_ASSERT(data[1] == 'B');
596 	CU_ASSERT(data[2] == 'C');
597 	CU_ASSERT(iovs[1].iov_base == NULL);
598 
599 	spdk_pipe_reader_advance(pipe, 3);
600 
601 	spdk_pipe_destroy(pipe);
602 }
603 
604 int
605 main(int argc, char **argv)
606 {
607 	CU_pSuite	suite = NULL;
608 	unsigned int	num_failures;
609 
610 	CU_initialize_registry();
611 
612 	suite = CU_add_suite("pipe", NULL, NULL);
613 
614 	CU_ADD_TEST(suite, test_create_destroy);
615 	CU_ADD_TEST(suite, test_write_get_buffer);
616 	CU_ADD_TEST(suite, test_write_advance);
617 	CU_ADD_TEST(suite, test_read_get_buffer);
618 	CU_ADD_TEST(suite, test_read_advance);
619 	CU_ADD_TEST(suite, test_data);
620 
621 
622 	num_failures = spdk_ut_run_tests(argc, argv, NULL);
623 
624 	CU_cleanup_registry();
625 
626 	return num_failures;
627 }
628