test_list.c (26045B)
1 /* This Source Code Form is subject to the terms of the Mozilla Public 2 * License, v. 2.0. If a copy of the MPL was not distributed with this 3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ 4 /* 5 * test_list.c 6 * 7 * Tests List Objects 8 * 9 */ 10 11 #include "testutil.h" 12 #include "testutil_nss.h" 13 14 static void *plContext = NULL; 15 16 static void 17 createLists(PKIX_List **list, PKIX_List **list2) 18 { 19 PKIX_TEST_STD_VARS(); 20 21 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(list, plContext)); 22 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(list2, plContext)); 23 24 cleanup: 25 26 PKIX_TEST_RETURN(); 27 } 28 29 static void 30 testReverseList(void) 31 { 32 PKIX_List *firstList = NULL; 33 PKIX_List *reverseList = NULL; 34 PKIX_UInt32 length, i; 35 char *testItemString = "one"; 36 char *testItemString2 = "two"; 37 PKIX_PL_String *testItem = NULL; 38 PKIX_PL_String *testItem2 = NULL; 39 PKIX_PL_Object *retrievedItem1 = NULL; 40 PKIX_PL_Object *retrievedItem2 = NULL; 41 42 PKIX_TEST_STD_VARS(); 43 44 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(&firstList, plContext)); 45 46 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_ReverseList(firstList, &reverseList, plContext)); 47 48 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength(reverseList, &length, plContext)); 49 if (length != 0) { 50 testError("Incorrect Length returned"); 51 } 52 53 PKIX_TEST_DECREF_BC(reverseList); 54 55 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, 56 testItemString, 57 0, 58 &testItem, 59 plContext)); 60 61 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, 62 testItemString2, 63 0, 64 &testItem2, 65 plContext)); 66 67 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(firstList, 68 (PKIX_PL_Object *)testItem, 69 plContext)); 70 71 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_ReverseList(firstList, &reverseList, plContext)); 72 73 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength(reverseList, &length, plContext)); 74 if (length != 1) { 75 testError("Incorrect Length returned"); 76 } 77 78 PKIX_TEST_DECREF_BC(reverseList); 79 80 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(firstList, 81 (PKIX_PL_Object *)testItem2, 82 plContext)); 83 84 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(firstList, 85 (PKIX_PL_Object *)testItem, 86 plContext)); 87 88 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(firstList, 89 (PKIX_PL_Object *)testItem2, 90 plContext)); 91 92 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_ReverseList(firstList, &reverseList, plContext)); 93 94 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength(reverseList, &length, plContext)); 95 if (length != 4) { 96 testError("Incorrect Length returned"); 97 } 98 99 for (i = 0; i < length; i++) { 100 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetItem(firstList, 101 i, 102 &retrievedItem1, 103 plContext)); 104 105 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetItem(reverseList, 106 (length - 1) - i, 107 &retrievedItem2, 108 plContext)); 109 110 testEqualsHelper(retrievedItem1, retrievedItem2, PKIX_TRUE, plContext); 111 112 PKIX_TEST_DECREF_BC(retrievedItem1); 113 PKIX_TEST_DECREF_BC(retrievedItem2); 114 } 115 116 cleanup: 117 118 PKIX_TEST_DECREF_AC(firstList); 119 PKIX_TEST_DECREF_AC(reverseList); 120 121 PKIX_TEST_DECREF_AC(testItem); 122 PKIX_TEST_DECREF_AC(testItem2); 123 124 PKIX_TEST_DECREF_AC(retrievedItem1); 125 PKIX_TEST_DECREF_AC(retrievedItem2); 126 127 PKIX_TEST_RETURN(); 128 } 129 130 static void 131 testZeroLengthList(PKIX_List *list) 132 { 133 PKIX_UInt32 length; 134 PKIX_Boolean empty; 135 char *testItemString = "hello"; 136 PKIX_PL_String *testItem = NULL; 137 PKIX_PL_String *retrievedItem = NULL; 138 PKIX_List *diffList = NULL; 139 140 PKIX_TEST_STD_VARS(); 141 142 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(&diffList, plContext)); 143 144 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength(list, &length, plContext)); 145 146 if (length != 0) { 147 testError("Incorrect Length returned"); 148 } 149 150 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_IsEmpty(list, &empty, plContext)); 151 if (!empty) { 152 testError("Incorrect result for PKIX_List_IsEmpty"); 153 } 154 155 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, 156 testItemString, 157 0, 158 &testItem, 159 plContext)); 160 161 PKIX_TEST_EXPECT_ERROR(PKIX_List_InsertItem(list, 0, (PKIX_PL_Object *)testItem, plContext)); 162 163 PKIX_TEST_EXPECT_ERROR(PKIX_List_SetItem(list, 0, (PKIX_PL_Object *)testItem, plContext)); 164 165 PKIX_TEST_EXPECT_ERROR(PKIX_List_GetItem(list, 166 0, 167 (PKIX_PL_Object **)&retrievedItem, 168 plContext)); 169 170 PKIX_TEST_EXPECT_ERROR(PKIX_List_DeleteItem(list, 0, plContext)); 171 172 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(diffList, 173 (PKIX_PL_Object *)testItem, 174 plContext)); 175 176 testDuplicateHelper((PKIX_PL_Object *)diffList, plContext); 177 178 PKIX_TEST_EQ_HASH_TOSTR_DUP(list, list, diffList, "(EMPTY)", List, PKIX_TRUE); 179 180 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength(diffList, &length, plContext)); 181 if (length != 1) { 182 testError("Incorrect Length returned"); 183 } 184 185 PKIX_TEST_EXPECT_ERROR(PKIX_List_DeleteItem(list, 1, plContext)); 186 187 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_DeleteItem(diffList, 0, plContext)); 188 189 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength(diffList, &length, plContext)); 190 if (length != 0) { 191 testError("Incorrect Length returned"); 192 } 193 194 cleanup: 195 196 PKIX_TEST_DECREF_AC(testItem); 197 PKIX_TEST_DECREF_AC(diffList); 198 PKIX_TEST_RETURN(); 199 } 200 201 static void 202 testGetLength(PKIX_List *list) 203 { 204 PKIX_UInt32 length; 205 PKIX_TEST_STD_VARS(); 206 207 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength(list, &length, plContext)); 208 209 if (length != 3) { 210 testError("Incorrect Length returned"); 211 } 212 213 cleanup: 214 215 PKIX_TEST_RETURN(); 216 } 217 218 static void 219 testGetSetItem( 220 PKIX_List *list, 221 char *testItemString, 222 char *testItemString2, 223 char *testItemString3, 224 PKIX_PL_String **testItem, 225 PKIX_PL_String **testItem2, 226 PKIX_PL_String **testItem3) 227 { 228 PKIX_PL_Object *tempItem = NULL; 229 char *temp = NULL; 230 231 PKIX_TEST_STD_VARS(); 232 233 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, 234 testItemString, 235 PL_strlen(testItemString), 236 testItem, 237 plContext)); 238 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, 239 testItemString2, 240 PL_strlen(testItemString2), 241 testItem2, 242 plContext)); 243 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, 244 testItemString3, 245 PL_strlen(testItemString3), 246 testItem3, 247 plContext)); 248 249 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list, (PKIX_PL_Object *)*testItem, plContext)); 250 251 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list, (PKIX_PL_Object *)*testItem, plContext)); 252 253 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list, (PKIX_PL_Object *)*testItem, plContext)); 254 255 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_SetItem(list, 0, (PKIX_PL_Object *)*testItem, plContext)); 256 257 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_SetItem(list, 1, (PKIX_PL_Object *)*testItem2, plContext)); 258 259 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_SetItem(list, 2, (PKIX_PL_Object *)*testItem3, plContext)); 260 261 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetItem(list, 0, &tempItem, plContext)); 262 263 temp = PKIX_String2ASCII((PKIX_PL_String *)tempItem, plContext); 264 if (temp) { 265 if (PL_strcmp(testItemString, temp) != 0) 266 testError("GetItem from list is incorrect"); 267 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); 268 } 269 270 PKIX_TEST_DECREF_BC(tempItem); 271 272 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetItem(list, 1, &tempItem, plContext)); 273 274 temp = PKIX_String2ASCII((PKIX_PL_String *)tempItem, plContext); 275 if (temp) { 276 if (PL_strcmp(testItemString2, temp) != 0) 277 testError("GetItem from list is incorrect"); 278 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); 279 } 280 PKIX_TEST_DECREF_BC(tempItem); 281 282 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetItem(list, 2, &tempItem, plContext)); 283 284 temp = PKIX_String2ASCII((PKIX_PL_String *)tempItem, plContext); 285 if (temp) { 286 if (PL_strcmp(testItemString3, temp) != 0) 287 testError("GetItem from list is incorrect"); 288 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); 289 } 290 PKIX_TEST_DECREF_BC(tempItem); 291 292 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_SetItem(list, 0, (PKIX_PL_Object *)*testItem3, plContext)); 293 temp = PKIX_String2ASCII(*testItem3, plContext); 294 if (temp) { 295 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); 296 } 297 298 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetItem(list, 0, &tempItem, plContext)); 299 300 temp = PKIX_String2ASCII((PKIX_PL_String *)tempItem, plContext); 301 if (temp) { 302 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); 303 } 304 305 temp = PKIX_String2ASCII((PKIX_PL_String *)tempItem, plContext); 306 if (temp) { 307 if (PL_strcmp(testItemString3, temp) != 0) 308 testError("GetItem from list is incorrect"); 309 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); 310 } 311 PKIX_TEST_DECREF_BC(tempItem); 312 313 cleanup: 314 315 PKIX_TEST_RETURN(); 316 } 317 318 static void 319 testInsertItem( 320 PKIX_List *list, 321 PKIX_PL_String *testItem, 322 char *testItemString) 323 { 324 PKIX_PL_Object *tempItem = NULL; 325 PKIX_PL_String *outputString = NULL; 326 char *temp = NULL; 327 328 PKIX_TEST_STD_VARS(); 329 330 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_InsertItem(list, 0, (PKIX_PL_Object *)testItem, plContext)); 331 332 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetItem(list, 0, &tempItem, plContext)); 333 334 temp = PKIX_String2ASCII((PKIX_PL_String *)tempItem, plContext); 335 if (temp) { 336 if (PL_strcmp(testItemString, temp) != 0) 337 testError("GetItem from list is incorrect"); 338 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); 339 } 340 PKIX_TEST_DECREF_BC(tempItem); 341 342 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list, 343 &outputString, 344 plContext)); 345 346 temp = PKIX_String2ASCII(outputString, plContext); 347 if (temp) { 348 if (PL_strcmp("(a, c, b, c)", temp) != 0) 349 testError("List toString is Incorrect"); 350 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); 351 } 352 353 PKIX_TEST_DECREF_BC(outputString); 354 355 cleanup: 356 357 PKIX_TEST_RETURN(); 358 } 359 360 static void 361 testAppendItem(PKIX_List *list, PKIX_PL_String *testItem) 362 { 363 PKIX_UInt32 length2; 364 PKIX_PL_String *outputString = NULL; 365 char *temp = NULL; 366 367 PKIX_TEST_STD_VARS(); 368 369 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_GetLength(list, &length2, plContext)); 370 371 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list, 372 (PKIX_PL_Object *)testItem, 373 plContext)); 374 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list, 375 &outputString, 376 plContext)); 377 378 temp = PKIX_String2ASCII(outputString, plContext); 379 if (temp) { 380 if (PL_strcmp("(a, c, b, c, a)", temp) != 0) 381 testError("List toString is Incorrect"); 382 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); 383 } 384 385 PKIX_TEST_DECREF_BC(outputString); 386 387 cleanup: 388 389 PKIX_TEST_RETURN(); 390 } 391 392 static void 393 testNestedLists( 394 PKIX_List *list, 395 PKIX_List *list2, 396 PKIX_PL_String *testItem, 397 PKIX_PL_String *testItem2) 398 { 399 PKIX_PL_String *outputString = NULL; 400 char *temp = NULL; 401 402 PKIX_TEST_STD_VARS(); 403 404 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list2, (PKIX_PL_Object *)testItem, plContext)); 405 406 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list2, 407 (PKIX_PL_Object *)NULL, 408 plContext)); 409 410 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list2, 411 (PKIX_PL_Object *)testItem, 412 plContext)); 413 414 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list2, 415 &outputString, 416 plContext)); 417 418 temp = PKIX_String2ASCII(outputString, plContext); 419 if (temp) { 420 if (PL_strcmp("(a, (null), a)", temp) != 0) 421 testError("List toString is Incorrect"); 422 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); 423 } 424 PKIX_TEST_DECREF_BC(outputString); 425 426 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_InsertItem(list, 1, 427 (PKIX_PL_Object *)list2, 428 plContext)); 429 430 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list, 431 &outputString, 432 plContext)); 433 434 temp = PKIX_String2ASCII(outputString, plContext); 435 if (temp) { 436 if (PL_strcmp("(a, (a, (null), a), c, b, c, a)", temp) != 0) 437 testError("List toString is Incorrect"); 438 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); 439 } 440 PKIX_TEST_DECREF_BC(outputString); 441 442 cleanup: 443 444 PKIX_TEST_RETURN(); 445 } 446 447 static void 448 testDeleteItem( 449 PKIX_List *list, 450 PKIX_List *list2, 451 PKIX_PL_String *testItem2, 452 PKIX_PL_String *testItem3) 453 { 454 PKIX_PL_String *outputString = NULL; 455 char *temp = NULL; 456 457 PKIX_TEST_STD_VARS(); 458 459 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_DeleteItem(list, 5, plContext)); 460 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list, 461 &outputString, 462 plContext)); 463 464 temp = PKIX_String2ASCII(outputString, plContext); 465 if (temp) { 466 if (PL_strcmp("(a, (a, (null), a), c, b, c)", temp) != 0) 467 testError("List toString is Incorrect"); 468 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); 469 } 470 PKIX_TEST_DECREF_BC(outputString); 471 472 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_DeleteItem(list, 1, plContext)); 473 474 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list, 475 &outputString, 476 plContext)); 477 478 temp = PKIX_String2ASCII(outputString, plContext); 479 if (temp) { 480 if (PL_strcmp("(a, c, b, c)", temp) != 0) 481 testError("List toString is Incorrect"); 482 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); 483 } 484 PKIX_TEST_DECREF_BC(outputString); 485 486 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_DeleteItem(list, 0, plContext)); 487 488 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list, 489 &outputString, 490 plContext)); 491 492 temp = PKIX_String2ASCII(outputString, plContext); 493 if (temp) { 494 if (PL_strcmp("(c, b, c)", temp) != 0) 495 testError("List toString is Incorrect"); 496 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); 497 } 498 PKIX_TEST_DECREF_BC(outputString); 499 500 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_DeleteItem(list2, 1, plContext)); 501 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list2, 502 &outputString, 503 plContext)); 504 temp = PKIX_String2ASCII(outputString, plContext); 505 if (temp) { 506 if (PL_strcmp("(a, a)", temp) != 0) 507 testError("List toString is Incorrect"); 508 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); 509 } 510 PKIX_TEST_DECREF_BC(outputString); 511 512 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list2, 513 (PKIX_PL_Object *)testItem2, 514 plContext)); 515 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list2, 516 &outputString, 517 plContext)); 518 519 temp = PKIX_String2ASCII(outputString, plContext); 520 if (temp) { 521 if (PL_strcmp("(a, a, b)", temp) != 0) 522 testError("List toString is Incorrect"); 523 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); 524 } 525 PKIX_TEST_DECREF_BC(outputString); 526 527 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_DeleteItem(list2, 2, plContext)); 528 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list2, 529 &outputString, 530 plContext)); 531 532 temp = PKIX_String2ASCII(outputString, plContext); 533 if (temp) { 534 if (PL_strcmp("(a, a)", temp) != 0) 535 testError("List toString is Incorrect"); 536 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); 537 } 538 PKIX_TEST_DECREF_BC(outputString); 539 540 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list2, 541 (PKIX_PL_Object *)testItem3, 542 plContext)); 543 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Object_ToString((PKIX_PL_Object *)list2, 544 &outputString, 545 plContext)); 546 temp = PKIX_String2ASCII(outputString, plContext); 547 if (temp) { 548 if (PL_strcmp("(a, a, c)", temp) != 0) 549 testError("List toString is Incorrect"); 550 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext)); 551 } 552 PKIX_TEST_DECREF_BC(outputString); 553 554 PKIX_TEST_DECREF_BC(list2); 555 556 cleanup: 557 558 PKIX_TEST_RETURN(); 559 } 560 561 #if testContainsFunction 562 /* This test requires pkix_List_Contains to be in nss.def */ 563 static void 564 testContains(void) 565 { 566 567 PKIX_List *list; 568 PKIX_PL_String *testItem, *testItem2, *testItem3, *testItem4; 569 char *testItemString = "a"; 570 char *testItemString2 = "b"; 571 char *testItemString3 = "c"; 572 char *testItemString4 = "d"; 573 PKIX_Boolean found = PKIX_FALSE; 574 575 PKIX_TEST_STD_VARS(); 576 subTest("pkix_ListContains"); 577 578 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, 579 testItemString, 580 PL_strlen(testItemString), 581 &testItem, 582 plContext)); 583 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, 584 testItemString2, 585 PL_strlen(testItemString2), 586 &testItem2, 587 plContext)); 588 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, 589 testItemString3, 590 PL_strlen(testItemString3), 591 &testItem3, 592 plContext)); 593 PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII, 594 testItemString4, 595 PL_strlen(testItemString4), 596 &testItem4, 597 plContext)); 598 599 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(&list, plContext)); 600 601 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list, (PKIX_PL_Object *)testItem, plContext)); 602 603 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list, (PKIX_PL_Object *)testItem2, plContext)); 604 605 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list, (PKIX_PL_Object *)testItem3, plContext)); 606 607 subTest("pkix_List_Contains <object missing>"); 608 609 PKIX_TEST_EXPECT_NO_ERROR(pkix_List_Contains(list, (PKIX_PL_Object *)testItem4, &found, plContext)); 610 611 if (found) { 612 testError("Contains found item that wasn't there!"); 613 } 614 615 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_AppendItem(list, (PKIX_PL_Object *)testItem4, plContext)); 616 617 subTest("pkix_List_Contains <object present>"); 618 619 PKIX_TEST_EXPECT_NO_ERROR(pkix_List_Contains(list, (PKIX_PL_Object *)testItem4, &found, plContext)); 620 621 if (!found) { 622 testError("Contains missed item that was present!"); 623 } 624 625 PKIX_TEST_DECREF_BC(list); 626 PKIX_TEST_DECREF_BC(testItem); 627 PKIX_TEST_DECREF_BC(testItem2); 628 PKIX_TEST_DECREF_BC(testItem3); 629 PKIX_TEST_DECREF_BC(testItem4); 630 631 cleanup: 632 633 PKIX_TEST_RETURN(); 634 } 635 #endif 636 637 static void 638 testErrorHandling(void) 639 { 640 PKIX_List *emptylist = NULL; 641 PKIX_List *list = NULL; 642 PKIX_PL_Object *tempItem = NULL; 643 644 PKIX_TEST_STD_VARS(); 645 646 PKIX_TEST_EXPECT_NO_ERROR(PKIX_List_Create(&list, plContext)); 647 648 PKIX_TEST_EXPECT_ERROR(PKIX_List_GetItem(list, 4, &tempItem, plContext)); 649 650 PKIX_TEST_EXPECT_ERROR(PKIX_List_GetItem(list, 1, NULL, plContext)); 651 PKIX_TEST_EXPECT_ERROR(PKIX_List_SetItem(list, 4, tempItem, plContext)); 652 PKIX_TEST_EXPECT_ERROR(PKIX_List_SetItem(NULL, 1, tempItem, plContext)); 653 PKIX_TEST_EXPECT_ERROR(PKIX_List_InsertItem(list, 4, tempItem, plContext)); 654 655 PKIX_TEST_EXPECT_ERROR(PKIX_List_InsertItem(NULL, 1, tempItem, plContext)); 656 657 PKIX_TEST_EXPECT_ERROR(PKIX_List_AppendItem(NULL, tempItem, plContext)); 658 PKIX_TEST_EXPECT_ERROR(PKIX_List_DeleteItem(list, 5, plContext)); 659 PKIX_TEST_EXPECT_ERROR(PKIX_List_DeleteItem(NULL, 1, plContext)); 660 PKIX_TEST_EXPECT_ERROR(PKIX_List_GetLength(list, NULL, plContext)); 661 662 PKIX_TEST_DECREF_BC(list); 663 PKIX_TEST_DECREF_BC(emptylist); 664 665 cleanup: 666 667 PKIX_TEST_RETURN(); 668 } 669 670 static void 671 testDestroy(PKIX_List *list) 672 { 673 PKIX_TEST_STD_VARS(); 674 675 PKIX_TEST_DECREF_BC(list); 676 677 cleanup: 678 679 PKIX_TEST_RETURN(); 680 } 681 682 int 683 test_list(int argc, char *argv[]) 684 { 685 686 PKIX_List *list, *list2; 687 PKIX_PL_String *testItem, *testItem2, *testItem3; 688 char *testItemString = "a"; 689 char *testItemString2 = "b"; 690 char *testItemString3 = "c"; 691 PKIX_UInt32 actualMinorVersion; 692 PKIX_UInt32 j = 0; 693 694 PKIX_TEST_STD_VARS(); 695 696 startTests("Lists"); 697 698 PKIX_TEST_EXPECT_NO_ERROR( 699 PKIX_PL_NssContext_Create(0, PKIX_FALSE, NULL, &plContext)); 700 701 subTest("PKIX_List_Create"); 702 createLists(&list, &list2); 703 704 subTest("pkix_List_ReverseList"); 705 testReverseList(); 706 707 subTest("Zero-length List"); 708 testZeroLengthList(list); 709 710 subTest("PKIX_List_Get/SetItem"); 711 testGetSetItem(list, 712 testItemString, 713 testItemString2, 714 testItemString3, 715 &testItem, 716 &testItem2, 717 &testItem3); 718 719 subTest("PKIX_List_GetLength"); 720 testGetLength(list); 721 722 PKIX_TEST_EQ_HASH_TOSTR_DUP(list, 723 list, 724 list2, 725 "(c, b, c)", 726 List, 727 PKIX_TRUE); 728 729 subTest("PKIX_List_InsertItem"); 730 testInsertItem(list, testItem, testItemString); 731 732 subTest("PKIX_List_AppendItem"); 733 testAppendItem(list, testItem); 734 735 subTest("Nested Lists"); 736 testNestedLists(list, list2, testItem, testItem2); 737 738 subTest("PKIX_List_DeleteItem"); 739 testDeleteItem(list, list2, testItem2, testItem3); 740 741 PKIX_TEST_DECREF_BC(testItem); 742 PKIX_TEST_DECREF_BC(testItem2); 743 PKIX_TEST_DECREF_BC(testItem3); 744 745 #if testContainsFunction 746 /* This test requires pkix_List_Contains to be in nss.def */ 747 testContains(); 748 #endif 749 750 subTest("PKIX_List Error Handling"); 751 testErrorHandling(); 752 753 subTest("PKIX_List_Destroy"); 754 testDestroy(list); 755 756 cleanup: 757 758 PKIX_Shutdown(plContext); 759 760 PKIX_TEST_RETURN(); 761 762 endTests("Lists"); 763 764 return (0); 765 }