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 */ 414 rc = spdk_pipe_reader_advance(pipe, 9); 415 CU_ASSERT(rc == 0); 416 CU_ASSERT(pipe->read == 9); 417 CU_ASSERT(pipe->write == 9); 418 419 pipe->read = 0; 420 pipe->write = 9; 421 422 /* Advance beyond the end */ 423 rc = spdk_pipe_reader_advance(pipe, 10); 424 CU_ASSERT(rc == -EINVAL); 425 CU_ASSERT(pipe->read == 0); 426 CU_ASSERT(pipe->write == 9); 427 428 /* Move the write pointer forward */ 429 pipe->read = 0; 430 pipe->write = 5; 431 432 /* Advance to the end of the pipe */ 433 rc = spdk_pipe_reader_advance(pipe, 5); 434 CU_ASSERT(rc == 0); 435 CU_ASSERT(pipe->write == 5); 436 CU_ASSERT(pipe->read == 5); 437 438 pipe->read = 0; 439 pipe->write = 5; 440 441 /* Advance beyond the end */ 442 rc = spdk_pipe_reader_advance(pipe, 6); 443 CU_ASSERT(rc == -EINVAL); 444 CU_ASSERT(pipe->read == 0); 445 CU_ASSERT(pipe->write == 5); 446 447 /* Test wrap around */ 448 pipe->read = 7; 449 pipe->write = 3; 450 451 /* Advance to the end of the pipe */ 452 rc = spdk_pipe_reader_advance(pipe, 6); 453 CU_ASSERT(rc == 0); 454 CU_ASSERT(pipe->read == 3); 455 CU_ASSERT(pipe->write == 3); 456 457 pipe->read = 7; 458 pipe->write = 3; 459 460 /* Advance beyond the end */ 461 rc = spdk_pipe_writer_advance(pipe, 7); 462 CU_ASSERT(rc == -EINVAL); 463 CU_ASSERT(pipe->read == 7); 464 CU_ASSERT(pipe->write == 3); 465 466 spdk_pipe_destroy(pipe); 467 } 468 469 static void 470 test_data(void) 471 { 472 struct spdk_pipe *pipe; 473 uint8_t mem[10]; 474 struct iovec iovs[2]; 475 uint8_t *data; 476 int rc; 477 size_t i; 478 479 memset(mem, 0, sizeof(mem)); 480 memset(iovs, 0, sizeof(iovs)); 481 482 pipe = spdk_pipe_create(mem, sizeof(mem)); 483 SPDK_CU_ASSERT_FATAL(pipe != NULL); 484 485 /* Place 1 byte in the pipe */ 486 rc = spdk_pipe_writer_get_buffer(pipe, 1, iovs); 487 CU_ASSERT(rc == 1); 488 CU_ASSERT(iovs[0].iov_base != NULL); 489 CU_ASSERT(iovs[0].iov_len == 1); 490 491 memset(iovs[0].iov_base, 'A', 1); 492 493 rc = spdk_pipe_writer_advance(pipe, 1); 494 CU_ASSERT(rc == 0); 495 496 CU_ASSERT(mem[0] == 'A'); 497 CU_ASSERT(mem[1] == 0); 498 CU_ASSERT(mem[2] == 0); 499 CU_ASSERT(mem[3] == 0); 500 CU_ASSERT(mem[4] == 0); 501 CU_ASSERT(mem[5] == 0); 502 CU_ASSERT(mem[6] == 0); 503 CU_ASSERT(mem[7] == 0); 504 CU_ASSERT(mem[8] == 0); 505 CU_ASSERT(mem[9] == 0); 506 507 memset(iovs, 0, sizeof(iovs)); 508 509 /* Get 1 byte from the pipe */ 510 CU_ASSERT(spdk_pipe_reader_bytes_available(pipe) == 1); 511 rc = spdk_pipe_reader_get_buffer(pipe, 10, iovs); 512 CU_ASSERT(rc == 1); 513 514 data = iovs[0].iov_base; 515 CU_ASSERT(*data = 'A'); 516 517 spdk_pipe_reader_advance(pipe, 1); 518 519 /* Put 9 more bytes in the pipe, so every byte has 520 * been written */ 521 rc = spdk_pipe_writer_get_buffer(pipe, 9, iovs); 522 CU_ASSERT(rc == 9); 523 CU_ASSERT(iovs[0].iov_len == 9); 524 CU_ASSERT(iovs[1].iov_len == 0); 525 526 memset(iovs[0].iov_base, 'B', iovs[0].iov_len); 527 528 rc = spdk_pipe_writer_advance(pipe, 9); 529 CU_ASSERT(rc == 0); 530 531 CU_ASSERT(mem[0] == 'A'); 532 CU_ASSERT(mem[1] == 'B'); 533 CU_ASSERT(mem[2] == 'B'); 534 CU_ASSERT(mem[3] == 'B'); 535 CU_ASSERT(mem[4] == 'B'); 536 CU_ASSERT(mem[5] == 'B'); 537 CU_ASSERT(mem[6] == 'B'); 538 CU_ASSERT(mem[7] == 'B'); 539 CU_ASSERT(mem[8] == 'B'); 540 CU_ASSERT(mem[9] == 'B'); 541 542 memset(iovs, 0, sizeof(iovs)); 543 544 /* Get 7 bytes of the previously written 9. */ 545 CU_ASSERT(spdk_pipe_reader_bytes_available(pipe) == 9); 546 rc = spdk_pipe_reader_get_buffer(pipe, 7, iovs); 547 CU_ASSERT(rc == 7); 548 549 CU_ASSERT(iovs[0].iov_len == 7); 550 data = iovs[0].iov_base; 551 for (i = 0; i < iovs[0].iov_len; i++) { 552 CU_ASSERT(data[i] == 'B'); 553 } 554 555 spdk_pipe_reader_advance(pipe, 7); 556 557 memset(iovs, 0, sizeof(iovs)); 558 559 /* Put 1 more byte in the pipe, overwriting the original 'A' */ 560 rc = spdk_pipe_writer_get_buffer(pipe, 1, iovs); 561 CU_ASSERT(rc == 1); 562 CU_ASSERT(iovs[0].iov_len == 1); 563 CU_ASSERT(iovs[1].iov_len == 0); 564 565 memset(iovs[0].iov_base, 'C', iovs[0].iov_len); 566 567 rc = spdk_pipe_writer_advance(pipe, 1); 568 CU_ASSERT(rc == 0); 569 570 CU_ASSERT(mem[0] == 'C'); 571 CU_ASSERT(mem[1] == 'B'); 572 CU_ASSERT(mem[2] == 'B'); 573 CU_ASSERT(mem[3] == 'B'); 574 CU_ASSERT(mem[4] == 'B'); 575 CU_ASSERT(mem[5] == 'B'); 576 CU_ASSERT(mem[6] == 'B'); 577 CU_ASSERT(mem[7] == 'B'); 578 CU_ASSERT(mem[8] == 'B'); 579 CU_ASSERT(mem[9] == 'B'); 580 581 memset(iovs, 0, sizeof(iovs)); 582 583 /* Get all of the data out of the pipe */ 584 CU_ASSERT(spdk_pipe_reader_bytes_available(pipe) == 3); 585 rc = spdk_pipe_reader_get_buffer(pipe, 3, iovs); 586 CU_ASSERT(rc == 3); 587 CU_ASSERT(iovs[0].iov_len == 2); 588 CU_ASSERT(iovs[1].iov_len == 1); 589 590 data = iovs[0].iov_base; 591 CU_ASSERT(data[0] == 'B'); 592 CU_ASSERT(data[1] == 'B'); 593 data = iovs[1].iov_base; 594 CU_ASSERT(data[0] == 'C'); 595 596 spdk_pipe_reader_advance(pipe, 3); 597 598 spdk_pipe_destroy(pipe); 599 } 600 601 int 602 main(int argc, char **argv) 603 { 604 CU_pSuite suite = NULL; 605 unsigned int num_failures; 606 607 CU_initialize_registry(); 608 609 suite = CU_add_suite("pipe", NULL, NULL); 610 611 CU_ADD_TEST(suite, test_create_destroy); 612 CU_ADD_TEST(suite, test_write_get_buffer); 613 CU_ADD_TEST(suite, test_write_advance); 614 CU_ADD_TEST(suite, test_read_get_buffer); 615 CU_ADD_TEST(suite, test_read_advance); 616 CU_ADD_TEST(suite, test_data); 617 618 619 num_failures = spdk_ut_run_tests(argc, argv, NULL); 620 621 CU_cleanup_registry(); 622 623 return num_failures; 624 } 625