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