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