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