1 /* 2 * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved. 3 * 4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ 5 * 6 * This file contains Original Code and/or Modifications of Original Code 7 * as defined in and that are subject to the Apple Public Source License 8 * Version 2.0 (the 'License'). You may not use this file except in 9 * compliance with the License. The rights granted to you under the License 10 * may not be used to create, or enable the creation or redistribution of, 11 * unlawful or unlicensed copies of an Apple operating system, or to 12 * circumvent, violate, or enable the circumvention or violation of, any 13 * terms of an Apple operating system software license agreement. 14 * 15 * Please obtain a copy of the License at 16 * http://www.opensource.apple.com/apsl/ and read it before using this file. 17 * 18 * The Original Code and all software distributed under the License are 19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 23 * Please see the License for the specific language governing rights and 24 * limitations under the License. 25 * 26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ 27 */ 28 #if DEBUG 29 #include "Tests.h" 30 31 #include <libkern/c++/OSArray.h> 32 #include <libkern/c++/OSSet.h> 33 #include <libkern/c++/OSDictionary.h> 34 #include <libkern/c++/OSString.h> 35 #include <libkern/c++/OSSymbol.h> 36 #include <libkern/c++/OSCollectionIterator.h> 37 38 void 39 testArray() 40 { 41 bool res = true; 42 void *spaceCheck, *spaceCheck2, *spaceCheck3; 43 int i, j, count, count2; 44 OSObject *cache[numStrCache], *str, *sym; 45 OSArray *array1, *array2; 46 47 // Do first test without memory leak tests to initialise the metaclass 48 array1 = OSArray::withCapacity(1); 49 TEST_ASSERT('A', "0a", array1); 50 if (array1) { 51 array1->release(); 52 } 53 54 // Grow the symbol pool to maximum 55 for (i = 0; i < numStrCache; i++) { 56 cache[i] = (OSObject *) OSSymbol::withCStringNoCopy(strCache[i]); 57 } 58 for (i = 0; i < numStrCache; i++) { 59 cache[i]->release(); 60 } 61 62 // Create and destroy an array 63 spaceCheck = checkPointSpace(); 64 array1 = OSArray::withCapacity(1); 65 TEST_ASSERT('A', "1a", array1); 66 if (array1) { 67 TEST_ASSERT('A', "1b", !array1->getCount()); 68 TEST_ASSERT('A', "1c", 1 == array1->getCapacity()); 69 TEST_ASSERT('A', "1d", 1 == array1->getCapacityIncrement()); 70 TEST_ASSERT('A', "1e", 4 == array1->setCapacityIncrement(4)); 71 TEST_ASSERT('A', "1f", 4 == array1->getCapacityIncrement()); 72 TEST_ASSERT('A', "1g", 8 == array1->ensureCapacity(5)); 73 74 spaceCheck2 = checkPointSpace(); 75 cache[0] = IOString::withCStringNoCopy(strCache[0]); 76 77 spaceCheck3 = checkPointSpace(); 78 TEST_ASSERT('A', "1h", array1->setObject(cache[0])); 79 TEST_ASSERT('A', "1i", cache[0] == array1->getObject(0)); 80 cache[0]->release(); 81 res = res && checkSpace("(A)1j", spaceCheck3, 0); 82 83 TEST_ASSERT('A', "1k", 1 == array1->getCount()); 84 array1->flushCollection(); 85 TEST_ASSERT('A', "1l", !array1->getCount()); 86 res = res && checkSpace("(A)1m", spaceCheck2, 0); 87 88 array1->release(); 89 } 90 res = res && checkSpace("(A)1", spaceCheck, 0); 91 92 // Check the creation of a sizable OSArray from an array of IOObjects 93 // Also check indexing into the array. 94 spaceCheck = checkPointSpace(); 95 for (i = 0; i < numStrCache; i++) { 96 cache[i] = OSString::withCStringNoCopy(strCache[i]); 97 } 98 array1 = OSArray::withObjects(cache, numStrCache, numStrCache); 99 TEST_ASSERT('A', "2a", array1); 100 for (i = 0; i < numStrCache; i++) { 101 cache[i]->release(); 102 } 103 if (array1) { 104 TEST_ASSERT('A', "2b", numStrCache == (int) array1->getCount()); 105 TEST_ASSERT('A', "2c", numStrCache == (int) array1->getCapacity()); 106 TEST_ASSERT('A', "2d", 107 numStrCache == (int) array1->getCapacityIncrement()); 108 109 for (i = 0; (str = array1->getObject(i)); i++) { 110 if (str != cache[i]) { 111 verPrintf(("testArray(A) test 2e%d failed\n", i)); 112 res = false; 113 } 114 } 115 TEST_ASSERT('A', "2f", numStrCache == i); 116 array1->release(); 117 } 118 res = res && checkSpace("(A)2", spaceCheck, 0); 119 120 // Test array creation from another array by both the setObject method 121 // and the withArray factory. And test __takeObject code first 122 // with tail removal then with head removal 123 spaceCheck = checkPointSpace(); 124 for (i = 0; i < numStrCache; i++) { 125 cache[i] = OSString::withCStringNoCopy(strCache[i]); 126 } 127 array1 = OSArray::withObjects(cache, numStrCache, numStrCache); 128 TEST_ASSERT('A', "3a", array1); 129 for (i = 0; i < numStrCache; i++) { 130 cache[i]->release(); 131 } 132 array2 = 0; 133 if (array1) { 134 array2 = OSArray::withCapacity(1); 135 TEST_ASSERT('A', "3b", array2); 136 TEST_ASSERT('A', "3c", !array2->getCount()); 137 TEST_ASSERT('A', "3d", array2->setObject(array1)); 138 TEST_ASSERT('A', "3e", array1->getCount() == array2->getCount()); 139 } 140 if (array2) { 141 count = 0; 142 TEST_ASSERT('A', "3f", numStrCache == (int) array2->getCount()); 143 for (i = array2->getCount(); (str = array2->__takeObject(--i));) { 144 if (str != cache[i]) { 145 verPrintf(("testArray(A) test 3g%d failed\n", i)); 146 res = false; 147 } 148 count += ((int) array2->getCount() == i); 149 str->release(); 150 } 151 TEST_ASSERT('A', "3h", count == numStrCache); 152 TEST_ASSERT('A', "3i", -1 == i); 153 TEST_ASSERT('A', "3j", !array2->getCount()); 154 155 spaceCheck2 = checkPointSpace(); 156 array2->flushCollection(); 157 res = res && checkSpace("(A)3k", spaceCheck2, 0); 158 159 array2->release(); 160 array2 = 0; 161 } 162 if (array1) { 163 array2 = OSArray::withArray(array1, numStrCache - 1); 164 TEST_ASSERT('A', "3l", !array2); 165 array2 = OSArray::withArray(array1, array1->getCount()); 166 TEST_ASSERT('A', "3m", array2); 167 array1->release(); 168 } 169 if (array2) { 170 count = 0; 171 TEST_ASSERT('A', "3o", numStrCache == (int) array2->getCount()); 172 for (i = 0; (str = array2->__takeObject(0)); i++) { 173 count += (str == cache[i]); 174 str->release(); 175 } 176 TEST_ASSERT('A', "3p", count == numStrCache); 177 TEST_ASSERT('A', "3q", !array2->getCount()); 178 array2->release(); 179 array2 = 0; 180 } 181 res = res && checkSpace("(A)3", spaceCheck, 0); 182 183 // Test object replacement from one array to another 184 spaceCheck = checkPointSpace(); 185 array1 = OSArray::withCapacity(numStrCache); 186 TEST_ASSERT('A', "4a", array1); 187 if (array1) { 188 count = count2 = 0; 189 for (i = 0; i < numStrCache; i++) { 190 str = OSString::withCStringNoCopy(strCache[i]); 191 count += array1->setObject(str); 192 count2 += (str == array1->lastObject()); 193 str->release(); 194 } 195 TEST_ASSERT('A', "4b", numStrCache == (int) array1->getCount()); 196 TEST_ASSERT('A', "4c", count == numStrCache); 197 TEST_ASSERT('A', "4d", count2 == numStrCache); 198 } 199 array2 = OSArray::withCapacity(1); 200 TEST_ASSERT('A', "4e", array2); 201 if (array2) { 202 count = count2 = 0; 203 str = (OSObject *) OSSymbol::withCStringNoCopy(strCache[0]); 204 for (i = 0; i < numStrCache; i++) { 205 sym = (OSObject *) OSSymbol::withCStringNoCopy(strCache[i]); 206 count += array2->setObject(sym, 0); 207 count2 += (str == array2->lastObject()); 208 sym->release(); 209 } 210 str->release(); 211 TEST_ASSERT('A', "4f", numStrCache == (int) array2->getCount()); 212 TEST_ASSERT('A', "4g", count == numStrCache); 213 TEST_ASSERT('A', "4h", count2 == numStrCache); 214 } 215 if (array1 && array2) { 216 count = count2 = 0; 217 for (i = array1->getCount() - 1; (sym = array2->__takeObject(0)); i--) { 218 str = array1->replaceObject(sym, i); 219 count += (str != 0); 220 count2 += (sym != str); 221 if (str) { 222 str->release(); 223 } 224 if (sym) { 225 sym->release(); 226 } 227 } 228 TEST_ASSERT('A', "4k", numStrCache == (int) array1->getCount()); 229 TEST_ASSERT('A', "4l", count == numStrCache); 230 TEST_ASSERT('A', "4m", count2 == numStrCache); 231 array1->release(); 232 array2->release(); 233 } else { 234 if (array1) { 235 array1->release(); 236 } 237 if (array2) { 238 array2->release(); 239 } 240 } 241 res = res && checkSpace("(A)4", spaceCheck, 0); 242 243 // Test array duplicate removal 244 spaceCheck = checkPointSpace(); 245 array1 = OSArray::withCapacity(numStrCache); 246 TEST_ASSERT('A', "5a", array1); 247 if (array1) { 248 for (i = 0; i < numStrCache; i++) { 249 sym = (OSObject *) OSSymbol::withCStringNoCopy(strCache[i]); 250 count += array1->setObject(sym); 251 sym->release(); 252 } 253 TEST_ASSERT('A', "5b", numStrCache == (int) array1->getCount()); 254 255 // remove duplicates 256 for (i = 0; (sym = array1->getObject(i));) { 257 if (sym->getRetainCount() == 1) { 258 i++; 259 } else { 260 //sym = array1->__takeObject(i); 261 //sym->release(); 262 array1->removeObject(i); 263 } 264 } 265 TEST_ASSERT('A', "5c", numStrCache != (int) array1->getCount()); 266 267 // check to see that all symbols are really there 268 for (count = 0, i = 0; i < numStrCache; i++) { 269 sym = (OSObject *) OSSymbol::withCStringNoCopy(strCache[i]); 270 for (count2 = false, j = 0; (str = array1->getObject(j)); j++) { 271 if (str == sym) { 272 count2 = true; 273 break; 274 } 275 } 276 count += count2; 277 sym->release(); 278 } 279 TEST_ASSERT('A', "5c", count == numStrCache); 280 array1->release(); 281 } 282 res = res && checkSpace("(S)5", spaceCheck, 0); 283 284 if (res) { 285 verPrintf(("testArray: All OSArray Tests passed\n")); 286 } else { 287 logPrintf(("testArray: Some OSArray Tests failed\n")); 288 } 289 } 290 291 void 292 testSet() 293 { 294 bool res = true; 295 void *spaceCheck, *spaceCheck2, *spaceCheck3; 296 int i, count, count2; 297 OSObject *cache[numStrCache], *str, *sym; 298 OSSet *set1, *set2; 299 OSArray *array; 300 301 // Do first test without memory leak tests to initialise the metaclass 302 set1 = OSSet::withCapacity(1); 303 TEST_ASSERT('S', "0a", set1); 304 if (set1) { 305 set1->release(); 306 } 307 308 // Grow the symbol pool to maximum 309 for (i = 0; i < numStrCache; i++) { 310 cache[i] = (OSObject *) OSSymbol::withCStringNoCopy(strCache[i]); 311 } 312 for (i = 0; i < numStrCache; i++) { 313 cache[i]->release(); 314 } 315 316 // Create and destroy an set 317 spaceCheck = checkPointSpace(); 318 set1 = OSSet::withCapacity(1); 319 TEST_ASSERT('S', "1a", set1); 320 if (set1) { 321 TEST_ASSERT('S', "1b", !set1->getCount()); 322 TEST_ASSERT('S', "1c", 1 == set1->getCapacity()); 323 TEST_ASSERT('S', "1d", 1 == set1->getCapacityIncrement()); 324 TEST_ASSERT('S', "1e", 4 == set1->setCapacityIncrement(4)); 325 TEST_ASSERT('S', "1f", 4 == set1->getCapacityIncrement()); 326 TEST_ASSERT('S', "1g", 8 == set1->ensureCapacity(5)); 327 328 spaceCheck2 = checkPointSpace(); 329 cache[0] = IOString::withCStringNoCopy(strCache[0]); 330 331 spaceCheck3 = checkPointSpace(); 332 TEST_ASSERT('S', "1h", set1->setObject(cache[0])); 333 TEST_ASSERT('S', "1i", set1->containsObject(cache[0])); 334 TEST_ASSERT('S', "1j", cache[0] == set1->getAnyObject()); 335 cache[0]->release(); 336 res = res && checkSpace("(S)1k", spaceCheck3, 0); 337 338 TEST_ASSERT('S', "1l", 1 == set1->getCount()); 339 set1->flushCollection(); 340 TEST_ASSERT('S', "1m", !set1->getCount()); 341 res = res && checkSpace("(S)1n", spaceCheck2, 0); 342 343 set1->release(); 344 } 345 res = res && checkSpace("(S)1", spaceCheck, 0); 346 347 // Check the creation of a sizable OSSet from an set of IOObjects 348 // Also check member test of set. 349 spaceCheck = checkPointSpace(); 350 for (i = 0; i < numStrCache; i++) { 351 cache[i] = OSString::withCStringNoCopy(strCache[i]); 352 } 353 set1 = OSSet::withObjects(cache, numStrCache, numStrCache); 354 TEST_ASSERT('S', "2a", set1); 355 for (i = 0; i < numStrCache; i++) { 356 cache[i]->release(); 357 } 358 if (set1) { 359 TEST_ASSERT('S', "2b", numStrCache == (int) set1->getCount()); 360 TEST_ASSERT('S', "2c", numStrCache == (int) set1->getCapacity()); 361 TEST_ASSERT('S', "2d", 362 numStrCache == (int) set1->getCapacityIncrement()); 363 364 count = 0; 365 for (i = set1->getCount(); --i >= 0;) { 366 count += set1->member(cache[i]); 367 } 368 369 TEST_ASSERT('S', "2e", numStrCache == count); 370 set1->release(); 371 } 372 res = res && checkSpace("(S)2", spaceCheck, 0); 373 374 // Test set creation from another set by both the setObject method 375 // and the withArray factory. And test __takeObject code first 376 // with tail removal then with head removal 377 spaceCheck = checkPointSpace(); 378 for (i = 0; i < numStrCache; i++) { 379 cache[i] = OSString::withCStringNoCopy(strCache[i]); 380 } 381 set1 = OSSet::withObjects(cache, numStrCache, numStrCache); 382 TEST_ASSERT('S', "3a", set1); 383 for (i = 0; i < numStrCache; i++) { 384 cache[i]->release(); 385 } 386 set2 = 0; 387 if (set1) { 388 set2 = OSSet::withCapacity(set1->getCount()); 389 TEST_ASSERT('S', "3b", set2); 390 TEST_ASSERT('S', "3c", !set2->getCount()); 391 TEST_ASSERT('S', "3d", set2->setObject(set1)); 392 TEST_ASSERT('S', "3e", set1->getCount() == set2->getCount()); 393 } 394 if (set2) { 395 TEST_ASSERT('S', "3f", numStrCache == (int) set2->getCount()); 396 count = count2 = 0; 397 while ((str = set2->getAnyObject())) { 398 count += set2->__takeObject(str); 399 count2 += set1->member(str); 400 str->release(); 401 } 402 TEST_ASSERT('S', "3g", !set2->getCount()); 403 TEST_ASSERT('S', "3h", numStrCache == count); 404 TEST_ASSERT('S', "3i", numStrCache == count2); 405 406 spaceCheck2 = checkPointSpace(); 407 set2->flushCollection(); 408 res = res && checkSpace("(S)3j", spaceCheck2, 0); 409 410 set2->release(); 411 set2 = 0; 412 } 413 if (set1) { 414 set2 = OSSet::withSet(set1, numStrCache - 1); 415 TEST_ASSERT('S', "3k", !set2); 416 set2 = OSSet::withSet(set1, set1->getCount()); 417 TEST_ASSERT('S', "3l", set2); 418 set1->release(); 419 } 420 if (set2) { 421 TEST_ASSERT('S', "3m", numStrCache == (int) set2->getCount()); 422 i = count = count2 = 0; 423 while ((str = set2->getAnyObject())) { 424 count += set2->__takeObject(str); 425 count2 += (cache[i++] == str); 426 str->release(); 427 } 428 TEST_ASSERT('S', "3n", !set2->getCount()); 429 TEST_ASSERT('S', "3o", numStrCache == count); 430 TEST_ASSERT('S', "3p", numStrCache == count2); 431 432 set2->release(); 433 set2 = 0; 434 } 435 res = res && checkSpace("(S)3", spaceCheck, 0); 436 437 // Test duplicate removal 438 spaceCheck = checkPointSpace(); 439 set2 = 0; 440 set1 = OSSet::withCapacity(numStrCache); 441 TEST_ASSERT('S', "4a", set1); 442 if (set1) { 443 count = 0; 444 for (i = 0; i < numStrCache; i++) { 445 sym = (OSObject *) OSSymbol::withCStringNoCopy(strCache[i]); 446 count += set1->setObject(sym); 447 sym->release(); 448 } 449 TEST_ASSERT('S', "4b", numStrCache != (int) set1->getCount()); 450 TEST_ASSERT('S', "4c", count == (int) set1->getCount()); 451 452 count = count2 = 0; 453 for (i = 0; i < numStrCache; i++) { 454 sym = (OSObject *) OSSymbol::withCStringNoCopy(strCache[i]); 455 count += set1->member(sym); 456 count2 += sym->getRetainCount(); 457 sym->release(); 458 } 459 TEST_ASSERT('S', "4d", count == numStrCache); 460 TEST_ASSERT('S', "4e", count2 == numStrCache * 2); 461 462 set2 = OSSet::withSet(set1, 2 * set1->getCount()); 463 } 464 TEST_ASSERT('S', "4f", set2); 465 if (set2) { 466 set2->setObject(set1); 467 TEST_ASSERT('S', "4g", set1->getCount() == set2->getCount()); 468 set1->release(); 469 set2->release(); 470 } 471 res = res && checkSpace("(S)4", spaceCheck, 0); 472 473 // Test array duplicate removal 474 spaceCheck = checkPointSpace(); 475 array = OSArray::withCapacity(numStrCache); 476 for (i = 0; i < numStrCache; i++) { 477 sym = (OSObject *) OSSymbol::withCStringNoCopy(strCache[i]); 478 count += array->setObject(sym); 479 sym->release(); 480 } 481 set1 = OSSet::withArray(array, numStrCache); 482 TEST_ASSERT('S', "5a", set1); 483 if (set1) { 484 TEST_ASSERT('S', "5b", array->getCount() != set1->getCount()); 485 array->release(); 486 487 count = count2 = set1->getCount(); 488 while ((sym = set1->getAnyObject())) { 489 count -= set1->__takeObject(sym); 490 count2 -= sym->getRetainCount(); 491 sym->release(); 492 } 493 TEST_ASSERT('S', "5c", !count); 494 TEST_ASSERT('S', "5d", !count2); 495 set1->release(); 496 } 497 res = res && checkSpace("(S)5", spaceCheck, 0); 498 499 if (res) { 500 verPrintf(("testSet: All OSSet Tests passed\n")); 501 } else { 502 logPrintf(("testSet: Some OSSet Tests failed\n")); 503 } 504 } 505 506 void 507 testDictionary() 508 { 509 bool res = true; 510 void *spaceCheck, *spaceCheck2, *spaceCheck3; 511 OSObject *cache[numStrCache]; 512 OSString *str; 513 const OSSymbol *symCache[numStrCache], *sym; 514 OSDictionary *dict1, *dict2; 515 int i, numSymbols, count1, count2; 516 517 // Do first test without memory leak tests to initialise the metaclass 518 dict1 = OSDictionary::withCapacity(1); 519 TEST_ASSERT('D', "0a", dict1); 520 if (dict1) { 521 dict1->release(); 522 } 523 524 // Grow the symbol pool to maximum 525 for (i = 0; i < numStrCache; i++) { 526 symCache[i] = OSSymbol::withCStringNoCopy(strCache[i]); 527 } 528 for (i = 0; i < numStrCache; i++) { 529 symCache[i]->release(); 530 } 531 532 // Create and destroy a dictionary 533 spaceCheck = checkPointSpace(); 534 dict1 = OSDictionary::withCapacity(1); 535 TEST_ASSERT('D', "1a", dict1); 536 if (dict1) { 537 TEST_ASSERT('D', "1b", !dict1->getCount()); 538 TEST_ASSERT('D', "1c", 1 == dict1->getCapacity()); 539 TEST_ASSERT('D', "1d", 1 == dict1->getCapacityIncrement()); 540 TEST_ASSERT('D', "1e", 4 == dict1->setCapacityIncrement(4)); 541 TEST_ASSERT('D', "1f", 4 == dict1->getCapacityIncrement()); 542 TEST_ASSERT('D', "1g", 8 == dict1->ensureCapacity(5)); 543 544 spaceCheck2 = checkPointSpace(); 545 sym = OSSymbol::withCStringNoCopy(strCache[0]); 546 547 spaceCheck3 = checkPointSpace(); 548 TEST_ASSERT('D', "1h", dict1->setObject((OSObject *) sym, sym)); 549 TEST_ASSERT('D', "1i", (OSObject *) sym == dict1->getObject(sym)); 550 sym->release(); 551 TEST_ASSERT('D', "1i", 2 == sym->getRetainCount()); 552 res = res && checkSpace("(D)1j", spaceCheck3, 0); 553 554 TEST_ASSERT('D', "1k", 1 == dict1->getCount()); 555 dict1->flushCollection(); 556 TEST_ASSERT('D', "1l", !dict1->getCount()); 557 res = res && checkSpace("(D)1m", spaceCheck2, 0); 558 559 dict1->release(); 560 } 561 res = res && checkSpace("(D)1", spaceCheck, 0); 562 563 // Check the creation of a sizable OSDictionary from an array of IOObjects 564 // Also check indexing into the array. 565 spaceCheck = checkPointSpace(); 566 for (i = 0, numSymbols = 0; i < numStrCache; i++) { 567 sym = OSSymbol::withCStringNoCopy(strCache[i]); 568 if (1 == sym->getRetainCount()) { 569 symCache[numSymbols++] = sym; 570 } else { 571 sym->release(); 572 } 573 } 574 dict1 = OSDictionary::withObjects( 575 (OSObject **) symCache, symCache, numSymbols, numSymbols); 576 TEST_ASSERT('D', "2a", dict1); 577 count1 = count2 = 0; 578 for (i = 0; i < numSymbols; i++) { 579 count1 += (symCache[i]->getRetainCount() == 3); 580 } 581 TEST_ASSERT('D', "2b", count1 == numSymbols); 582 if (dict1) { 583 TEST_ASSERT('D', "2c", numSymbols == (int) dict1->getCount()); 584 TEST_ASSERT('D', "2d", numSymbols == (int) dict1->getCapacity()); 585 TEST_ASSERT('D', "2e", 586 numSymbols == (int) dict1->getCapacityIncrement()); 587 588 for (i = dict1->getCount(); --i >= 0;) { 589 str = (OSString *) dict1->getObject(symCache[i]); 590 if (str != (OSString *) symCache[i]) { 591 verPrintf(("testDictionary(D) test 2f%d failed\n", i)); 592 res = false; 593 } 594 } 595 dict1->release(); 596 } 597 count1 = count2 = 0; 598 for (i = 0; i < numSymbols; i++) { 599 count1 += (symCache[i]->getRetainCount() == 1); 600 symCache[i]->release(); 601 } 602 TEST_ASSERT('D', "2g", count1 == numSymbols); 603 res = res && checkSpace("(D)2", spaceCheck, 0); 604 605 // Check the creation of a sizable Dictionary from an array of IOStrings 606 // Also check searching dictionary use OSString for a key. 607 spaceCheck = checkPointSpace(); 608 for (i = 0, numSymbols = 0; i < numStrCache; i++) { 609 sym = OSSymbol::withCStringNoCopy(strCache[i]); 610 if (1 == sym->getRetainCount()) { 611 cache[numSymbols] = OSString::withCStringNoCopy(strCache[i]); 612 symCache[numSymbols] = sym; 613 numSymbols++; 614 } else { 615 sym->release(); 616 } 617 } 618 dict1 = OSDictionary::withObjects((OSObject **) symCache, 619 (OSString **) cache, 620 numSymbols, numSymbols); 621 TEST_ASSERT('D', "3a", dict1); 622 count1 = count2 = 0; 623 for (i = 0; i < numSymbols; i++) { 624 count1 += (symCache[i]->getRetainCount() == 3); 625 count2 += (cache[i]->getRetainCount() == 1); 626 } 627 TEST_ASSERT('D', "3b", count1 == numSymbols); 628 TEST_ASSERT('D', "3c", count2 == numSymbols); 629 if (dict1) { 630 count1 = count2 = 0; 631 for (i = 0; i < numSymbols; i++) { 632 str = (OSString *) cache[i]; 633 count1 += (symCache[i] == (const OSSymbol *) dict1->getObject(str)); 634 count2 += (symCache[i]->getRetainCount() == 3); 635 } 636 TEST_ASSERT('D', "3d", count1 == numSymbols); 637 TEST_ASSERT('D', "3e", count2 == numSymbols); 638 639 count1 = count2 = 0; 640 for (i = 0; i < numSymbols; i++) { 641 const char *cStr = ((OSString *) cache[i])->getCStringNoCopy(); 642 643 count1 += (symCache[i] == (const OSSymbol *) dict1->getObject(cStr)); 644 count2 += (symCache[i]->getRetainCount() == 3); 645 } 646 TEST_ASSERT('D', "3f", count1 == numSymbols); 647 TEST_ASSERT('D', "3g", count2 == numSymbols); 648 649 dict1->release(); 650 } 651 count1 = count2 = 0; 652 for (i = 0; i < numSymbols; i++) { 653 count1 += (symCache[i]->getRetainCount() == 1); 654 count2 += (cache[i]->getRetainCount() == 1); 655 symCache[i]->release(); 656 cache[i]->release(); 657 } 658 TEST_ASSERT('D', "3h", count1 == numSymbols); 659 res = res && checkSpace("(D)3", spaceCheck, 0); 660 661 // Check the creation of a small dictionary then grow it one item at a time 662 // Create a new dictionary from the old dictionary. 663 // Finally remove each item permanently. 664 spaceCheck = checkPointSpace(); 665 for (i = 0, numSymbols = 0; i < numStrCache; i++) { 666 sym = OSSymbol::withCStringNoCopy(strCache[i]); 667 if (1 == sym->getRetainCount()) { 668 cache[numSymbols] = OSString::withCStringNoCopy(strCache[i]); 669 symCache[numSymbols] = sym; 670 numSymbols++; 671 } else { 672 sym->release(); 673 } 674 } 675 dict2 = 0; 676 dict1 = OSDictionary::withCapacity(1); 677 TEST_ASSERT('D', "4a", dict1); 678 if (dict1) { 679 count1 = count2 = 0; 680 for (i = 0; i < numSymbols; i++) { 681 sym = symCache[i]; 682 count1 += ((OSObject *) sym == dict1->setObject((OSObject *) sym, 683 sym->getCStringNoCopy())); 684 count2 += (sym->getRetainCount() == 3); 685 } 686 TEST_ASSERT('D', "4b", numSymbols == (int) dict1->getCount()); 687 TEST_ASSERT('D', "4c", numSymbols == count1); 688 TEST_ASSERT('D', "4d", numSymbols == count2); 689 690 dict2 = OSDictionary::withDictionary(dict1, numSymbols - 1); 691 TEST_ASSERT('D', "4b", !dict2); 692 dict2 = OSDictionary::withDictionary(dict1, numSymbols); 693 } 694 TEST_ASSERT('D', "4e", dict2); 695 if (dict2) { 696 dict1->release(); dict1 = 0; 697 698 TEST_ASSERT('D', "4f", numSymbols == (int) dict2->getCount()); 699 700 count1 = count2 = 0; 701 for (i = 0; i < numSymbols; i++) { 702 OSObject *replacedObject; 703 704 sym = symCache[i]; 705 str = (OSString *) cache[i]; 706 replacedObject = dict2->setObject(str, str); 707 count1 += ((OSString *) sym == replacedObject); 708 replacedObject->release(); 709 count2 += (sym->getRetainCount() == 2); 710 str->release(); 711 } 712 TEST_ASSERT('D', "4g", numSymbols == count1); 713 TEST_ASSERT('D', "4h", numSymbols == count2); 714 715 count1 = count2 = 0; 716 for (i = 0; i < numSymbols; i++) { 717 sym = symCache[i]; 718 str = (OSString *) cache[i]; 719 count1 += (str == dict2->__takeObject(sym)); 720 str->release(); 721 count2 += (sym->getRetainCount() == 1); 722 sym->release(); 723 } 724 TEST_ASSERT('D', "4i", numSymbols == count1); 725 TEST_ASSERT('D', "4j", numSymbols == count2); 726 TEST_ASSERT('D', "4k", !dict2->getCount()); 727 dict2->release(); dict2 = 0; 728 } else if (dict1) { 729 dict1->release(); 730 } 731 res = res && checkSpace("(D)4", spaceCheck, 0); 732 733 if (res) { 734 verPrintf(("testDictionary: All OSDictionary Tests passed\n")); 735 } else { 736 logPrintf(("testDictionary: Some OSDictionary Tests failed\n")); 737 } 738 } 739 740 void 741 testIterator() 742 { 743 bool res = true; 744 void *spaceCheck; 745 OSObject *cache[numStrCache]; 746 OSString *str = 0; 747 const OSSymbol *symCache[numStrCache], *sym; 748 OSDictionary *dict; 749 OSSet *set; 750 OSArray *array, *bigReturn; 751 OSCollectionIterator *iter1, *iter2; 752 int i, numSymbols, count1, count2, count3; 753 754 // Setup symbol and string pools 755 for (i = 0, numSymbols = 0; i < numStrCache; i++) { 756 sym = OSSymbol::withCStringNoCopy(strCache[i]); 757 if (1 == sym->getRetainCount()) { 758 cache[numSymbols] = OSString::withCStringNoCopy(strCache[i]); 759 symCache[numSymbols] = sym; 760 numSymbols++; 761 } else { 762 sym->release(); 763 } 764 } 765 766 // Test the array iterator 767 spaceCheck = checkPointSpace(); 768 iter1 = iter2 = 0; 769 array = OSArray::withCapacity(numSymbols); 770 TEST_ASSERT('I', "1a", array); 771 if (array) { 772 count1 = count2 = 0; 773 for (i = numSymbols; --i >= 0;) { 774 count1 += array->setObject(cache[i], 0); 775 } 776 TEST_ASSERT('I', "1b", count1 == numSymbols); 777 778 iter1 = OSCollectionIterator::withCollection(array); 779 iter2 = OSCollectionIterator::withCollection(array); 780 } 781 TEST_ASSERT('I', "1c", iter1); 782 TEST_ASSERT('I', "1d", iter2); 783 if (iter1 && iter2) { 784 count1 = count2 = count3 = 0; 785 for (i = 0; (str = (IOString *) iter1->getNextObject()); i++) { 786 bigReturn = iter2->nextEntries(); 787 count1 += (bigReturn->getCount() == 1); 788 count2 += (cache[i] == bigReturn->getObject(0)); 789 count3 += (cache[i] == str); 790 } 791 TEST_ASSERT('I', "1e", count1 == numSymbols); 792 TEST_ASSERT('I', "1f", count2 == numSymbols); 793 TEST_ASSERT('I', "1g", count3 == numSymbols); 794 TEST_ASSERT('I', "1h", iter1->valid()); 795 TEST_ASSERT('I', "1i", iter2->valid()); 796 797 iter1->reset(); 798 str = (OSString *) array->__takeObject(0); 799 array->setObject(str, 0); 800 str->release(); 801 TEST_ASSERT('I', "1j", !iter1->getNextObject()); 802 TEST_ASSERT('I', "1k", !iter1->valid()); 803 804 iter1->reset(); 805 count1 = count2 = count3 = 0; 806 for (i = 0;; i++) { 807 if (i & 1) { 808 str = (OSString *) iter1->getNextObject(); 809 } else if ((bigReturn = iter1->nextEntries())) { 810 str = (OSString *) bigReturn->getObject(0); 811 } else { 812 str = 0; 813 } 814 815 if (!str) { 816 break; 817 } 818 count1 += (cache[i] == str); 819 } 820 TEST_ASSERT('I', "1l", count1 == numSymbols); 821 TEST_ASSERT('I', "1m", i == numSymbols); 822 TEST_ASSERT('I', "1n", iter1->valid()); 823 824 TEST_ASSERT('I', "1o", 3 == array->getRetainCount()); 825 array->release(); 826 } 827 828 if (iter1) { 829 iter1->release(); 830 } 831 if (iter2) { 832 iter2->release(); 833 } 834 res = res && checkSpace("(I)1", spaceCheck, 0); 835 836 // Test the set iterator 837 spaceCheck = checkPointSpace(); 838 iter1 = 0; 839 set = OSSet::withCapacity(numSymbols); 840 TEST_ASSERT('I', "2a", set); 841 if (set) { 842 count1 = count2 = 0; 843 for (i = 0; i < numSymbols; i++) { 844 count1 += set->setObject(cache[i]); 845 } 846 TEST_ASSERT('I', "2b", count1 == numSymbols); 847 848 iter1 = OSCollectionIterator::withCollection(set); 849 iter2 = OSCollectionIterator::withCollection(set); 850 } 851 TEST_ASSERT('I', "2c", iter1); 852 TEST_ASSERT('I', "2d", iter2); 853 if (iter1 && iter2) { 854 count1 = count2 = count3 = 0; 855 for (i = 0; (str = (IOString *) iter1->getNextObject()); i++) { 856 bigReturn = iter2->nextEntries(); 857 count1 += (bigReturn->getCount() == 1); 858 count2 += (cache[i] == bigReturn->getObject(0)); 859 count3 += (cache[i] == str); 860 } 861 TEST_ASSERT('I', "2e", count1 == numSymbols); 862 TEST_ASSERT('I', "2f", count2 == numSymbols); 863 TEST_ASSERT('I', "2g", count3 == numSymbols); 864 TEST_ASSERT('I', "2h", iter1->valid()); 865 TEST_ASSERT('I', "2i", iter2->valid()); 866 867 iter1->reset(); 868 count1 = count2 = count3 = 0; 869 for (i = 0;; i++) { 870 if (i & 1) { 871 str = (OSString *) iter1->getNextObject(); 872 } else if ((bigReturn = iter1->nextEntries())) { 873 str = (OSString *) bigReturn->getObject(0); 874 } else { 875 str = 0; 876 } 877 878 if (!str) { 879 break; 880 } 881 count1 += (cache[i] == str); 882 } 883 TEST_ASSERT('I', "2l", count1 == numSymbols); 884 TEST_ASSERT('I', "2m", i == numSymbols); 885 TEST_ASSERT('I', "2n", iter1->valid()); 886 887 iter1->reset(); 888 str = (OSString *) set->getAnyObject(); 889 (void) set->__takeObject(str); 890 set->setObject(str); 891 str->release(); 892 TEST_ASSERT('I', "2j", !iter1->getNextObject()); 893 TEST_ASSERT('I', "2k", !iter1->valid()); 894 895 TEST_ASSERT('I', "2o", 3 == set->getRetainCount()); 896 set->release(); 897 } 898 899 if (iter1) { 900 iter1->release(); 901 } 902 if (iter2) { 903 iter2->release(); 904 } 905 res = res && checkSpace("(I)2", spaceCheck, 0); 906 907 // Test the dictionary iterator 908 spaceCheck = checkPointSpace(); 909 iter1 = 0; 910 dict = OSDictionary::withCapacity(numSymbols); 911 TEST_ASSERT('I', "3a", dict); 912 if (dict) { 913 count1 = count2 = 0; 914 for (i = 0; i < numSymbols; i++) { 915 count1 += (0 != dict->setObject(cache[i], symCache[i])); 916 } 917 TEST_ASSERT('I', "3b", count1 == numSymbols); 918 919 iter1 = OSCollectionIterator::withCollection(dict); 920 iter2 = OSCollectionIterator::withCollection(dict); 921 } 922 TEST_ASSERT('I', "3c", iter1); 923 TEST_ASSERT('I', "3d", iter2); 924 if (iter1 && iter2) { 925 count1 = count2 = count3 = 0; 926 for (i = 0; (sym = (const IOSymbol *) iter1->getNextObject()); i++) { 927 bigReturn = iter2->nextEntries(); 928 count1 += (bigReturn->getCount() == 2); 929 count2 += (cache[i] == bigReturn->getObject(1)); 930 count3 += (symCache[i] == sym); 931 } 932 TEST_ASSERT('I', "3e", count1 == numSymbols); 933 TEST_ASSERT('I', "3f", count2 == numSymbols); 934 TEST_ASSERT('I', "3g", count3 == numSymbols); 935 TEST_ASSERT('I', "3h", iter1->valid()); 936 TEST_ASSERT('I', "3i", iter2->valid()); 937 938 iter1->reset(); 939 count1 = count2 = count3 = 0; 940 i = 0; 941 for (i = 0;; i++) { 942 if (i & 1) { 943 sym = (const OSSymbol *) iter1->getNextObject(); 944 str = 0; 945 } else if ((bigReturn = iter1->nextEntries())) { 946 sym = (const OSSymbol *) bigReturn->getObject(0); 947 str = (OSString *) bigReturn->getObject(1); 948 } else { 949 sym = 0; 950 } 951 952 if (!sym) { 953 break; 954 } 955 956 count1 += (symCache[i] == sym); 957 count2 += (!str || cache[i] == str); 958 } 959 TEST_ASSERT('I', "3l", count1 == numSymbols); 960 TEST_ASSERT('I', "3m", count2 == numSymbols); 961 TEST_ASSERT('I', "3n", i == numSymbols); 962 TEST_ASSERT('I', "3o", iter1->valid()); 963 964 iter1->reset(); 965 str = (OSString *) dict->__takeObject(symCache[numSymbols - 1]); 966 dict->setObject(str, symCache[numSymbols - 1]); 967 str->release(); 968 TEST_ASSERT('I', "3j", !iter1->getNextObject()); 969 TEST_ASSERT('I', "3k", !iter1->valid()); 970 971 TEST_ASSERT('I', "3p", 3 == dict->getRetainCount()); 972 dict->release(); 973 } 974 975 if (iter1) { 976 iter1->release(); 977 } 978 if (iter2) { 979 iter2->release(); 980 } 981 res = res && checkSpace("(I)3", spaceCheck, 0); 982 983 count1 = count2 = count3 = 0; 984 for (i = 0; i < numSymbols; i++) { 985 count1 += (1 == cache[i]->getRetainCount()); 986 count2 += (1 == symCache[i]->getRetainCount()); 987 cache[i]->release(); 988 symCache[i]->release(); 989 } 990 TEST_ASSERT('I', "4a", count1 == numSymbols); 991 TEST_ASSERT('I', "4b", count2 == numSymbols); 992 993 if (res) { 994 verPrintf(("testIterator: All OSCollectionIterator Tests passed\n")); 995 } else { 996 logPrintf(("testIterator: Some OSCollectionIterator Tests failed\n")); 997 } 998 } 999 1000 #endif /* DEBUG */ 1001