[apple/xnu.git] / iokit / Tests / TestContainers.cpp

/*
 * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
#if DEBUG
#include "Tests.h"

#include <libkern/c++/OSData.h>
#include <libkern/c++/OSString.h>
#include <libkern/c++/OSSymbol.h>

static const char testC00[] = "The quick brown fox jumps over the lazy dog.  ";
static const char testC01[] = "The quick brown fox ";
static const char testC02[] = "jumps over the ";
static const char testC03[] = "lazy dog.  \n";
static const char testC04[] = "The ";
static const char testC05[] = "quick ";
static const char testC06[] = "brown ";
static const char testC07[] = "fox ";
static const char testC08[] = "jumps ";
static const char testC09[] = "over ";
static const char testC10[] = "the ";
static const char testC11[] = "lazy ";
static const char testC12[] = "dog.  \n";
static const char testC13[] = "Now is the time for all good "
                               "men to come to the aid of the party  \n";
static const char testC14[] = "Now is the time for ";
static const char testC15[] = "all good men to come ";
static const char testC16[] = "to the aid of the party  \n";
static const char testC17[] = "Now ";
static const char testC18[] = "is ";
static const char testC19[] = "the ";
static const char testC20[] = "time ";
static const char testC21[] = "for ";
static const char testC22[] = "all ";
static const char testC23[] = "good ";
static const char testC24[] = "men ";
static const char testC25[] = "to ";
static const char testC26[] = "come ";
static const char testC27[] = "to ";
static const char testC28[] = "the ";
static const char testC29[] = "aid ";
static const char testC30[] = "of ";
static const char testC31[] = "the ";
static const char testC32[] = "party.  \n";
static const char testC33[] = "Frank Burns eats worms.  \n";
static const char testC34[] = "Frank Burns ";
static const char testC35[] = "eats worms.  \n";
static const char testC36[] = "Frank ";
static const char testC37[] = "Burns ";
static const char testC38[] = "eats ";
static const char testC39[] = "worms.  \n";
static const char testC40[] = "Tired eyes?  Stiff neck?  Tight shoulders?  "
                              "Aching back?  The right moves can help "
                              "prevent these kinds of problem.  ";
static const char testC41[] = "Tired eyes?  Stiff neck?  ";
static const char testC42[] = "Tight shoulders?  Aching back?  ";
static const char testC43[] = "The right moves can help prevent ";
static const char testC44[] = "these kinds of problem.  ";
static const char testC45[] = "Tired ";
static const char testC46[] = "eyes?  ";
static const char testC47[] = "Stiff ";
static const char testC48[] = "neck?  ";
static const char testC49[] = "Tight ";
static const char testC50[] = "shoulders?  ";
static const char testC51[] = "Aching ";
static const char testC52[] = "back?  ";
static const char testC53[] = "The ";
static const char testC54[] = "right ";
static const char testC55[] = "moves ";
static const char testC56[] = "can ";
static const char testC57[] = "help ";
static const char testC58[] = "prevent ";
static const char testC59[] = "these ";
static const char testC60[] = "kinds ";
static const char testC61[] = "of ";
static const char testC62[] = "problem.  ";

const char *strCache[] = {
    testC00, testC01, testC02, testC03, testC04, testC05, testC06, testC07,
    testC08, testC09, testC10, testC11, testC12, testC13, testC14, testC15,
    testC16, testC17, testC18, testC19, testC20, testC21, testC22, testC23,
    testC24, testC25, testC26, testC27, testC28, testC29, testC30, testC31,
    testC32, testC33, testC34, testC35, testC36, testC37, testC38, testC39, 
    testC40, testC41, testC42, testC43, testC44, testC45, testC46, testC47, 
    testC48, testC49, testC50, testC51, testC52, testC53, testC54, testC55, 
    testC56, testC57, testC58, testC59, testC60, testC61, testC62, 
};
const int numStrCache = ((int) (sizeof(strCache)/sizeof(strCache[0])));

void testData()
{
#define DATA_SIZE_1	 256
#define DATA_SIZE_2	 512
#define DATA_SIZE_3	1024
#define DATA_SIZE_4	8192
    
    OSData *test1, *test2, *test3;
    void *spaceCheck;
    unsigned int len;
    unsigned int i;
    bool res = true;
    unsigned short testData[DATA_SIZE_4/sizeof(short)], *cp;

    // very first test initialises the OSMetaClass cache.
    test1 = OSData::withCapacity(DATA_SIZE_1);
    TEST_ASSERT('d', "0a", test1);
    if (test1)
        test1->release();

    for (i = 0; i < sizeof(testData)/sizeof(short); i++)
        testData[i] = (unsigned short) i;

    // Check empty data allocation
    spaceCheck = checkPointSpace();
    test1 = OSData::withCapacity(DATA_SIZE_1);
    TEST_ASSERT('d', "1a", test1);
    if (test1) {
        TEST_ASSERT('d', "1b", !test1->getLength());
        TEST_ASSERT('d', "1c", test1->getCapacity() == DATA_SIZE_1);
        TEST_ASSERT('d', "1d", !test1->getBytesNoCopy());
        TEST_ASSERT('d', "1e", !test1->getBytesNoCopy(10, DATA_SIZE_1 - 10));
        TEST_ASSERT('d', "1f", test1->appendBytes(spaceCheck, 0));
        TEST_ASSERT('d', "1g", !test1->getLength());
        TEST_ASSERT('d', "1h", test1->getCapacity() == DATA_SIZE_1);
        TEST_ASSERT('d', "1i", !test1->getBytesNoCopy());
        test1->release();
    }
    res = res && checkSpace("(d)1", spaceCheck, 0);

    // Check appending to empty data allocation 
    spaceCheck = checkPointSpace();
    test1 = OSData::withCapacity(DATA_SIZE_1);
    TEST_ASSERT('d', "2a", test1);
    if (test1) {
        TEST_ASSERT('d', "2b", !test1->getLength());
        TEST_ASSERT('d', "2c", !test1->getBytesNoCopy());
        TEST_ASSERT('d', "2d", test1->appendBytes(testData, DATA_SIZE_1));
        TEST_ASSERT('d', "2e", test1->getLength() == DATA_SIZE_1);
        TEST_ASSERT('d', "2f", test1->getBytesNoCopy());
        cp = (unsigned short *) test1->getBytesNoCopy();
        for (i = 0; cp && i < (DATA_SIZE_1/sizeof(short)); i++) {
            TEST_ASSERT('d', "2g", *cp++ == testData[i]);
            if (*cp != testData[i])
                break;
        }
        TEST_ASSERT('d', "2h", test1->getBytesNoCopy(10, DATA_SIZE_1-10));
        cp = (unsigned short *) test1->getBytesNoCopy(10, DATA_SIZE_1 - 10);
        for (i = 5; cp && i < (DATA_SIZE_1/sizeof(short)) - 5; i++) {
            TEST_ASSERT('d', "2i", *cp++ == testData[i]);
            if (*cp != testData[i])
                break;
        }
        TEST_ASSERT('d', "2j", test1->isEqualTo(testData, DATA_SIZE_1));
        test1->release();
    }
    res = res && checkSpace("(d)2", spaceCheck, 0);

    // Check data allocation from some constant data
    spaceCheck = checkPointSpace();
    test1 = OSData::withBytes(testData, sizeof(testData));
    TEST_ASSERT('d', "3a", test1);
    if (test1) {
        TEST_ASSERT('d', "3b", test1->getLength() == sizeof(testData));
        TEST_ASSERT('d', "3c", test1->getCapacity() == sizeof(testData));
        TEST_ASSERT('d', "3d", test1->getBytesNoCopy());
        TEST_ASSERT('d', "3e", test1->getBytesNoCopy(10, sizeof(testData)-10));
        TEST_ASSERT('d', "3f", test1->appendBytes(spaceCheck, 0));
        TEST_ASSERT('d', "3g", test1->getLength() == sizeof(testData));
        TEST_ASSERT('d', "3h", test1->getCapacity() == sizeof(testData));
        TEST_ASSERT('d', "3i", test1->getBytesNoCopy());
        TEST_ASSERT('d', "3j", test1->getBytesNoCopy(10, sizeof(testData)-10));
        TEST_ASSERT('d', "3k", !test1->appendBytes(testData, 10));
        test1->release();
    }
    res = res && checkSpace("(d)3", spaceCheck, 0);

    // Check and continious addition of more data
    spaceCheck = checkPointSpace();
    test1 = OSData::withCapacity(DATA_SIZE_4);
    test2 = OSData::withBytesNoCopy(testData, DATA_SIZE_3);
    len = DATA_SIZE_3;
    TEST_ASSERT('d', "4a", (test1 && test2));
    if (test1 && test2) {
        TEST_ASSERT('d', "4b", !test1->getLength());
        for (i = 0; i < DATA_SIZE_4; i += DATA_SIZE_3)
            TEST_ASSERT('d', "4c", test1->appendBytes(test2));
        TEST_ASSERT('d', "4d", !test1->appendBytes(test2));
        for (i = 0; i < DATA_SIZE_4; i += DATA_SIZE_3) {

            TEST_ASSERT('d', "4e", test2->isEqualTo(
                                        test1->getBytesNoCopy(i, DATA_SIZE_3),
                                        DATA_SIZE_3));

            test3 = OSData::withData(test1, i, DATA_SIZE_3);
            TEST_ASSERT('d', "4f", test3);
            if (test3) {
                TEST_ASSERT('d', "4g", test2->isEqualTo(test3));
                test3->release();
            }

            test3 = OSData::withData(test1, i, len);
            TEST_ASSERT('d', "4i", test3);
            if (test3) {
                TEST_ASSERT('d', "4j", test2->isEqualTo(test3));
                test3->release();
            }
        }
        test1->release();
        test2->release();
    }
    res = res && checkSpace("(d)3", spaceCheck, 0);

    if (res)
        verPrintf(("testData: All OSData Tests passed\n"));
    else
        logPrintf(("testData: Some OSData Tests failed\n"));
#undef DATA_SIZE_4
#undef DATA_SIZE_3
#undef DATA_SIZE_2
#undef DATA_SIZE_1
}

void testString()
{
    OSString *test1, *test2;
    void *spaceCheck;
    int i;
    char c;
    bool res = true;

    // very first test initialises the OSMetaClass cache.
    test1 = OSString::withCStringNoCopy(testC00);
    TEST_ASSERT('s', "0a", test1);
    if (test1)
        test1->release();

    // Check c string allocation
    spaceCheck = checkPointSpace();
    test1 = OSString::withCString(testC00);
    TEST_ASSERT('s', "1a", test1);
    TEST_ASSERT('s', "1b", testC00 != test1->getCStringNoCopy());
    TEST_ASSERT('s', "1c", strcmp(testC00, test1->getCStringNoCopy()) == 0);
    TEST_ASSERT('s', "1d", strlen(testC00) == test1->getLength());
    TEST_ASSERT('s', "1e", test1->isEqualTo(testC00));
    TEST_ASSERT('s', "1f", !test1->isEqualTo(testC01));
    if (test1) test1->release();
    res = res && checkSpace("(s)1", spaceCheck, 0);

    // Check c string no allocation
    spaceCheck = checkPointSpace();
    test1 = OSString::withCStringNoCopy(testC00);
    TEST_ASSERT('s', "2a", test1);
    TEST_ASSERT('s', "2b", testC00 == test1->getCStringNoCopy());
    if (test1) test1->release();
    res = res && checkSpace("(s)2", spaceCheck, 0);

    // Check string from other string generation
    spaceCheck = checkPointSpace();
    test1 = OSString::withCStringNoCopy(testC00);
    TEST_ASSERT('s', "3a", test1);
    test2 = OSString::withString(test1);
    TEST_ASSERT('s', "3b", test2);
    TEST_ASSERT('s', "3c", test1 != test2);
    TEST_ASSERT('s', "3d", test1->isEqualTo(test2));
    if (test1) test1->release();
    if (test2) test2->release();
    res = res && checkSpace("(s)3", spaceCheck, 0);

    // Check string comparison functionality no copy
    spaceCheck = checkPointSpace();
    test1 = OSString::withCStringNoCopy(testC00);
    test2 = OSString::withCStringNoCopy(testC01);
    TEST_ASSERT('s', "4a", test1 && test2);
    TEST_ASSERT('s', "4b", !test1->isEqualTo(test2));
    TEST_ASSERT('s', "4c", !test1->isEqualTo(testC01));
    TEST_ASSERT('s', "4d", test1->isEqualTo(testC00));
    if (test1) test1->release();
    if (test2) test2->release();
    res = res && checkSpace("(s)4", spaceCheck, 0);

    // Check string comparison functionality with copy
    spaceCheck = checkPointSpace();
    test1 = OSString::withCString(testC00);
    test2 = OSString::withCString(testC01);
    TEST_ASSERT('s', "5a", test1 && test2);
    TEST_ASSERT('s', "5b", !test1->isEqualTo(test2));
    TEST_ASSERT('s', "5c", !test1->isEqualTo(testC01));
    TEST_ASSERT('s', "5d", test1->isEqualTo(testC00));
    if (test1) test1->release();
    if (test2) test2->release();
    res = res && checkSpace("(s)5", spaceCheck, 0);

    // Check string inplace modifications
    spaceCheck = checkPointSpace();
    test1 = OSString::withCString(testC00);
    TEST_ASSERT('s', "6a", test1);
    for (i = 0; (c = test1->getChar(i)); i++)
        if (c != testC00[i]) {
            verPrintf(("testString(s) test 6b failed\n")); res = false;
            break;
        }
    TEST_ASSERT('s', "6c", !c);
    TEST_ASSERT('s', "6d", test1->setChar(' ', 0));
    TEST_ASSERT('s', "6e", !test1->isEqualTo(testC00));
    TEST_ASSERT('s', "6f", test1->setChar('T', 0));
    TEST_ASSERT('s', "6g", !test1->setChar(' ', sizeof(testC00)));
    TEST_ASSERT('s', "6h", test1->isEqualTo(testC00));
    if (test1) test1->release();
    res = res && checkSpace("(s)6", spaceCheck, 0);

    // Check const string fail inplace modifications
    spaceCheck = checkPointSpace();
    test1 = OSString::withCStringNoCopy(testC00);
    TEST_ASSERT('s', "7a", test1);
    for (i = 0; (c = test1->getChar(i)); i++)
        if (c != testC00[i]) {
            verPrintf(("testString(s) test 7b failed\n")); res = false;
            break;
        }
    TEST_ASSERT('s', "7c", !c);
    TEST_ASSERT('s', "7d", !test1->setChar(' ', 0));
    TEST_ASSERT('s', "7e", test1->isEqualTo(testC00));
    TEST_ASSERT('s', "7f", !test1->setChar(' ', sizeof(testC00)));
    TEST_ASSERT('s', "7g", test1->isEqualTo(testC00));
    if (test1) test1->release();
    res = res && checkSpace("(s)7", spaceCheck, 0);

    if (res)
        verPrintf(("testString: All OSString Tests passed\n"));
    else
        logPrintf(("testString: Some OSString Tests failed\n"));
}

void testSymbol()
{
    bool res = true;
    int i, j;
    int countDups;
    const OSSymbol *cache[numStrCache];
    void *spaceCheck;

    // very first test initialises the OSMetaClass cache.
    cache[0] = IOSymbol::withCStringNoCopy(testC00);
    TEST_ASSERT('u', "0a", cache[0]);
    if (cache[0])
        cache[0]->release();

    spaceCheck = checkPointSpace();

    // Setup the symbol cache, make sure it grows the symbol unique'ing
    // hash table.  Also determine that the symbol is created ok and that
    // it is indeed equal to the creating cString by strcmp.
    for (i = 0; i < numStrCache; i++) {
        cache[i] = OSSymbol::withCStringNoCopy(strCache[i]);
        if (!cache[i]) {
            verPrintf(("testSymbol(u) test 1a%d failed\n", i)); res = false;
        }
        else if (!cache[i]->isEqualTo(strCache[i])) {
            verPrintf(("testSymbol(u) test 1b%d failed\n", i)); res = false;
        }
    }

    // The strCache does have some duplicates in it, mostly 'the'.  Make
    // sure that we wind them and that different cache entries really are
    // different by strcmp.  Fundamental to OSSymbol semantics.
    countDups = 0;
    for (i = 0; i < numStrCache; i++)
        for (j = i+1; j < numStrCache; j++) {
            if (cache[i] != cache[j] && cache[i]->isEqualTo(cache[j])) {
                verPrintf(("testSymbol(u) test 2a%d,%d failed\n", i, j));
                res = false;
            }
            else if (cache[i] == cache[j]) {
                if (cache[i]->getRetainCount() == 1) {
                    verPrintf(("testSymbol(u) test 2b%d,%d failed\n", i, j));
                    res = false;
                }
                countDups++;
            }
        }
    TEST_ASSERT('u', "2c", countDups);

    // Clear out the cache and check that the unique'ing hashtable has grown
    for (i = 0; i < numStrCache; i++) {
        if (cache[i]) {
            cache[i]->release();
            cache[i] = 0;
        }
    }
    // As of 1998-11-17 the hash growth is 364.
    res = res && checkSpace("(u)3", spaceCheck, 972);
    logSpace();

    // Check for leaks by repeating the cacheing and freeing
    spaceCheck = checkPointSpace();
    for (i = 0; i < numStrCache; i++)
        cache[i] = OSSymbol::withCString(strCache[i]);
    for (i = 0; i < numStrCache; i++) {
        if (cache[i]) {
            cache[i]->release();
            cache[i] = 0;
        }
    }
    res = res && checkSpace("(u)4", spaceCheck, 0);

    // Check that the OSString based symbol constructors work
    // and that they don't leak, and finally double check that while
    // the cache is active the symbol semantics still work.
    spaceCheck = checkPointSpace();
    for (i = 0; i < numStrCache; i++) {
        OSString *tmpStr;

        tmpStr = (i&1)
               ? OSString::withCString(strCache[i])
               : OSString::withCStringNoCopy(strCache[i]);
        if (tmpStr) {
            cache[i] = OSSymbol::withString(tmpStr);
            if (!cache[i]) {
                verPrintf(("testSymbol(u) test 5a%d failed\n", i));
                res = false;
            }
            tmpStr->release();
        }
    }

    for (i = 0; i < numStrCache; i++) {
        if (cache[i]) {
            const OSSymbol *tmpSymb;

            tmpSymb = OSSymbol::withCStringNoCopy(strCache[i]);
            if (cache[i] != tmpSymb) {
                verPrintf(("testSymbol(u) test 5b%d failed\n", i));
                res = false;
            }
            tmpSymb->release();
            cache[i]->release();
            cache[i] = 0;
        }
        else {
            verPrintf(("testSymbol(u) test 5c%d failed\n", i));
            res = false;
        }
    }
    res = res && checkSpace("(u)5", spaceCheck, 0);

    if (res)
        verPrintf(("testSymbol: All OSSymbol Tests passed\n"));
    else
        logPrintf(("testSymbol: Some OSSymbol Tests failed\n"));
}

#endif /* DEBUG */
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
	3	*
6601e61a	4	* @APPLE_LICENSE_HEADER_START@
1c79356b	5	*
6601e61a A	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.
8f6c56a5	11	*
6601e61a A	12	* This Original Code and all software distributed under the License are
6601e61a A	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
8f6c56a5 A	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
8f6c56a5 A	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
6601e61a A	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.
8f6c56a5	19	*
6601e61a	20	* @APPLE_LICENSE_HEADER_END@
1c79356b A	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 */