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++/OSData.h> 32 #include <libkern/c++/OSString.h> 33 #include <libkern/c++/OSSymbol.h> 34 35 static const char testC00[] = "The quick brown fox jumps over the lazy dog. "; 36 static const char testC01[] = "The quick brown fox "; 37 static const char testC02[] = "jumps over the "; 38 static const char testC03[] = "lazy dog. \n"; 39 static const char testC04[] = "The "; 40 static const char testC05[] = "quick "; 41 static const char testC06[] = "brown "; 42 static const char testC07[] = "fox "; 43 static const char testC08[] = "jumps "; 44 static const char testC09[] = "over "; 45 static const char testC10[] = "the "; 46 static const char testC11[] = "lazy "; 47 static const char testC12[] = "dog. \n"; 48 static const char testC13[] = "Now is the time for all good " 49 "men to come to the aid of the party \n"; 50 static const char testC14[] = "Now is the time for "; 51 static const char testC15[] = "all good men to come "; 52 static const char testC16[] = "to the aid of the party \n"; 53 static const char testC17[] = "Now "; 54 static const char testC18[] = "is "; 55 static const char testC19[] = "the "; 56 static const char testC20[] = "time "; 57 static const char testC21[] = "for "; 58 static const char testC22[] = "all "; 59 static const char testC23[] = "good "; 60 static const char testC24[] = "men "; 61 static const char testC25[] = "to "; 62 static const char testC26[] = "come "; 63 static const char testC27[] = "to "; 64 static const char testC28[] = "the "; 65 static const char testC29[] = "aid "; 66 static const char testC30[] = "of "; 67 static const char testC31[] = "the "; 68 static const char testC32[] = "party. \n"; 69 static const char testC33[] = "Frank Burns eats worms. \n"; 70 static const char testC34[] = "Frank Burns "; 71 static const char testC35[] = "eats worms. \n"; 72 static const char testC36[] = "Frank "; 73 static const char testC37[] = "Burns "; 74 static const char testC38[] = "eats "; 75 static const char testC39[] = "worms. \n"; 76 static const char testC40[] = "Tired eyes? Stiff neck? Tight shoulders? " 77 "Aching back? The right moves can help " 78 "prevent these kinds of problem. "; 79 static const char testC41[] = "Tired eyes? Stiff neck? "; 80 static const char testC42[] = "Tight shoulders? Aching back? "; 81 static const char testC43[] = "The right moves can help prevent "; 82 static const char testC44[] = "these kinds of problem. "; 83 static const char testC45[] = "Tired "; 84 static const char testC46[] = "eyes? "; 85 static const char testC47[] = "Stiff "; 86 static const char testC48[] = "neck? "; 87 static const char testC49[] = "Tight "; 88 static const char testC50[] = "shoulders? "; 89 static const char testC51[] = "Aching "; 90 static const char testC52[] = "back? "; 91 static const char testC53[] = "The "; 92 static const char testC54[] = "right "; 93 static const char testC55[] = "moves "; 94 static const char testC56[] = "can "; 95 static const char testC57[] = "help "; 96 static const char testC58[] = "prevent "; 97 static const char testC59[] = "these "; 98 static const char testC60[] = "kinds "; 99 static const char testC61[] = "of "; 100 static const char testC62[] = "problem. "; 101 102 const char *strCache[] = { 103 testC00, testC01, testC02, testC03, testC04, testC05, testC06, testC07, 104 testC08, testC09, testC10, testC11, testC12, testC13, testC14, testC15, 105 testC16, testC17, testC18, testC19, testC20, testC21, testC22, testC23, 106 testC24, testC25, testC26, testC27, testC28, testC29, testC30, testC31, 107 testC32, testC33, testC34, testC35, testC36, testC37, testC38, testC39, 108 testC40, testC41, testC42, testC43, testC44, testC45, testC46, testC47, 109 testC48, testC49, testC50, testC51, testC52, testC53, testC54, testC55, 110 testC56, testC57, testC58, testC59, testC60, testC61, testC62, 111 }; 112 const int numStrCache = ((int) (sizeof(strCache)/sizeof(strCache[0]))); 113 114 void testData() 115 { 116 #define DATA_SIZE_1 256 117 #define DATA_SIZE_2 512 118 #define DATA_SIZE_3 1024 119 #define DATA_SIZE_4 8192 120 121 OSData *test1, *test2, *test3; 122 void *spaceCheck; 123 unsigned int len; 124 unsigned int i; 125 bool res = true; 126 unsigned short testData[DATA_SIZE_4/sizeof(short)], *cp; 127 128 // very first test initialises the OSMetaClass cache. 129 test1 = OSData::withCapacity(DATA_SIZE_1); 130 TEST_ASSERT('d', "0a", test1); 131 if (test1) 132 test1->release(); 133 134 for (i = 0; i < sizeof(testData)/sizeof(short); i++) 135 testData[i] = (unsigned short) i; 136 137 // Check empty data allocation 138 spaceCheck = checkPointSpace(); 139 test1 = OSData::withCapacity(DATA_SIZE_1); 140 TEST_ASSERT('d', "1a", test1); 141 if (test1) { 142 TEST_ASSERT('d', "1b", !test1->getLength()); 143 TEST_ASSERT('d', "1c", test1->getCapacity() == DATA_SIZE_1); 144 TEST_ASSERT('d', "1d", !test1->getBytesNoCopy()); 145 TEST_ASSERT('d', "1e", !test1->getBytesNoCopy(10, DATA_SIZE_1 - 10)); 146 TEST_ASSERT('d', "1f", test1->appendBytes(spaceCheck, 0)); 147 TEST_ASSERT('d', "1g", !test1->getLength()); 148 TEST_ASSERT('d', "1h", test1->getCapacity() == DATA_SIZE_1); 149 TEST_ASSERT('d', "1i", !test1->getBytesNoCopy()); 150 test1->release(); 151 } 152 res = res && checkSpace("(d)1", spaceCheck, 0); 153 154 // Check appending to empty data allocation 155 spaceCheck = checkPointSpace(); 156 test1 = OSData::withCapacity(DATA_SIZE_1); 157 TEST_ASSERT('d', "2a", test1); 158 if (test1) { 159 TEST_ASSERT('d', "2b", !test1->getLength()); 160 TEST_ASSERT('d', "2c", !test1->getBytesNoCopy()); 161 TEST_ASSERT('d', "2d", test1->appendBytes(testData, DATA_SIZE_1)); 162 TEST_ASSERT('d', "2e", test1->getLength() == DATA_SIZE_1); 163 TEST_ASSERT('d', "2f", test1->getBytesNoCopy()); 164 cp = (unsigned short *) test1->getBytesNoCopy(); 165 for (i = 0; cp && i < (DATA_SIZE_1/sizeof(short)); i++) { 166 TEST_ASSERT('d', "2g", *cp++ == testData[i]); 167 if (*cp != testData[i]) 168 break; 169 } 170 TEST_ASSERT('d', "2h", test1->getBytesNoCopy(10, DATA_SIZE_1-10)); 171 cp = (unsigned short *) test1->getBytesNoCopy(10, DATA_SIZE_1 - 10); 172 for (i = 5; cp && i < (DATA_SIZE_1/sizeof(short)) - 5; i++) { 173 TEST_ASSERT('d', "2i", *cp++ == testData[i]); 174 if (*cp != testData[i]) 175 break; 176 } 177 TEST_ASSERT('d', "2j", test1->isEqualTo(testData, DATA_SIZE_1)); 178 test1->release(); 179 } 180 res = res && checkSpace("(d)2", spaceCheck, 0); 181 182 // Check data allocation from some constant data 183 spaceCheck = checkPointSpace(); 184 test1 = OSData::withBytes(testData, sizeof(testData)); 185 TEST_ASSERT('d', "3a", test1); 186 if (test1) { 187 TEST_ASSERT('d', "3b", test1->getLength() == sizeof(testData)); 188 TEST_ASSERT('d', "3c", test1->getCapacity() == sizeof(testData)); 189 TEST_ASSERT('d', "3d", test1->getBytesNoCopy()); 190 TEST_ASSERT('d', "3e", test1->getBytesNoCopy(10, sizeof(testData)-10)); 191 TEST_ASSERT('d', "3f", test1->appendBytes(spaceCheck, 0)); 192 TEST_ASSERT('d', "3g", test1->getLength() == sizeof(testData)); 193 TEST_ASSERT('d', "3h", test1->getCapacity() == sizeof(testData)); 194 TEST_ASSERT('d', "3i", test1->getBytesNoCopy()); 195 TEST_ASSERT('d', "3j", test1->getBytesNoCopy(10, sizeof(testData)-10)); 196 TEST_ASSERT('d', "3k", !test1->appendBytes(testData, 10)); 197 test1->release(); 198 } 199 res = res && checkSpace("(d)3", spaceCheck, 0); 200 201 // Check and continious addition of more data 202 spaceCheck = checkPointSpace(); 203 test1 = OSData::withCapacity(DATA_SIZE_4); 204 test2 = OSData::withBytesNoCopy(testData, DATA_SIZE_3); 205 len = DATA_SIZE_3; 206 TEST_ASSERT('d', "4a", (test1 && test2)); 207 if (test1 && test2) { 208 TEST_ASSERT('d', "4b", !test1->getLength()); 209 for (i = 0; i < DATA_SIZE_4; i += DATA_SIZE_3) 210 TEST_ASSERT('d', "4c", test1->appendBytes(test2)); 211 TEST_ASSERT('d', "4d", !test1->appendBytes(test2)); 212 for (i = 0; i < DATA_SIZE_4; i += DATA_SIZE_3) { 213 214 TEST_ASSERT('d', "4e", test2->isEqualTo( 215 test1->getBytesNoCopy(i, DATA_SIZE_3), 216 DATA_SIZE_3)); 217 218 test3 = OSData::withData(test1, i, DATA_SIZE_3); 219 TEST_ASSERT('d', "4f", test3); 220 if (test3) { 221 TEST_ASSERT('d', "4g", test2->isEqualTo(test3)); 222 test3->release(); 223 } 224 225 test3 = OSData::withData(test1, i, len); 226 TEST_ASSERT('d', "4i", test3); 227 if (test3) { 228 TEST_ASSERT('d', "4j", test2->isEqualTo(test3)); 229 test3->release(); 230 } 231 } 232 test1->release(); 233 test2->release(); 234 } 235 res = res && checkSpace("(d)3", spaceCheck, 0); 236 237 if (res) 238 verPrintf(("testData: All OSData Tests passed\n")); 239 else 240 logPrintf(("testData: Some OSData Tests failed\n")); 241 #undef DATA_SIZE_4 242 #undef DATA_SIZE_3 243 #undef DATA_SIZE_2 244 #undef DATA_SIZE_1 245 } 246 247 void testString() 248 { 249 OSString *test1, *test2; 250 void *spaceCheck; 251 int i; 252 char c; 253 bool res = true; 254 255 // very first test initialises the OSMetaClass cache. 256 test1 = OSString::withCStringNoCopy(testC00); 257 TEST_ASSERT('s', "0a", test1); 258 if (test1) 259 test1->release(); 260 261 // Check c string allocation 262 spaceCheck = checkPointSpace(); 263 test1 = OSString::withCString(testC00); 264 TEST_ASSERT('s', "1a", test1); 265 TEST_ASSERT('s', "1b", testC00 != test1->getCStringNoCopy()); 266 TEST_ASSERT('s', "1c", strcmp(testC00, test1->getCStringNoCopy()) == 0); 267 TEST_ASSERT('s', "1d", strlen(testC00) == test1->getLength()); 268 TEST_ASSERT('s', "1e", test1->isEqualTo(testC00)); 269 TEST_ASSERT('s', "1f", !test1->isEqualTo(testC01)); 270 if (test1) test1->release(); 271 res = res && checkSpace("(s)1", spaceCheck, 0); 272 273 // Check c string no allocation 274 spaceCheck = checkPointSpace(); 275 test1 = OSString::withCStringNoCopy(testC00); 276 TEST_ASSERT('s', "2a", test1); 277 TEST_ASSERT('s', "2b", testC00 == test1->getCStringNoCopy()); 278 if (test1) test1->release(); 279 res = res && checkSpace("(s)2", spaceCheck, 0); 280 281 // Check string from other string generation 282 spaceCheck = checkPointSpace(); 283 test1 = OSString::withCStringNoCopy(testC00); 284 TEST_ASSERT('s', "3a", test1); 285 test2 = OSString::withString(test1); 286 TEST_ASSERT('s', "3b", test2); 287 TEST_ASSERT('s', "3c", test1 != test2); 288 TEST_ASSERT('s', "3d", test1->isEqualTo(test2)); 289 if (test1) test1->release(); 290 if (test2) test2->release(); 291 res = res && checkSpace("(s)3", spaceCheck, 0); 292 293 // Check string comparison functionality no copy 294 spaceCheck = checkPointSpace(); 295 test1 = OSString::withCStringNoCopy(testC00); 296 test2 = OSString::withCStringNoCopy(testC01); 297 TEST_ASSERT('s', "4a", test1 && test2); 298 TEST_ASSERT('s', "4b", !test1->isEqualTo(test2)); 299 TEST_ASSERT('s', "4c", !test1->isEqualTo(testC01)); 300 TEST_ASSERT('s', "4d", test1->isEqualTo(testC00)); 301 if (test1) test1->release(); 302 if (test2) test2->release(); 303 res = res && checkSpace("(s)4", spaceCheck, 0); 304 305 // Check string comparison functionality with copy 306 spaceCheck = checkPointSpace(); 307 test1 = OSString::withCString(testC00); 308 test2 = OSString::withCString(testC01); 309 TEST_ASSERT('s', "5a", test1 && test2); 310 TEST_ASSERT('s', "5b", !test1->isEqualTo(test2)); 311 TEST_ASSERT('s', "5c", !test1->isEqualTo(testC01)); 312 TEST_ASSERT('s', "5d", test1->isEqualTo(testC00)); 313 if (test1) test1->release(); 314 if (test2) test2->release(); 315 res = res && checkSpace("(s)5", spaceCheck, 0); 316 317 // Check string inplace modifications 318 spaceCheck = checkPointSpace(); 319 test1 = OSString::withCString(testC00); 320 TEST_ASSERT('s', "6a", test1); 321 for (i = 0; (c = test1->getChar(i)); i++) 322 if (c != testC00[i]) { 323 verPrintf(("testString(s) test 6b failed\n")); res = false; 324 break; 325 } 326 TEST_ASSERT('s', "6c", !c); 327 TEST_ASSERT('s', "6d", test1->setChar(' ', 0)); 328 TEST_ASSERT('s', "6e", !test1->isEqualTo(testC00)); 329 TEST_ASSERT('s', "6f", test1->setChar('T', 0)); 330 TEST_ASSERT('s', "6g", !test1->setChar(' ', sizeof(testC00))); 331 TEST_ASSERT('s', "6h", test1->isEqualTo(testC00)); 332 if (test1) test1->release(); 333 res = res && checkSpace("(s)6", spaceCheck, 0); 334 335 // Check const string fail inplace modifications 336 spaceCheck = checkPointSpace(); 337 test1 = OSString::withCStringNoCopy(testC00); 338 TEST_ASSERT('s', "7a", test1); 339 for (i = 0; (c = test1->getChar(i)); i++) 340 if (c != testC00[i]) { 341 verPrintf(("testString(s) test 7b failed\n")); res = false; 342 break; 343 } 344 TEST_ASSERT('s', "7c", !c); 345 TEST_ASSERT('s', "7d", !test1->setChar(' ', 0)); 346 TEST_ASSERT('s', "7e", test1->isEqualTo(testC00)); 347 TEST_ASSERT('s', "7f", !test1->setChar(' ', sizeof(testC00))); 348 TEST_ASSERT('s', "7g", test1->isEqualTo(testC00)); 349 if (test1) test1->release(); 350 res = res && checkSpace("(s)7", spaceCheck, 0); 351 352 if (res) 353 verPrintf(("testString: All OSString Tests passed\n")); 354 else 355 logPrintf(("testString: Some OSString Tests failed\n")); 356 } 357 358 void testSymbol() 359 { 360 bool res = true; 361 int i, j; 362 int countDups; 363 const OSSymbol *cache[numStrCache]; 364 void *spaceCheck; 365 366 // very first test initialises the OSMetaClass cache. 367 cache[0] = IOSymbol::withCStringNoCopy(testC00); 368 TEST_ASSERT('u', "0a", cache[0]); 369 if (cache[0]) 370 cache[0]->release(); 371 372 spaceCheck = checkPointSpace(); 373 374 // Setup the symbol cache, make sure it grows the symbol unique'ing 375 // hash table. Also determine that the symbol is created ok and that 376 // it is indeed equal to the creating cString by strcmp. 377 for (i = 0; i < numStrCache; i++) { 378 cache[i] = OSSymbol::withCStringNoCopy(strCache[i]); 379 if (!cache[i]) { 380 verPrintf(("testSymbol(u) test 1a%d failed\n", i)); res = false; 381 } 382 else if (!cache[i]->isEqualTo(strCache[i])) { 383 verPrintf(("testSymbol(u) test 1b%d failed\n", i)); res = false; 384 } 385 } 386 387 // The strCache does have some duplicates in it, mostly 'the'. Make 388 // sure that we wind them and that different cache entries really are 389 // different by strcmp. Fundamental to OSSymbol semantics. 390 countDups = 0; 391 for (i = 0; i < numStrCache; i++) 392 for (j = i+1; j < numStrCache; j++) { 393 if (cache[i] != cache[j] && cache[i]->isEqualTo(cache[j])) { 394 verPrintf(("testSymbol(u) test 2a%d,%d failed\n", i, j)); 395 res = false; 396 } 397 else if (cache[i] == cache[j]) { 398 if (cache[i]->getRetainCount() == 1) { 399 verPrintf(("testSymbol(u) test 2b%d,%d failed\n", i, j)); 400 res = false; 401 } 402 countDups++; 403 } 404 } 405 TEST_ASSERT('u', "2c", countDups); 406 407 // Clear out the cache and check that the unique'ing hashtable has grown 408 for (i = 0; i < numStrCache; i++) { 409 if (cache[i]) { 410 cache[i]->release(); 411 cache[i] = 0; 412 } 413 } 414 // As of 1998-11-17 the hash growth is 364. 415 res = res && checkSpace("(u)3", spaceCheck, 972); 416 logSpace(); 417 418 // Check for leaks by repeating the cacheing and freeing 419 spaceCheck = checkPointSpace(); 420 for (i = 0; i < numStrCache; i++) 421 cache[i] = OSSymbol::withCString(strCache[i]); 422 for (i = 0; i < numStrCache; i++) { 423 if (cache[i]) { 424 cache[i]->release(); 425 cache[i] = 0; 426 } 427 } 428 res = res && checkSpace("(u)4", spaceCheck, 0); 429 430 // Check that the OSString based symbol constructors work 431 // and that they don't leak, and finally double check that while 432 // the cache is active the symbol semantics still work. 433 spaceCheck = checkPointSpace(); 434 for (i = 0; i < numStrCache; i++) { 435 OSString *tmpStr; 436 437 tmpStr = (i&1) 438 ? OSString::withCString(strCache[i]) 439 : OSString::withCStringNoCopy(strCache[i]); 440 if (tmpStr) { 441 cache[i] = OSSymbol::withString(tmpStr); 442 if (!cache[i]) { 443 verPrintf(("testSymbol(u) test 5a%d failed\n", i)); 444 res = false; 445 } 446 tmpStr->release(); 447 } 448 } 449 450 for (i = 0; i < numStrCache; i++) { 451 if (cache[i]) { 452 const OSSymbol *tmpSymb; 453 454 tmpSymb = OSSymbol::withCStringNoCopy(strCache[i]); 455 if (cache[i] != tmpSymb) { 456 verPrintf(("testSymbol(u) test 5b%d failed\n", i)); 457 res = false; 458 } 459 tmpSymb->release(); 460 cache[i]->release(); 461 cache[i] = 0; 462 } 463 else { 464 verPrintf(("testSymbol(u) test 5c%d failed\n", i)); 465 res = false; 466 } 467 } 468 res = res && checkSpace("(u)5", spaceCheck, 0); 469 470 if (res) 471 verPrintf(("testSymbol: All OSSymbol Tests passed\n")); 472 else 473 logPrintf(("testSymbol: Some OSSymbol Tests failed\n")); 474 } 475 476 #endif /* DEBUG */ 477