iokit/Tests/TestContainers.cpp

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