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