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 #include "spdk/stdinc.h" 34 35 #include "spdk_cunit.h" 36 #include "CUnit/Basic.h" 37 38 #include "iscsi/init_grp.c" 39 #include "unit/lib/json_mock.c" 40 41 SPDK_LOG_REGISTER_COMPONENT("iscsi", SPDK_LOG_ISCSI) 42 43 struct spdk_iscsi_globals g_spdk_iscsi; 44 45 const char *config_file; 46 47 static int 48 test_setup(void) 49 { 50 TAILQ_INIT(&g_spdk_iscsi.ig_head); 51 return 0; 52 } 53 54 static void 55 create_from_config_file_cases(void) 56 { 57 struct spdk_conf *config; 58 struct spdk_conf_section *sp; 59 char section_name[64]; 60 int section_index; 61 int rc; 62 63 config = spdk_conf_allocate(); 64 65 rc = spdk_conf_read(config, config_file); 66 CU_ASSERT(rc == 0); 67 68 section_index = 0; 69 while (true) { 70 snprintf(section_name, sizeof(section_name), "IG_Valid%d", section_index); 71 72 sp = spdk_conf_find_section(config, section_name); 73 if (sp == NULL) { 74 break; 75 } 76 77 rc = iscsi_parse_init_grp(sp); 78 CU_ASSERT(rc == 0); 79 80 spdk_iscsi_init_grps_destroy(); 81 82 section_index++; 83 } 84 85 section_index = 0; 86 while (true) { 87 snprintf(section_name, sizeof(section_name), "IG_Invalid%d", section_index); 88 89 sp = spdk_conf_find_section(config, section_name); 90 if (sp == NULL) { 91 break; 92 } 93 94 rc = iscsi_parse_init_grp(sp); 95 CU_ASSERT(rc != 0); 96 97 spdk_iscsi_init_grps_destroy(); 98 99 section_index++; 100 } 101 102 spdk_conf_free(config); 103 } 104 105 106 static void 107 create_initiator_group_success_case(void) 108 { 109 struct spdk_iscsi_init_grp *ig; 110 111 ig = iscsi_init_grp_create(1); 112 CU_ASSERT(ig != NULL); 113 114 spdk_iscsi_init_grp_destroy(ig); 115 } 116 117 static void 118 find_initiator_group_success_case(void) 119 { 120 struct spdk_iscsi_init_grp *ig, *tmp; 121 int rc; 122 123 ig = iscsi_init_grp_create(1); 124 CU_ASSERT(ig != NULL); 125 126 rc = spdk_iscsi_init_grp_register(ig); 127 CU_ASSERT(rc == 0); 128 129 ig = spdk_iscsi_init_grp_find_by_tag(1); 130 CU_ASSERT(ig != NULL); 131 132 tmp = spdk_iscsi_init_grp_unregister(1); 133 CU_ASSERT(ig == tmp); 134 spdk_iscsi_init_grp_destroy(ig); 135 136 ig = spdk_iscsi_init_grp_find_by_tag(1); 137 CU_ASSERT(ig == NULL); 138 } 139 140 static void 141 register_initiator_group_twice_case(void) 142 { 143 struct spdk_iscsi_init_grp *ig, *tmp; 144 int rc; 145 146 ig = iscsi_init_grp_create(1); 147 CU_ASSERT(ig != NULL); 148 149 rc = spdk_iscsi_init_grp_register(ig); 150 CU_ASSERT(rc == 0); 151 152 rc = spdk_iscsi_init_grp_register(ig); 153 CU_ASSERT(rc != 0); 154 155 ig = spdk_iscsi_init_grp_find_by_tag(1); 156 CU_ASSERT(ig != NULL); 157 158 tmp = spdk_iscsi_init_grp_unregister(1); 159 CU_ASSERT(tmp == ig); 160 spdk_iscsi_init_grp_destroy(ig); 161 162 ig = spdk_iscsi_init_grp_find_by_tag(1); 163 CU_ASSERT(ig == NULL); 164 } 165 166 static void 167 add_initiator_name_success_case(void) 168 { 169 170 int rc; 171 struct spdk_iscsi_init_grp *ig; 172 struct spdk_iscsi_initiator_name *iname; 173 char *name1 = "iqn.2017-10.spdk.io:0001"; 174 char *name2 = "iqn.2017-10.spdk.io:0002"; 175 176 ig = iscsi_init_grp_create(1); 177 CU_ASSERT(ig != NULL); 178 179 /* add two different names to the empty name list */ 180 rc = iscsi_init_grp_add_initiator(ig, name1); 181 CU_ASSERT(rc == 0); 182 183 rc = iscsi_init_grp_add_initiator(ig, name2); 184 CU_ASSERT(rc == 0); 185 186 /* check if two names are added correctly. */ 187 iname = iscsi_init_grp_find_initiator(ig, name1); 188 CU_ASSERT(iname != NULL); 189 190 iname = iscsi_init_grp_find_initiator(ig, name2); 191 CU_ASSERT(iname != NULL); 192 193 /* restore the initial state */ 194 rc = iscsi_init_grp_delete_initiator(ig, name1); 195 CU_ASSERT(rc == 0); 196 197 iname = iscsi_init_grp_find_initiator(ig, name1); 198 CU_ASSERT(iname == NULL); 199 200 rc = iscsi_init_grp_delete_initiator(ig, name2); 201 CU_ASSERT(rc == 0); 202 203 iname = iscsi_init_grp_find_initiator(ig, name2); 204 CU_ASSERT(iname == NULL); 205 206 spdk_iscsi_init_grp_destroy(ig); 207 } 208 209 static void 210 add_initiator_name_fail_case(void) 211 { 212 int rc; 213 struct spdk_iscsi_init_grp *ig; 214 struct spdk_iscsi_initiator_name *iname; 215 char *name1 = "iqn.2017-10.spdk.io:0001"; 216 217 ig = iscsi_init_grp_create(1); 218 CU_ASSERT(ig != NULL); 219 220 /* add an name to the full name list */ 221 ig->ninitiators = MAX_INITIATOR; 222 223 rc = iscsi_init_grp_add_initiator(ig, name1); 224 CU_ASSERT(rc != 0); 225 226 ig->ninitiators = 0; 227 228 /* add the same name to the name list twice */ 229 rc = iscsi_init_grp_add_initiator(ig, name1); 230 CU_ASSERT(rc == 0); 231 232 rc = iscsi_init_grp_add_initiator(ig, name1); 233 CU_ASSERT(rc != 0); 234 235 /* restore the initial state */ 236 rc = iscsi_init_grp_delete_initiator(ig, name1); 237 CU_ASSERT(rc == 0); 238 239 iname = iscsi_init_grp_find_initiator(ig, name1); 240 CU_ASSERT(iname == NULL); 241 242 spdk_iscsi_init_grp_destroy(ig); 243 } 244 245 static void 246 delete_all_initiator_names_success_case(void) 247 { 248 int rc; 249 struct spdk_iscsi_init_grp *ig; 250 struct spdk_iscsi_initiator_name *iname; 251 char *name1 = "iqn.2017-10.spdk.io:0001"; 252 char *name2 = "iqn.2017-10.spdk.io:0002"; 253 254 ig = iscsi_init_grp_create(1); 255 CU_ASSERT(ig != NULL); 256 257 /* add two different names to the empty name list */ 258 rc = iscsi_init_grp_add_initiator(ig, name1); 259 CU_ASSERT(rc == 0); 260 261 rc = iscsi_init_grp_add_initiator(ig, name2); 262 CU_ASSERT(rc == 0); 263 264 /* delete all initiator names */ 265 iscsi_init_grp_delete_all_initiators(ig); 266 267 /* check if two names are deleted correctly. */ 268 iname = iscsi_init_grp_find_initiator(ig, name1); 269 CU_ASSERT(iname == NULL); 270 271 iname = iscsi_init_grp_find_initiator(ig, name2); 272 CU_ASSERT(iname == NULL); 273 274 /* restore the initial state */ 275 spdk_iscsi_init_grp_destroy(ig); 276 } 277 278 static void 279 add_netmask_success_case(void) 280 { 281 int rc; 282 struct spdk_iscsi_init_grp *ig; 283 struct spdk_iscsi_initiator_netmask *imask; 284 char *netmask1 = "192.168.2.0"; 285 char *netmask2 = "192.168.2.1"; 286 287 ig = iscsi_init_grp_create(1); 288 CU_ASSERT(ig != NULL); 289 290 /* add two different netmasks to the empty netmask list */ 291 rc = iscsi_init_grp_add_netmask(ig, netmask1); 292 CU_ASSERT(rc == 0); 293 294 rc = iscsi_init_grp_add_netmask(ig, netmask2); 295 CU_ASSERT(rc == 0); 296 297 /* check if two netmasks are added correctly. */ 298 imask = iscsi_init_grp_find_netmask(ig, netmask1); 299 CU_ASSERT(imask != NULL); 300 301 imask = iscsi_init_grp_find_netmask(ig, netmask2); 302 CU_ASSERT(imask != NULL); 303 304 /* restore the initial state */ 305 rc = iscsi_init_grp_delete_netmask(ig, netmask1); 306 CU_ASSERT(rc == 0); 307 308 imask = iscsi_init_grp_find_netmask(ig, netmask1); 309 CU_ASSERT(imask == NULL); 310 311 rc = iscsi_init_grp_delete_netmask(ig, netmask2); 312 CU_ASSERT(rc == 0); 313 314 imask = iscsi_init_grp_find_netmask(ig, netmask2); 315 CU_ASSERT(imask == NULL); 316 317 spdk_iscsi_init_grp_destroy(ig); 318 } 319 320 static void 321 add_netmask_fail_case(void) 322 { 323 int rc; 324 struct spdk_iscsi_init_grp *ig; 325 struct spdk_iscsi_initiator_netmask *imask; 326 char *netmask1 = "192.168.2.0"; 327 328 ig = iscsi_init_grp_create(1); 329 CU_ASSERT(ig != NULL); 330 331 /* add an netmask to the full netmask list */ 332 ig->nnetmasks = MAX_NETMASK; 333 334 rc = iscsi_init_grp_add_netmask(ig, netmask1); 335 CU_ASSERT(rc != 0); 336 337 ig->nnetmasks = 0; 338 339 /* add the same netmask to the netmask list twice */ 340 rc = iscsi_init_grp_add_netmask(ig, netmask1); 341 CU_ASSERT(rc == 0); 342 343 rc = iscsi_init_grp_add_netmask(ig, netmask1); 344 CU_ASSERT(rc != 0); 345 346 /* restore the initial state */ 347 rc = iscsi_init_grp_delete_netmask(ig, netmask1); 348 CU_ASSERT(rc == 0); 349 350 imask = iscsi_init_grp_find_netmask(ig, netmask1); 351 CU_ASSERT(imask == NULL); 352 353 spdk_iscsi_init_grp_destroy(ig); 354 } 355 356 static void 357 delete_all_netmasks_success_case(void) 358 { 359 int rc; 360 struct spdk_iscsi_init_grp *ig; 361 struct spdk_iscsi_initiator_netmask *imask; 362 char *netmask1 = "192.168.2.0"; 363 char *netmask2 = "192.168.2.1"; 364 365 ig = iscsi_init_grp_create(1); 366 CU_ASSERT(ig != NULL); 367 368 /* add two different netmasks to the empty netmask list */ 369 rc = iscsi_init_grp_add_netmask(ig, netmask1); 370 CU_ASSERT(rc == 0); 371 372 rc = iscsi_init_grp_add_netmask(ig, netmask2); 373 CU_ASSERT(rc == 0); 374 375 /* delete all netmasks */ 376 iscsi_init_grp_delete_all_netmasks(ig); 377 378 /* check if two netmasks are deleted correctly. */ 379 imask = iscsi_init_grp_find_netmask(ig, netmask1); 380 CU_ASSERT(imask == NULL); 381 382 imask = iscsi_init_grp_find_netmask(ig, netmask2); 383 CU_ASSERT(imask == NULL); 384 385 /* restore the initial state */ 386 spdk_iscsi_init_grp_destroy(ig); 387 } 388 389 static void 390 initiator_name_overwrite_all_to_any_case(void) 391 { 392 int rc; 393 struct spdk_iscsi_init_grp *ig; 394 struct spdk_iscsi_initiator_name *iname; 395 char *all = "ALL"; 396 char *any = "ANY"; 397 char *all_not = "!ALL"; 398 char *any_not = "!ANY"; 399 400 ig = iscsi_init_grp_create(1); 401 CU_ASSERT(ig != NULL); 402 403 rc = iscsi_init_grp_add_initiator(ig, all); 404 CU_ASSERT(rc == 0); 405 406 iname = iscsi_init_grp_find_initiator(ig, all); 407 CU_ASSERT(iname == NULL); 408 409 iname = iscsi_init_grp_find_initiator(ig, any); 410 CU_ASSERT(iname != NULL); 411 412 rc = iscsi_init_grp_delete_initiator(ig, any); 413 CU_ASSERT(rc == 0); 414 415 rc = iscsi_init_grp_add_initiator(ig, all_not); 416 CU_ASSERT(rc == 0); 417 418 iname = iscsi_init_grp_find_initiator(ig, all_not); 419 CU_ASSERT(iname == NULL); 420 421 iname = iscsi_init_grp_find_initiator(ig, any_not); 422 CU_ASSERT(iname != NULL); 423 424 rc = iscsi_init_grp_delete_initiator(ig, any_not); 425 CU_ASSERT(rc == 0); 426 427 spdk_iscsi_init_grp_destroy(ig); 428 } 429 430 static void 431 netmask_overwrite_all_to_any_case(void) 432 { 433 int rc; 434 struct spdk_iscsi_init_grp *ig; 435 struct spdk_iscsi_initiator_netmask *imask; 436 char *all = "ALL"; 437 char *any = "ANY"; 438 439 ig = iscsi_init_grp_create(1); 440 CU_ASSERT(ig != NULL); 441 442 rc = iscsi_init_grp_add_netmask(ig, all); 443 CU_ASSERT(rc == 0); 444 445 imask = iscsi_init_grp_find_netmask(ig, all); 446 CU_ASSERT(imask == NULL); 447 448 imask = iscsi_init_grp_find_netmask(ig, any); 449 CU_ASSERT(imask != NULL); 450 451 rc = iscsi_init_grp_delete_netmask(ig, any); 452 CU_ASSERT(rc == 0); 453 454 spdk_iscsi_init_grp_destroy(ig); 455 } 456 457 static void 458 add_delete_initiator_names_case(void) 459 { 460 int rc, i; 461 struct spdk_iscsi_init_grp *ig; 462 struct spdk_iscsi_initiator_name *iname; 463 char *names[3] = {"iqn.2018-02.spdk.io:0001", "iqn.2018-02.spdk.io:0002", "iqn.2018-02.spdk.io:0003"}; 464 465 ig = iscsi_init_grp_create(1); 466 SPDK_CU_ASSERT_FATAL(ig != NULL); 467 468 rc = iscsi_init_grp_add_initiators(ig, 3, names); 469 CU_ASSERT(rc == 0); 470 471 for (i = 0; i < 3; i++) { 472 iname = iscsi_init_grp_find_initiator(ig, names[i]); 473 CU_ASSERT(iname != NULL); 474 } 475 476 rc = iscsi_init_grp_delete_initiators(ig, 3, names); 477 CU_ASSERT(rc == 0); 478 479 if (ig != NULL) { 480 CU_ASSERT(TAILQ_EMPTY(&ig->initiator_head)); 481 } 482 483 spdk_iscsi_init_grp_destroy(ig); 484 } 485 486 static void 487 add_duplicated_initiator_names_case(void) 488 { 489 int rc; 490 struct spdk_iscsi_init_grp *ig; 491 char *names[3] = {"iqn.2018-02.spdk.io:0001", "iqn.2018-02.spdk.io:0002", "iqn.2018-02.spdk.io:0001"}; 492 493 ig = iscsi_init_grp_create(1); 494 SPDK_CU_ASSERT_FATAL(ig != NULL); 495 496 rc = iscsi_init_grp_add_initiators(ig, 3, names); 497 CU_ASSERT(rc != 0); 498 499 if (ig != NULL) { 500 CU_ASSERT(TAILQ_EMPTY(&ig->initiator_head)); 501 } 502 503 spdk_iscsi_init_grp_destroy(ig); 504 } 505 506 static void 507 delete_nonexisting_initiator_names_case(void) 508 { 509 int rc, i; 510 struct spdk_iscsi_init_grp *ig; 511 struct spdk_iscsi_initiator_name *iname; 512 char *names1[3] = {"iqn.2018-02.spdk.io:0001", "iqn.2018-02.spdk.io:0002", "iqn.2018-02.spdk.io:0003"}; 513 char *names2[3] = {"iqn.2018-02.spdk.io:0001", "iqn.2018-02.spdk.io:0002", "iqn.2018-02.spdk.io:0004"}; 514 515 ig = iscsi_init_grp_create(1); 516 SPDK_CU_ASSERT_FATAL(ig != NULL); 517 518 rc = iscsi_init_grp_add_initiators(ig, 3, names1); 519 CU_ASSERT(rc == 0); 520 521 for (i = 0; i < 3; i++) { 522 iname = iscsi_init_grp_find_initiator(ig, names1[i]); 523 CU_ASSERT(iname != NULL); 524 } 525 526 rc = iscsi_init_grp_delete_initiators(ig, 3, names2); 527 CU_ASSERT(rc != 0); 528 529 for (i = 0; i < 3; i++) { 530 iname = iscsi_init_grp_find_initiator(ig, names1[i]); 531 CU_ASSERT(iname != NULL); 532 } 533 534 rc = iscsi_init_grp_delete_initiators(ig, 3, names1); 535 CU_ASSERT(rc == 0); 536 537 if (ig != NULL) { 538 CU_ASSERT(TAILQ_EMPTY(&ig->initiator_head)); 539 } 540 541 spdk_iscsi_init_grp_destroy(ig); 542 } 543 544 static void 545 add_delete_netmasks_case(void) 546 { 547 int rc, i; 548 struct spdk_iscsi_init_grp *ig; 549 struct spdk_iscsi_initiator_netmask *netmask; 550 char *netmasks[3] = {"192.168.2.0", "192.168.2.1", "192.168.2.2"}; 551 552 ig = iscsi_init_grp_create(1); 553 SPDK_CU_ASSERT_FATAL(ig != NULL); 554 555 rc = iscsi_init_grp_add_netmasks(ig, 3, netmasks); 556 CU_ASSERT(rc == 0); 557 558 for (i = 0; i < 3; i++) { 559 netmask = iscsi_init_grp_find_netmask(ig, netmasks[i]); 560 CU_ASSERT(netmask != NULL); 561 } 562 563 rc = iscsi_init_grp_delete_netmasks(ig, 3, netmasks); 564 CU_ASSERT(rc == 0); 565 566 if (ig != NULL) { 567 CU_ASSERT(TAILQ_EMPTY(&ig->netmask_head)); 568 } 569 570 spdk_iscsi_init_grp_destroy(ig); 571 } 572 573 static void 574 add_duplicated_netmasks_case(void) 575 { 576 int rc; 577 struct spdk_iscsi_init_grp *ig; 578 char *netmasks[3] = {"192.168.2.0", "192.168.2.1", "192.168.2.0"}; 579 580 ig = iscsi_init_grp_create(1); 581 SPDK_CU_ASSERT_FATAL(ig != NULL); 582 583 rc = iscsi_init_grp_add_netmasks(ig, 3, netmasks); 584 CU_ASSERT(rc != 0); 585 586 if (ig != NULL) { 587 CU_ASSERT(TAILQ_EMPTY(&ig->netmask_head)); 588 } 589 590 spdk_iscsi_init_grp_destroy(ig); 591 } 592 593 static void 594 delete_nonexisting_netmasks_case(void) 595 { 596 int rc, i; 597 struct spdk_iscsi_init_grp *ig; 598 struct spdk_iscsi_initiator_netmask *netmask; 599 char *netmasks1[3] = {"192.168.2.0", "192.168.2.1", "192.168.2.2"}; 600 char *netmasks2[3] = {"192.168.2.0", "192.168.2.1", "192.168.2.3"}; 601 602 ig = iscsi_init_grp_create(1); 603 SPDK_CU_ASSERT_FATAL(ig != NULL); 604 605 rc = iscsi_init_grp_add_netmasks(ig, 3, netmasks1); 606 CU_ASSERT(rc == 0); 607 608 for (i = 0; i < 3; i++) { 609 netmask = iscsi_init_grp_find_netmask(ig, netmasks1[i]); 610 CU_ASSERT(netmask != NULL); 611 } 612 613 rc = iscsi_init_grp_delete_netmasks(ig, 3, netmasks2); 614 CU_ASSERT(rc != 0); 615 616 for (i = 0; i < 3; i++) { 617 netmask = iscsi_init_grp_find_netmask(ig, netmasks1[i]); 618 CU_ASSERT(netmask != NULL); 619 } 620 621 rc = iscsi_init_grp_delete_netmasks(ig, 3, netmasks1); 622 CU_ASSERT(rc == 0); 623 624 if (ig != NULL) { 625 CU_ASSERT(TAILQ_EMPTY(&ig->netmask_head)); 626 } 627 628 spdk_iscsi_init_grp_destroy(ig); 629 } 630 631 632 int 633 main(int argc, char **argv) 634 { 635 CU_pSuite suite = NULL; 636 unsigned int num_failures; 637 638 if (argc < 2) { 639 fprintf(stderr, "usage: %s <config file>\n", argv[0]); 640 exit(1); 641 } 642 643 if (CU_initialize_registry() != CUE_SUCCESS) { 644 return CU_get_error(); 645 } 646 647 config_file = argv[1]; 648 649 suite = CU_add_suite("init_grp_suite", test_setup, NULL); 650 if (suite == NULL) { 651 CU_cleanup_registry(); 652 return CU_get_error(); 653 } 654 655 if ( 656 CU_add_test(suite, "create from config file cases", 657 create_from_config_file_cases) == NULL 658 || CU_add_test(suite, "create initiator group success case", 659 create_initiator_group_success_case) == NULL 660 || CU_add_test(suite, "find initiator group success case", 661 find_initiator_group_success_case) == NULL 662 || CU_add_test(suite, "register initiator group twice case", 663 register_initiator_group_twice_case) == NULL 664 || CU_add_test(suite, "add initiator name success case", 665 add_initiator_name_success_case) == NULL 666 || CU_add_test(suite, "add initiator name fail case", 667 add_initiator_name_fail_case) == NULL 668 || CU_add_test(suite, "delete all initiator names success case", 669 delete_all_initiator_names_success_case) == NULL 670 || CU_add_test(suite, "add initiator netmask success case", 671 add_netmask_success_case) == NULL 672 || CU_add_test(suite, "add initiator netmask fail case", 673 add_netmask_fail_case) == NULL 674 || CU_add_test(suite, "delete all initiator netmasks success case", 675 delete_all_netmasks_success_case) == NULL 676 || CU_add_test(suite, "overwrite all to any for name case", 677 initiator_name_overwrite_all_to_any_case) == NULL 678 || CU_add_test(suite, "overwrite all to any for netmask case", 679 netmask_overwrite_all_to_any_case) == NULL 680 || CU_add_test(suite, "add/delete initiator names case", 681 add_delete_initiator_names_case) == NULL 682 || CU_add_test(suite, "add duplicated initiator names case", 683 add_duplicated_initiator_names_case) == NULL 684 || CU_add_test(suite, "delete nonexisting initiator names case", 685 delete_nonexisting_initiator_names_case) == NULL 686 || CU_add_test(suite, "add/delete netmasks case", 687 add_delete_netmasks_case) == NULL 688 || CU_add_test(suite, "add duplicated netmasks case", 689 add_duplicated_netmasks_case) == NULL 690 || CU_add_test(suite, "delete nonexisting netmasks case", 691 delete_nonexisting_netmasks_case) == NULL 692 ) { 693 CU_cleanup_registry(); 694 return CU_get_error(); 695 } 696 697 CU_basic_set_mode(CU_BRM_VERBOSE); 698 CU_basic_run_tests(); 699 num_failures = CU_get_number_of_failures(); 700 CU_cleanup_registry(); 701 return num_failures; 702 } 703