1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (c) Intel Corporation. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include "spdk/stdinc.h" 35 36 #include "CUnit/Basic.h" 37 #include "spdk_cunit.h" 38 39 #include "spdk/util.h" 40 41 #include "scsi/dev.c" 42 #include "scsi/port.c" 43 44 #include "spdk_internal/mock.h" 45 46 /* Unit test bdev mockup */ 47 struct spdk_bdev { 48 char name[100]; 49 }; 50 51 static struct spdk_bdev g_bdevs[] = { 52 {"malloc0"}, 53 {"malloc1"}, 54 }; 55 56 static struct spdk_scsi_port *g_initiator_port_with_pending_tasks = NULL; 57 static struct spdk_scsi_port *g_initiator_port_with_pending_mgmt_tasks = NULL; 58 59 const char * 60 spdk_bdev_get_name(const struct spdk_bdev *bdev) 61 { 62 return bdev->name; 63 } 64 65 static struct spdk_scsi_task * 66 spdk_get_task(uint32_t *owner_task_ctr) 67 { 68 struct spdk_scsi_task *task; 69 70 task = calloc(1, sizeof(*task)); 71 if (!task) { 72 return NULL; 73 } 74 75 return task; 76 } 77 78 void 79 spdk_scsi_task_put(struct spdk_scsi_task *task) 80 { 81 free(task); 82 } 83 84 struct spdk_scsi_lun *scsi_lun_construct(struct spdk_bdev *bdev, 85 void (*hotremove_cb)(const struct spdk_scsi_lun *, void *), 86 void *hotremove_ctx) 87 { 88 struct spdk_scsi_lun *lun; 89 90 lun = calloc(1, sizeof(struct spdk_scsi_lun)); 91 SPDK_CU_ASSERT_FATAL(lun != NULL); 92 93 lun->bdev = bdev; 94 95 return lun; 96 } 97 98 void 99 scsi_lun_destruct(struct spdk_scsi_lun *lun) 100 { 101 free(lun); 102 } 103 104 struct spdk_bdev * 105 spdk_bdev_get_by_name(const char *bdev_name) 106 { 107 size_t i; 108 109 for (i = 0; i < SPDK_COUNTOF(g_bdevs); i++) { 110 if (strcmp(bdev_name, g_bdevs[i].name) == 0) { 111 return &g_bdevs[i]; 112 } 113 } 114 115 return NULL; 116 } 117 118 DEFINE_STUB_V(scsi_lun_execute_mgmt_task, 119 (struct spdk_scsi_lun *lun, struct spdk_scsi_task *task)); 120 121 DEFINE_STUB_V(scsi_lun_execute_task, 122 (struct spdk_scsi_lun *lun, struct spdk_scsi_task *task)); 123 124 DEFINE_STUB(scsi_lun_allocate_io_channel, int, 125 (struct spdk_scsi_lun *lun), 0); 126 127 DEFINE_STUB_V(scsi_lun_free_io_channel, (struct spdk_scsi_lun *lun)); 128 129 bool 130 scsi_lun_has_pending_mgmt_tasks(const struct spdk_scsi_lun *lun, 131 const struct spdk_scsi_port *initiator_port) 132 { 133 return (g_initiator_port_with_pending_mgmt_tasks == initiator_port); 134 } 135 136 bool 137 scsi_lun_has_pending_tasks(const struct spdk_scsi_lun *lun, 138 const struct spdk_scsi_port *initiator_port) 139 { 140 return (g_initiator_port_with_pending_tasks == initiator_port); 141 } 142 143 static void 144 dev_destruct_null_dev(void) 145 { 146 /* pass null for the dev */ 147 spdk_scsi_dev_destruct(NULL, NULL, NULL); 148 } 149 150 static void 151 dev_destruct_zero_luns(void) 152 { 153 struct spdk_scsi_dev dev = { .is_allocated = 1 }; 154 155 /* No luns attached to the dev */ 156 157 /* free the dev */ 158 spdk_scsi_dev_destruct(&dev, NULL, NULL); 159 } 160 161 static void 162 dev_destruct_null_lun(void) 163 { 164 struct spdk_scsi_dev dev = { .is_allocated = 1 }; 165 166 /* pass null for the lun */ 167 dev.lun[0] = NULL; 168 169 /* free the dev */ 170 spdk_scsi_dev_destruct(&dev, NULL, NULL); 171 } 172 173 static void 174 dev_destruct_success(void) 175 { 176 struct spdk_scsi_dev dev = { .is_allocated = 1 }; 177 int rc; 178 179 /* dev with a single lun */ 180 rc = spdk_scsi_dev_add_lun(&dev, "malloc0", 0, NULL, NULL); 181 182 CU_ASSERT(rc == 0); 183 184 /* free the dev */ 185 spdk_scsi_dev_destruct(&dev, NULL, NULL); 186 187 } 188 189 static void 190 dev_construct_num_luns_zero(void) 191 { 192 struct spdk_scsi_dev *dev; 193 const char *bdev_name_list[1] = {}; 194 int lun_id_list[1] = { 0 }; 195 196 dev = spdk_scsi_dev_construct("Name", bdev_name_list, lun_id_list, 0, 197 SPDK_SPC_PROTOCOL_IDENTIFIER_ISCSI, NULL, NULL); 198 199 /* dev should be null since we passed num_luns = 0 */ 200 CU_ASSERT_TRUE(dev == NULL); 201 } 202 203 static void 204 dev_construct_no_lun_zero(void) 205 { 206 struct spdk_scsi_dev *dev; 207 const char *bdev_name_list[1] = {}; 208 int lun_id_list[1] = { 0 }; 209 210 lun_id_list[0] = 1; 211 212 dev = spdk_scsi_dev_construct("Name", bdev_name_list, lun_id_list, 1, 213 SPDK_SPC_PROTOCOL_IDENTIFIER_ISCSI, NULL, NULL); 214 215 /* dev should be null since no LUN0 was specified (lun_id_list[0] = 1) */ 216 CU_ASSERT_TRUE(dev == NULL); 217 } 218 219 static void 220 dev_construct_null_lun(void) 221 { 222 struct spdk_scsi_dev *dev; 223 const char *bdev_name_list[1] = {}; 224 int lun_id_list[1] = { 0 }; 225 226 dev = spdk_scsi_dev_construct("Name", bdev_name_list, lun_id_list, 1, 227 SPDK_SPC_PROTOCOL_IDENTIFIER_ISCSI, NULL, NULL); 228 229 /* dev should be null since no LUN0 was specified (lun_list[0] = NULL) */ 230 CU_ASSERT_TRUE(dev == NULL); 231 } 232 233 static void 234 dev_construct_name_too_long(void) 235 { 236 struct spdk_scsi_dev *dev; 237 const char *bdev_name_list[1] = {"malloc0"}; 238 int lun_id_list[1] = { 0 }; 239 char name[SPDK_SCSI_DEV_MAX_NAME + 1 + 1]; 240 241 /* Try to construct a dev with a name that is one byte longer than allowed. */ 242 memset(name, 'x', sizeof(name) - 1); 243 name[sizeof(name) - 1] = '\0'; 244 245 dev = spdk_scsi_dev_construct(name, bdev_name_list, lun_id_list, 1, 246 SPDK_SPC_PROTOCOL_IDENTIFIER_ISCSI, NULL, NULL); 247 248 CU_ASSERT(dev == NULL); 249 } 250 251 static void 252 dev_construct_success(void) 253 { 254 struct spdk_scsi_dev *dev; 255 const char *bdev_name_list[1] = {"malloc0"}; 256 int lun_id_list[1] = { 0 }; 257 258 dev = spdk_scsi_dev_construct("Name", bdev_name_list, lun_id_list, 1, 259 SPDK_SPC_PROTOCOL_IDENTIFIER_ISCSI, NULL, NULL); 260 261 /* Successfully constructs and returns a dev */ 262 CU_ASSERT_TRUE(dev != NULL); 263 264 /* free the dev */ 265 spdk_scsi_dev_destruct(dev, NULL, NULL); 266 } 267 268 static void 269 dev_construct_success_lun_zero_not_first(void) 270 { 271 struct spdk_scsi_dev *dev; 272 const char *bdev_name_list[2] = {"malloc1", "malloc0"}; 273 int lun_id_list[2] = { 1, 0 }; 274 275 dev = spdk_scsi_dev_construct("Name", bdev_name_list, lun_id_list, 2, 276 SPDK_SPC_PROTOCOL_IDENTIFIER_ISCSI, NULL, NULL); 277 278 /* Successfully constructs and returns a dev */ 279 CU_ASSERT_TRUE(dev != NULL); 280 281 /* free the dev */ 282 spdk_scsi_dev_destruct(dev, NULL, NULL); 283 } 284 285 static void 286 dev_queue_mgmt_task_success(void) 287 { 288 struct spdk_scsi_dev *dev; 289 const char *bdev_name_list[1] = {"malloc0"}; 290 int lun_id_list[1] = { 0 }; 291 struct spdk_scsi_task *task; 292 293 dev = spdk_scsi_dev_construct("Name", bdev_name_list, lun_id_list, 1, 294 SPDK_SPC_PROTOCOL_IDENTIFIER_ISCSI, NULL, NULL); 295 296 /* Successfully constructs and returns a dev */ 297 CU_ASSERT_TRUE(dev != NULL); 298 299 task = spdk_get_task(NULL); 300 301 task->function = SPDK_SCSI_TASK_FUNC_LUN_RESET; 302 spdk_scsi_dev_queue_mgmt_task(dev, task); 303 304 spdk_scsi_task_put(task); 305 306 spdk_scsi_dev_destruct(dev, NULL, NULL); 307 } 308 309 static void 310 dev_queue_task_success(void) 311 { 312 struct spdk_scsi_dev *dev; 313 const char *bdev_name_list[1] = {"malloc0"}; 314 int lun_id_list[1] = { 0 }; 315 struct spdk_scsi_task *task; 316 317 dev = spdk_scsi_dev_construct("Name", bdev_name_list, lun_id_list, 1, 318 SPDK_SPC_PROTOCOL_IDENTIFIER_ISCSI, NULL, NULL); 319 320 /* Successfully constructs and returns a dev */ 321 CU_ASSERT_TRUE(dev != NULL); 322 323 task = spdk_get_task(NULL); 324 325 spdk_scsi_dev_queue_task(dev, task); 326 327 spdk_scsi_task_put(task); 328 329 spdk_scsi_dev_destruct(dev, NULL, NULL); 330 } 331 332 static void 333 dev_stop_success(void) 334 { 335 struct spdk_scsi_dev dev = { 0 }; 336 struct spdk_scsi_task *task; 337 struct spdk_scsi_task *task_mgmt; 338 339 task = spdk_get_task(NULL); 340 341 spdk_scsi_dev_queue_task(&dev, task); 342 343 task_mgmt = spdk_get_task(NULL); 344 345 /* Enqueue the tasks into dev->task_mgmt_submit_queue */ 346 task->function = SPDK_SCSI_TASK_FUNC_LUN_RESET; 347 spdk_scsi_dev_queue_mgmt_task(&dev, task_mgmt); 348 349 spdk_scsi_task_put(task); 350 spdk_scsi_task_put(task_mgmt); 351 } 352 353 static void 354 dev_add_port_max_ports(void) 355 { 356 struct spdk_scsi_dev dev = { 0 }; 357 const char *name; 358 int id, rc; 359 360 /* dev is set to SPDK_SCSI_DEV_MAX_PORTS */ 361 dev.num_ports = SPDK_SCSI_DEV_MAX_PORTS; 362 name = "Name of Port"; 363 id = 1; 364 365 rc = spdk_scsi_dev_add_port(&dev, id, name); 366 367 /* returns -1; since the dev already has maximum 368 * number of ports (SPDK_SCSI_DEV_MAX_PORTS) */ 369 CU_ASSERT_TRUE(rc < 0); 370 } 371 372 static void 373 dev_add_port_construct_failure1(void) 374 { 375 struct spdk_scsi_dev dev = { 0 }; 376 const int port_name_length = SPDK_SCSI_PORT_MAX_NAME_LENGTH + 2; 377 char name[port_name_length]; 378 uint64_t id; 379 int rc; 380 381 dev.num_ports = 1; 382 /* Set the name such that the length exceeds SPDK_SCSI_PORT_MAX_NAME_LENGTH 383 * SPDK_SCSI_PORT_MAX_NAME_LENGTH = 256 */ 384 memset(name, 'a', port_name_length - 1); 385 name[port_name_length - 1] = '\0'; 386 id = 1; 387 388 rc = spdk_scsi_dev_add_port(&dev, id, name); 389 390 /* returns -1; since the length of the name exceeds 391 * SPDK_SCSI_PORT_MAX_NAME_LENGTH */ 392 CU_ASSERT_TRUE(rc < 0); 393 } 394 395 static void 396 dev_add_port_construct_failure2(void) 397 { 398 struct spdk_scsi_dev dev = { 0 }; 399 const char *name; 400 uint64_t id; 401 int rc; 402 403 dev.num_ports = 1; 404 name = "Name of Port"; 405 id = 1; 406 407 /* Initialize port[0] to be valid and its index is set to 1 */ 408 dev.port[0].id = id; 409 dev.port[0].is_used = 1; 410 411 rc = spdk_scsi_dev_add_port(&dev, id, name); 412 413 /* returns -1; since the dev already has a port whose index to be 1 */ 414 CU_ASSERT_TRUE(rc < 0); 415 } 416 417 static void 418 dev_add_port_success1(void) 419 { 420 struct spdk_scsi_dev dev = { 0 }; 421 const char *name; 422 int id, rc; 423 424 dev.num_ports = 1; 425 name = "Name of Port"; 426 id = 1; 427 428 rc = spdk_scsi_dev_add_port(&dev, id, name); 429 430 /* successfully adds a port */ 431 CU_ASSERT_EQUAL(rc, 0); 432 /* Assert num_ports has been incremented to 2 */ 433 CU_ASSERT_EQUAL(dev.num_ports, 2); 434 } 435 436 static void 437 dev_add_port_success2(void) 438 { 439 struct spdk_scsi_dev dev = { 0 }; 440 const char *name; 441 uint64_t id; 442 int rc; 443 444 dev.num_ports = 1; 445 name = "Name of Port"; 446 id = 1; 447 /* set id of invalid port[0] to 1. This must be ignored */ 448 dev.port[0].id = id; 449 dev.port[0].is_used = 0; 450 451 rc = spdk_scsi_dev_add_port(&dev, id, name); 452 453 /* successfully adds a port */ 454 CU_ASSERT_EQUAL(rc, 0); 455 /* Assert num_ports has been incremented to 1 */ 456 CU_ASSERT_EQUAL(dev.num_ports, 2); 457 } 458 459 static void 460 dev_add_port_success3(void) 461 { 462 struct spdk_scsi_dev dev = { 0 }; 463 const char *name; 464 uint64_t add_id; 465 int rc; 466 467 dev.num_ports = 1; 468 name = "Name of Port"; 469 dev.port[0].id = 1; 470 dev.port[0].is_used = 1; 471 add_id = 2; 472 473 /* Add a port with id = 2 */ 474 rc = spdk_scsi_dev_add_port(&dev, add_id, name); 475 476 /* successfully adds a port */ 477 CU_ASSERT_EQUAL(rc, 0); 478 /* Assert num_ports has been incremented to 2 */ 479 CU_ASSERT_EQUAL(dev.num_ports, 2); 480 } 481 482 static void 483 dev_find_port_by_id_num_ports_zero(void) 484 { 485 struct spdk_scsi_dev dev = { 0 }; 486 struct spdk_scsi_port *rp_port; 487 uint64_t id; 488 489 dev.num_ports = 0; 490 id = 1; 491 492 rp_port = spdk_scsi_dev_find_port_by_id(&dev, id); 493 494 /* returns null; since dev's num_ports is 0 */ 495 CU_ASSERT_TRUE(rp_port == NULL); 496 } 497 498 static void 499 dev_find_port_by_id_id_not_found_failure(void) 500 { 501 struct spdk_scsi_dev dev = { 0 }; 502 struct spdk_scsi_port *rp_port; 503 const char *name; 504 int rc; 505 uint64_t id, find_id; 506 507 id = 1; 508 dev.num_ports = 1; 509 name = "Name of Port"; 510 find_id = 2; 511 512 /* Add a port with id = 1 */ 513 rc = spdk_scsi_dev_add_port(&dev, id, name); 514 515 CU_ASSERT_EQUAL(rc, 0); 516 517 /* Find port with id = 2 */ 518 rp_port = spdk_scsi_dev_find_port_by_id(&dev, find_id); 519 520 /* returns null; failed to find port specified by id = 2 */ 521 CU_ASSERT_TRUE(rp_port == NULL); 522 } 523 524 static void 525 dev_find_port_by_id_success(void) 526 { 527 struct spdk_scsi_dev dev = { 0 }; 528 struct spdk_scsi_port *rp_port; 529 const char *name; 530 int rc; 531 uint64_t id; 532 533 id = 1; 534 dev.num_ports = 1; 535 name = "Name of Port"; 536 537 /* Add a port */ 538 rc = spdk_scsi_dev_add_port(&dev, id, name); 539 540 CU_ASSERT_EQUAL(rc, 0); 541 542 /* Find port by the same id as the one added above */ 543 rp_port = spdk_scsi_dev_find_port_by_id(&dev, id); 544 545 /* Successfully found port specified by id */ 546 CU_ASSERT_TRUE(rp_port != NULL); 547 if (rp_port != NULL) { 548 /* Assert the found port's id and name are same as 549 * the port added. */ 550 CU_ASSERT_EQUAL(rp_port->id, 1); 551 CU_ASSERT_STRING_EQUAL(rp_port->name, "Name of Port"); 552 } 553 } 554 555 static void 556 dev_add_lun_bdev_not_found(void) 557 { 558 int rc; 559 struct spdk_scsi_dev dev = {0}; 560 561 rc = spdk_scsi_dev_add_lun(&dev, "malloc2", 0, NULL, NULL); 562 563 SPDK_CU_ASSERT_FATAL(dev.lun[0] == NULL); 564 CU_ASSERT_NOT_EQUAL(rc, 0); 565 } 566 567 static void 568 dev_add_lun_no_free_lun_id(void) 569 { 570 int rc; 571 int i; 572 struct spdk_scsi_dev dev = {0}; 573 struct spdk_scsi_lun lun; 574 575 for (i = 0; i < SPDK_SCSI_DEV_MAX_LUN; i++) { 576 dev.lun[i] = &lun; 577 } 578 579 rc = spdk_scsi_dev_add_lun(&dev, "malloc0", -1, NULL, NULL); 580 581 CU_ASSERT_NOT_EQUAL(rc, 0); 582 } 583 584 static void 585 dev_add_lun_success1(void) 586 { 587 int rc; 588 struct spdk_scsi_dev dev = {0}; 589 590 rc = spdk_scsi_dev_add_lun(&dev, "malloc0", -1, NULL, NULL); 591 592 CU_ASSERT_EQUAL(rc, 0); 593 594 spdk_scsi_dev_destruct(&dev, NULL, NULL); 595 } 596 597 static void 598 dev_add_lun_success2(void) 599 { 600 int rc; 601 struct spdk_scsi_dev dev = {0}; 602 603 rc = spdk_scsi_dev_add_lun(&dev, "malloc0", 0, NULL, NULL); 604 605 CU_ASSERT_EQUAL(rc, 0); 606 607 spdk_scsi_dev_destruct(&dev, NULL, NULL); 608 } 609 610 static void 611 dev_check_pending_tasks(void) 612 { 613 struct spdk_scsi_dev dev = {}; 614 struct spdk_scsi_lun lun = {}; 615 struct spdk_scsi_port initiator_port = {}; 616 617 g_initiator_port_with_pending_tasks = NULL; 618 g_initiator_port_with_pending_mgmt_tasks = NULL; 619 620 CU_ASSERT(spdk_scsi_dev_has_pending_tasks(&dev, NULL) == false); 621 622 dev.lun[SPDK_SCSI_DEV_MAX_LUN - 1] = &lun; 623 624 CU_ASSERT(spdk_scsi_dev_has_pending_tasks(&dev, NULL) == true); 625 CU_ASSERT(spdk_scsi_dev_has_pending_tasks(&dev, &initiator_port) == false); 626 627 g_initiator_port_with_pending_tasks = &initiator_port; 628 CU_ASSERT(spdk_scsi_dev_has_pending_tasks(&dev, NULL) == true); 629 CU_ASSERT(spdk_scsi_dev_has_pending_tasks(&dev, &initiator_port) == true); 630 631 g_initiator_port_with_pending_tasks = NULL; 632 g_initiator_port_with_pending_mgmt_tasks = &initiator_port; 633 CU_ASSERT(spdk_scsi_dev_has_pending_tasks(&dev, NULL) == true); 634 CU_ASSERT(spdk_scsi_dev_has_pending_tasks(&dev, &initiator_port) == true); 635 } 636 637 int 638 main(int argc, char **argv) 639 { 640 CU_pSuite suite = NULL; 641 unsigned int num_failures; 642 643 CU_set_error_action(CUEA_ABORT); 644 CU_initialize_registry(); 645 646 suite = CU_add_suite("dev_suite", NULL, NULL); 647 648 CU_ADD_TEST(suite, dev_destruct_null_dev); 649 CU_ADD_TEST(suite, dev_destruct_zero_luns); 650 CU_ADD_TEST(suite, dev_destruct_null_lun); 651 CU_ADD_TEST(suite, dev_destruct_success); 652 CU_ADD_TEST(suite, dev_construct_num_luns_zero); 653 CU_ADD_TEST(suite, dev_construct_no_lun_zero); 654 CU_ADD_TEST(suite, dev_construct_null_lun); 655 CU_ADD_TEST(suite, dev_construct_name_too_long); 656 CU_ADD_TEST(suite, dev_construct_success); 657 CU_ADD_TEST(suite, dev_construct_success_lun_zero_not_first); 658 CU_ADD_TEST(suite, dev_queue_mgmt_task_success); 659 CU_ADD_TEST(suite, dev_queue_task_success); 660 CU_ADD_TEST(suite, dev_stop_success); 661 CU_ADD_TEST(suite, dev_add_port_max_ports); 662 CU_ADD_TEST(suite, dev_add_port_construct_failure1); 663 CU_ADD_TEST(suite, dev_add_port_construct_failure2); 664 CU_ADD_TEST(suite, dev_add_port_success1); 665 CU_ADD_TEST(suite, dev_add_port_success2); 666 CU_ADD_TEST(suite, dev_add_port_success3); 667 CU_ADD_TEST(suite, dev_find_port_by_id_num_ports_zero); 668 CU_ADD_TEST(suite, dev_find_port_by_id_id_not_found_failure); 669 CU_ADD_TEST(suite, dev_find_port_by_id_success); 670 CU_ADD_TEST(suite, dev_add_lun_bdev_not_found); 671 CU_ADD_TEST(suite, dev_add_lun_no_free_lun_id); 672 CU_ADD_TEST(suite, dev_add_lun_success1); 673 CU_ADD_TEST(suite, dev_add_lun_success2); 674 CU_ADD_TEST(suite, dev_check_pending_tasks); 675 676 CU_basic_set_mode(CU_BRM_VERBOSE); 677 CU_basic_run_tests(); 678 num_failures = CU_get_number_of_failures(); 679 CU_cleanup_registry(); 680 681 return num_failures; 682 } 683