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

/*
 * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 *
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 *
 * The 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, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_OSREFERENCE_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	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
0a7de745	5	*
2d21ac55 A	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.
0a7de745	14	*
2d21ac55 A	15	* Please obtain a copy of the License at
2d21ac55 A	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
0a7de745	17	*
2d21ac55 A	18	* The Original Code and all software distributed under the License are
2d21ac55 A	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
8f6c56a5 A	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
8f6c56a5 A	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
2d21ac55 A	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.
0a7de745	25	*
2d21ac55	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	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 "
0a7de745	49	"men to come to the aid of the party \n";
1c79356b A	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? "
0a7de745 A	77	"Aching back? The right moves can help "
0a7de745 A	78	"prevent these kinds of problem. ";
1c79356b A	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[] = {
0a7de745 A	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,
1c79356b	111	};
0a7de745	112	const int numStrCache = ((int) (sizeof(strCache) / sizeof(strCache[0])));
1c79356b	113
0a7de745 A	114	void
0a7de745 A	115	testData()
1c79356b	116	{
0a7de745 A	117	#define DATA_SIZE_1 256
	118	#define DATA_SIZE_2 512
	119	#define DATA_SIZE_3 1024
	120	#define DATA_SIZE_4 8192
	121
	122	OSData test1, test2, *test3;
	123	void *spaceCheck;
	124	unsigned int len;
	125	unsigned int i;
	126	bool res = true;
	127	unsigned short testData[DATA_SIZE_4 / sizeof(short)], *cp;
	128
	129	// very first test initialises the OSMetaClass cache.
	130	test1 = OSData::withCapacity(DATA_SIZE_1);
	131	TEST_ASSERT('d', "0a", test1);
	132	if (test1) {
	133	test1->release();
	134	}
	135
	136	for (i = 0; i < sizeof(testData) / sizeof(short); i++) {
	137	testData[i] = (unsigned short) i;
	138	}
	139
	140	// Check empty data allocation
	141	spaceCheck = checkPointSpace();
	142	test1 = OSData::withCapacity(DATA_SIZE_1);
	143	TEST_ASSERT('d', "1a", test1);
	144	if (test1) {
	145	TEST_ASSERT('d', "1b", !test1->getLength());
	146	TEST_ASSERT('d', "1c", test1->getCapacity() == DATA_SIZE_1);
	147	TEST_ASSERT('d', "1d", !test1->getBytesNoCopy());
	148	TEST_ASSERT('d', "1e", !test1->getBytesNoCopy(10, DATA_SIZE_1 - 10));
	149	TEST_ASSERT('d', "1f", test1->appendBytes(spaceCheck, 0));
	150	TEST_ASSERT('d', "1g", !test1->getLength());
	151	TEST_ASSERT('d', "1h", test1->getCapacity() == DATA_SIZE_1);
	152	TEST_ASSERT('d', "1i", !test1->getBytesNoCopy());
	153	test1->release();
	154	}
	155	res = res && checkSpace("(d)1", spaceCheck, 0);
	156
	157	// Check appending to empty data allocation
	158	spaceCheck = checkPointSpace();
	159	test1 = OSData::withCapacity(DATA_SIZE_1);
	160	TEST_ASSERT('d', "2a", test1);
	161	if (test1) {
	162	TEST_ASSERT('d', "2b", !test1->getLength());
	163	TEST_ASSERT('d', "2c", !test1->getBytesNoCopy());
	164	TEST_ASSERT('d', "2d", test1->appendBytes(testData, DATA_SIZE_1));
	165	TEST_ASSERT('d', "2e", test1->getLength() == DATA_SIZE_1);
	166	TEST_ASSERT('d', "2f", test1->getBytesNoCopy());
	167	cp = (unsigned short *) test1->getBytesNoCopy();
	168	for (i = 0; cp && i < (DATA_SIZE_1 / sizeof(short)); i++) {
	169	TEST_ASSERT('d', "2g", *cp++ == testData[i]);
	170	if (*cp != testData[i]) {
	171	break;
	172	}
	173	}
	174	TEST_ASSERT('d', "2h", test1->getBytesNoCopy(10, DATA_SIZE_1 - 10));
	175	cp = (unsigned short *) test1->getBytesNoCopy(10, DATA_SIZE_1 - 10);
	176	for (i = 5; cp && i < (DATA_SIZE_1 / sizeof(short)) - 5; i++) {
	177	TEST_ASSERT('d', "2i", *cp++ == testData[i]);
	178	if (*cp != testData[i]) {
	179	break;
	180	}
181	}
182	TEST_ASSERT('d', "2j", test1->isEqualTo(testData, DATA_SIZE_1));
183	test1->release();
184	}
185	res = res && checkSpace("(d)2", spaceCheck, 0);
186
187	// Check data allocation from some constant data
188	spaceCheck = checkPointSpace();
189	test1 = OSData::withBytes(testData, sizeof(testData));
190	TEST_ASSERT('d', "3a", test1);
191	if (test1) {
192	TEST_ASSERT('d', "3b", test1->getLength() == sizeof(testData));
193	TEST_ASSERT('d', "3c", test1->getCapacity() == sizeof(testData));
194	TEST_ASSERT('d', "3d", test1->getBytesNoCopy());
195	TEST_ASSERT('d', "3e", test1->getBytesNoCopy(10, sizeof(testData) - 10));
196	TEST_ASSERT('d', "3f", test1->appendBytes(spaceCheck, 0));
197	TEST_ASSERT('d', "3g", test1->getLength() == sizeof(testData));
198	TEST_ASSERT('d', "3h", test1->getCapacity() == sizeof(testData));
199	TEST_ASSERT('d', "3i", test1->getBytesNoCopy());
200	TEST_ASSERT('d', "3j", test1->getBytesNoCopy(10, sizeof(testData) - 10));
201	TEST_ASSERT('d', "3k", !test1->appendBytes(testData, 10));
202	test1->release();
203	}
204	res = res && checkSpace("(d)3", spaceCheck, 0);
205
206	// Check and continious addition of more data
207	spaceCheck = checkPointSpace();
208	test1 = OSData::withCapacity(DATA_SIZE_4);
209	test2 = OSData::withBytesNoCopy(testData, DATA_SIZE_3);
210	len = DATA_SIZE_3;
211	TEST_ASSERT('d', "4a", (test1 && test2));
212	if (test1 && test2) {
213	TEST_ASSERT('d', "4b", !test1->getLength());
214	for (i = 0; i < DATA_SIZE_4; i += DATA_SIZE_3) {
215	TEST_ASSERT('d', "4c", test1->appendBytes(test2));
216	}
217	TEST_ASSERT('d', "4d", !test1->appendBytes(test2));
218	for (i = 0; i < DATA_SIZE_4; i += DATA_SIZE_3) {
219	TEST_ASSERT('d', "4e", test2->isEqualTo(
220	test1->getBytesNoCopy(i, DATA_SIZE_3),
221	DATA_SIZE_3));
222
223	test3 = OSData::withData(test1, i, DATA_SIZE_3);
224	TEST_ASSERT('d', "4f", test3);
225	if (test3) {
226	TEST_ASSERT('d', "4g", test2->isEqualTo(test3));
227	test3->release();
228	}
229
230	test3 = OSData::withData(test1, i, len);
231	TEST_ASSERT('d', "4i", test3);
232	if (test3) {
233	TEST_ASSERT('d', "4j", test2->isEqualTo(test3));
234	test3->release();
235	}
236	}
237	test1->release();
238	test2->release();
239	}
240	res = res && checkSpace("(d)3", spaceCheck, 0);
241
242	if (res) {
243	verPrintf(("testData: All OSData Tests passed\n"));
244	} else {
245	logPrintf(("testData: Some OSData Tests failed\n"));
246	}
1c79356b A	247	#undef DATA_SIZE_4
	248	#undef DATA_SIZE_3
	249	#undef DATA_SIZE_2
	250	#undef DATA_SIZE_1
	251	}
	252
0a7de745 A	253	void
0a7de745 A	254	testString()
1c79356b	255	{
0a7de745 A	256	OSString test1, test2;
	257	void *spaceCheck;
	258	int i;
	259	char c;
	260	bool res = true;
	261
	262	// very first test initialises the OSMetaClass cache.
	263	test1 = OSString::withCStringNoCopy(testC00);
	264	TEST_ASSERT('s', "0a", test1);
	265	if (test1) {
	266	test1->release();
	267	}
	268
	269	// Check c string allocation
	270	spaceCheck = checkPointSpace();
	271	test1 = OSString::withCString(testC00);
	272	TEST_ASSERT('s', "1a", test1);
	273	TEST_ASSERT('s', "1b", testC00 != test1->getCStringNoCopy());
	274	TEST_ASSERT('s', "1c", strcmp(testC00, test1->getCStringNoCopy()) == 0);
	275	TEST_ASSERT('s', "1d", strlen(testC00) == test1->getLength());
	276	TEST_ASSERT('s', "1e", test1->isEqualTo(testC00));
	277	TEST_ASSERT('s', "1f", !test1->isEqualTo(testC01));
	278	if (test1) {
	279	test1->release();
	280	}
	281	res = res && checkSpace("(s)1", spaceCheck, 0);
	282
	283	// Check c string no allocation
	284	spaceCheck = checkPointSpace();
	285	test1 = OSString::withCStringNoCopy(testC00);
	286	TEST_ASSERT('s', "2a", test1);
	287	TEST_ASSERT('s', "2b", testC00 == test1->getCStringNoCopy());
	288	if (test1) {
	289	test1->release();
	290	}
	291	res = res && checkSpace("(s)2", spaceCheck, 0);
	292
	293	// Check string from other string generation
	294	spaceCheck = checkPointSpace();
	295	test1 = OSString::withCStringNoCopy(testC00);
	296	TEST_ASSERT('s', "3a", test1);
	297	test2 = OSString::withString(test1);
	298	TEST_ASSERT('s', "3b", test2);
	299	TEST_ASSERT('s', "3c", test1 != test2);
	300	TEST_ASSERT('s', "3d", test1->isEqualTo(test2));
	301	if (test1) {
	302	test1->release();
	303	}
	304	if (test2) {
	305	test2->release();
	306	}
	307	res = res && checkSpace("(s)3", spaceCheck, 0);
	308
	309	// Check string comparison functionality no copy
	310	spaceCheck = checkPointSpace();
	311	test1 = OSString::withCStringNoCopy(testC00);
	312	test2 = OSString::withCStringNoCopy(testC01);
	313	TEST_ASSERT('s', "4a", test1 && test2);
	314	TEST_ASSERT('s', "4b", !test1->isEqualTo(test2));
	315	TEST_ASSERT('s', "4c", !test1->isEqualTo(testC01));
	316	TEST_ASSERT('s', "4d", test1->isEqualTo(testC00));
	317	if (test1) {
	318	test1->release();
	319	}
320	if (test2) {
321	test2->release();
322	}
323	res = res && checkSpace("(s)4", spaceCheck, 0);
324
325	// Check string comparison functionality with copy
326	spaceCheck = checkPointSpace();
327	test1 = OSString::withCString(testC00);
328	test2 = OSString::withCString(testC01);
329	TEST_ASSERT('s', "5a", test1 && test2);
330	TEST_ASSERT('s', "5b", !test1->isEqualTo(test2));
331	TEST_ASSERT('s', "5c", !test1->isEqualTo(testC01));
332	TEST_ASSERT('s', "5d", test1->isEqualTo(testC00));
333	if (test1) {
334	test1->release();
335	}
336	if (test2) {
337	test2->release();
338	}
339	res = res && checkSpace("(s)5", spaceCheck, 0);
340
341	// Check string inplace modifications
342	spaceCheck = checkPointSpace();
343	test1 = OSString::withCString(testC00);
344	TEST_ASSERT('s', "6a", test1);
345	for (i = 0; (c = test1->getChar(i)); i++) {
346	if (c != testC00[i]) {
347	verPrintf(("testString(s) test 6b failed\n")); res = false;
348	break;
349	}
350	}
351	TEST_ASSERT('s', "6c", !c);
352	TEST_ASSERT('s', "6d", test1->setChar(' ', 0));
353	TEST_ASSERT('s', "6e", !test1->isEqualTo(testC00));
354	TEST_ASSERT('s', "6f", test1->setChar('T', 0));
355	TEST_ASSERT('s', "6g", !test1->setChar(' ', sizeof(testC00)));
356	TEST_ASSERT('s', "6h", test1->isEqualTo(testC00));
357	if (test1) {
358	test1->release();
359	}
360	res = res && checkSpace("(s)6", spaceCheck, 0);
361
362	// Check const string fail inplace modifications
363	spaceCheck = checkPointSpace();
364	test1 = OSString::withCStringNoCopy(testC00);
365	TEST_ASSERT('s', "7a", test1);
366	for (i = 0; (c = test1->getChar(i)); i++) {
367	if (c != testC00[i]) {
368	verPrintf(("testString(s) test 7b failed\n")); res = false;
369	break;
370	}
371	}
372	TEST_ASSERT('s', "7c", !c);
373	TEST_ASSERT('s', "7d", !test1->setChar(' ', 0));
374	TEST_ASSERT('s', "7e", test1->isEqualTo(testC00));
375	TEST_ASSERT('s', "7f", !test1->setChar(' ', sizeof(testC00)));
376	TEST_ASSERT('s', "7g", test1->isEqualTo(testC00));
377	if (test1) {
378	test1->release();
379	}
380	res = res && checkSpace("(s)7", spaceCheck, 0);
381
382	if (res) {
383	verPrintf(("testString: All OSString Tests passed\n"));
384	} else {
385	logPrintf(("testString: Some OSString Tests failed\n"));
386	}
1c79356b A	387	}
1c79356b A	388
0a7de745 A	389	void
0a7de745 A	390	testSymbol()
1c79356b	391	{
0a7de745 A	392	bool res = true;
	393	int i, j;
	394	int countDups;
	395	const OSSymbol *cache[numStrCache];
	396	void *spaceCheck;
	397
	398	// very first test initialises the OSMetaClass cache.
	399	cache[0] = IOSymbol::withCStringNoCopy(testC00);
	400	TEST_ASSERT('u', "0a", cache[0]);
	401	if (cache[0]) {
	402	cache[0]->release();
	403	}
	404
	405	spaceCheck = checkPointSpace();
	406
	407	// Setup the symbol cache, make sure it grows the symbol unique'ing
	408	// hash table. Also determine that the symbol is created ok and that
	409	// it is indeed equal to the creating cString by strcmp.
	410	for (i = 0; i < numStrCache; i++) {
	411	cache[i] = OSSymbol::withCStringNoCopy(strCache[i]);
	412	if (!cache[i]) {
	413	verPrintf(("testSymbol(u) test 1a%d failed\n", i)); res = false;
	414	} else if (!cache[i]->isEqualTo(strCache[i])) {
	415	verPrintf(("testSymbol(u) test 1b%d failed\n", i)); res = false;
	416	}
	417	}
	418
	419	// The strCache does have some duplicates in it, mostly 'the'. Make
	420	// sure that we wind them and that different cache entries really are
	421	// different by strcmp. Fundamental to OSSymbol semantics.
	422	countDups = 0;
	423	for (i = 0; i < numStrCache; i++) {
	424	for (j = i + 1; j < numStrCache; j++) {
	425	if (cache[i] != cache[j] && cache[i]->isEqualTo(cache[j])) {
	426	verPrintf(("testSymbol(u) test 2a%d,%d failed\n", i, j));
	427	res = false;
	428	} else if (cache[i] == cache[j]) {
	429	if (cache[i]->getRetainCount() == 1) {
	430	verPrintf(("testSymbol(u) test 2b%d,%d failed\n", i, j));
	431	res = false;
	432	}
	433	countDups++;
	434	}
	435	}
	436	}
	437	TEST_ASSERT('u', "2c", countDups);
	438
	439	// Clear out the cache and check that the unique'ing hashtable has grown
	440	for (i = 0; i < numStrCache; i++) {
	441	if (cache[i]) {
	442	cache[i]->release();
	443	cache[i] = 0;
	444	}
	445	}
	446	// As of 1998-11-17 the hash growth is 364.
	447	res = res && checkSpace("(u)3", spaceCheck, 972);
	448	logSpace();
	449
	450	// Check for leaks by repeating the cacheing and freeing
	451	spaceCheck = checkPointSpace();
	452	for (i = 0; i < numStrCache; i++) {
	453	cache[i] = OSSymbol::withCString(strCache[i]);
	454	}
	455	for (i = 0; i < numStrCache; i++) {
456	if (cache[i]) {
457	cache[i]->release();
458	cache[i] = 0;
459	}
460	}
461	res = res && checkSpace("(u)4", spaceCheck, 0);
462
463	// Check that the OSString based symbol constructors work
464	// and that they don't leak, and finally double check that while
465	// the cache is active the symbol semantics still work.
466	spaceCheck = checkPointSpace();
467	for (i = 0; i < numStrCache; i++) {
468	OSString *tmpStr;
469
470	tmpStr = (i & 1)
471	? OSString::withCString(strCache[i])
472	: OSString::withCStringNoCopy(strCache[i]);
473	if (tmpStr) {
474	cache[i] = OSSymbol::withString(tmpStr);
475	if (!cache[i]) {
476	verPrintf(("testSymbol(u) test 5a%d failed\n", i));
477	res = false;
478	}
479	tmpStr->release();
480	}
481	}
482
483	for (i = 0; i < numStrCache; i++) {
484	if (cache[i]) {
485	const OSSymbol *tmpSymb;
486
487	tmpSymb = OSSymbol::withCStringNoCopy(strCache[i]);
488	if (cache[i] != tmpSymb) {
489	verPrintf(("testSymbol(u) test 5b%d failed\n", i));
490	res = false;
491	}
492	tmpSymb->release();
493	cache[i]->release();
494	cache[i] = 0;
495	} else {
496	verPrintf(("testSymbol(u) test 5c%d failed\n", i));
497	res = false;
498	}
499	}
500	res = res && checkSpace("(u)5", spaceCheck, 0);
501
502	if (res) {
503	verPrintf(("testSymbol: All OSSymbol Tests passed\n"));
504	} else {
505	logPrintf(("testSymbol: Some OSSymbol Tests failed\n"));
506	}
1c79356b A	507	}
	508
	509	#endif /* DEBUG */