![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to StringTest.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / objc / Test|
Return to StringTest.m CVS log | Up to [Apple Darwin 0.x] / objc / Test |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * "Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.0 (the 'License'). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License."
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24: /*
25: StringTest.m by Ali Ozer
26: Run with -v for verbose mode (where all results, successful or not, are shown).
27: */
28:
29: #ifdef TESTING
30: #define NXString NxString
31: #define NXMutableString NxMutableString
32: #define NXReadWriteString NxReadWriteString
33: #define NXReadOnlyString NxReadOnlyString
34: #define NXReadOnlySubstring NxReadOnlySubstring
35: #define NXSimpleReadOnlyString NxSimpleReadOnlyString
36: #define NXUniquedString NxUniquedString
37: #define NXGapString NxGapString
38: #define NXBigString NxBigString
39: #endif
40:
41: #import "NXString.h"
42:
43: #define TESTTESTEDSTUFF
44: // #define TESTGAPSTRING
45: // #define TESTBIGSTRING
46:
47: #ifdef TESTGAPSTRING
48: #import "NXGapString.h"
49: #endif
50: #ifdef TESTBIGSTRING
51: #import "NXBigString.h"
52: #endif
53:
54: #define TESTCONSTANTSTRING
55:
56: #import <stdio.h>
57: #import <streams/streams.h>
58: #import <appkit/nextstd.h>
59: #import <libc.h>
60:
61: #define CHARALLOC(zone, var, num) var = ((num) ? NXZoneMalloc((zone), sizeof(unichar) * (num)) : NULL)
62:
63: static int numErrors;
64: static BOOL verbose;
65:
66: @interface NXString (DebugStuff)
67:
68: - (void)verifyInt:(int)value :(int)desired;
69: - (void)verifyCStrings:(const char *)value :(const char *)desired;
70: - (void)verifyChars:(const char *)theRealThing;
71: - (void)verifyId:theRealThing;
72: - (void)verifyString:theRealThing;
73:
74: @end
75:
76: @implementation NXString (DebugStuff)
77:
78: static Err()
79: {
80: // Place to break on...
81: numErrors++;
82: }
83:
84: - (void)verifyChars:(const char *)theRealThing
85: {
86: unichar buffer[1000];
87: BOOL equal;
88:
89: [self getCharacters:buffer];
90:
91: if (equal = ([self length] == strlen(theRealThing))) {
92: int cnt, length = [self length];
93: for (cnt = 0; cnt < length; cnt++) {
94: if (buffer[cnt] != (unichar)theRealThing[cnt]) {
95: equal = NO;
96: break;
97: }
98: }
99: }
100:
101: if (verbose || !equal) {
102: fprintf (stderr, "%s:", equal ? "OK" : "*** NOT OK");
103: fprintf (stderr, " %p ", self);
104: [self printForDebugger: NXOpenFile (fileno (stderr), NX_WRITEONLY)];
105: fprintf (stderr, "\n");
106:
107: if (!equal) {
108: fprintf (stderr, "*** Should be: %s\n", theRealThing);
109: Err();
110: }
111: }
112: }
113:
114: - (void)verifyInt:(int)value :(int)desired
115: {
116: BOOL equal = (value == desired);
117:
118: if (verbose || !equal) {
119: fprintf (stderr, "%s:", equal ? "OK" : "*** NOT OK");
120: fprintf (stderr, " %p ", self);
121: [self printForDebugger: NXOpenFile (fileno (stderr), NX_WRITEONLY)];
122: fprintf (stderr, "\n");
123:
124: if (!equal) {
125: fprintf (stderr, "*** %d should be: %d\n", value, desired);
126: Err();
127: }
128: }
129: }
130:
131: - (void)verifyCStrings:(const char *)value :(const char *)desired
132: {
133: BOOL equal = !strcmp(value, desired);
134:
135: if (verbose || !equal) {
136: fprintf (stderr, "%s:", equal ? "OK" : "*** NOT OK");
137: fprintf (stderr, " %p ", self);
138: [self printForDebugger: NXOpenFile (fileno (stderr), NX_WRITEONLY)];
139: fprintf (stderr, "\n");
140:
141: if (!equal) {
142: fprintf (stderr, "*** %s should be: %s\n", value, desired);
143: Err();
144: }
145: }
146: }
147:
148: - (void)verifyId:theRealThing
149: {
150: BOOL equal = (theRealThing == self);
151:
152: if (verbose || !equal) {
153: fprintf (stderr, "%s:", equal ? "OK" : "*** NOT OK");
154: fprintf (stderr, " %p ", self);
155: [self printForDebugger: NXOpenFile (fileno (stderr), NX_WRITEONLY)];
156: fprintf (stderr, "\n");
157:
158: if (!equal) {
159: fprintf (stderr, "*** Should be: %p\n", theRealThing);
160: Err();
161: }
162: }
163: }
164:
165: - (void)verifyString:theRealThing
166: {
167: BOOL equal = ([self isEqual:theRealThing]);
168:
169: if (verbose || !equal) {
170: fprintf (stderr, "%s:", equal ? "OK" : "*** NOT OK");
171: fprintf (stderr, " %p ", self);
172: [self printForDebugger: NXOpenFile (fileno (stderr), NX_WRITEONLY)];
173: fprintf (stderr, "\n");
174:
175: if (!equal) {
176: fprintf (stderr, "*** Should be: ");
177: [theRealThing printForDebugger: NXOpenFile (fileno (stderr), NX_WRITEONLY)];
178: fprintf (stderr, "\n");
179: Err();
180: }
181: }
182: }
183:
184: @end
185:
186: #define TITLE(title) \
187: printf ("%s%s %s%s\n", \
188: verbose ? "\n" : "", \
189: [testClass name], \
190: (title), \
191: verbose ? ":" : "...")
192:
193: #define TITLE1(title) \
194: printf ("%s%s%s\n", \
195: verbose ? "\n" : "", \
196: (title), \
197: verbose ? ":" : "...")
198:
199: /* This function returns a string containing 200 occurences of "ab..yz"
200: */
201: static NXString *hugeString (id testClass)
202: {
203: #define HUGESTRINGLEN 5200
204: static char buf[HUGESTRINGLEN] = {'\0'};
205: if (buf[0] == '\0') {
206: int cnt;
207: for (cnt = 0; cnt < HUGESTRINGLEN; cnt++) buf[cnt] = ('a' + (cnt % 26));
208: }
209: return [[testClass alloc] initFromCString:buf];
210: }
211:
212: void testBasic /* create/read/copy/free */ (id testClass)
213: {
214: id str1, str2, str3;
215: unichar chars1[] = {'A', 'B', 'C', 'D', 'E'};
216: unichar chars2[] = {'F', 'G', 'H', 'I', 'J'};
217: unichar chars3[] = {'K', 'L', 'M', 'N', 'O'};
218: unichar *charPtr;
219: NXRange range = {1, 2};
220: NXRange tmpRange = {0, 0};
221:
222: TITLE ("basic create/read/copy/free test");
223:
224: str1 = [[testClass alloc] initFromCharacters:chars1 length:5];
225: str2 = [[testClass alloc] initFromString:str1];
226: str3 = [[testClass alloc] initFromString:str2 range:range];
227: [str3 verifyChars:"BC"];
228: [str3 free];
229: str3 = [str2 copy];
230: [str3 verifyChars:"ABCDE"];
231: [str2 free];
232: [str3 verifyChars:"ABCDE"];
233: [str3 free];
234:
235: str3 = [[testClass alloc] initFromCharacters:chars2 length:5];
236: CHARALLOC(NXDefaultMallocZone(), charPtr, NX_LENGTH(range));
237: [str3 getCharacters:charPtr range:range];
238: str2 = [[testClass alloc] initFromCharacters:charPtr length:NX_LENGTH(range)];
239: [str3 verifyChars:"FGHIJ"];
240: [str2 verifyChars:"GH"];
241: [str2 free];
242: NX_FREE (charPtr);
243:
244: NX_LOCATION(tmpRange) = 1;
245: NX_LENGTH(tmpRange) = [str3 length] - 1;
246: CHARALLOC(NXDefaultMallocZone(), charPtr, NX_LENGTH(tmpRange));
247: [str3 getCharacters:charPtr range:tmpRange];
248: str2 = [[testClass alloc] initFromCharacters:charPtr length:NX_LENGTH(tmpRange)];
249: [str2 verifyChars:"GHIJ"];
250: [str2 free];
251: [str3 free];
252: [str1 free];
253: NX_FREE (charPtr);
254:
255: str3 = [[testClass alloc] initFromCharacters:chars3 length:5];
256: str2 = [str3 copy];
257: NX_LOCATION(tmpRange) = 0;
258: NX_LENGTH(tmpRange) = [str2 length];
259: CHARALLOC(NXDefaultMallocZone(), charPtr, NX_LENGTH(tmpRange));
260: [str2 getCharacters:charPtr range:tmpRange];
261: str1 = [[testClass alloc] initFromCharactersNoCopy:charPtr length:NX_LENGTH(tmpRange)];
262: [str3 free];
263: [str2 verifyChars:"KLMNO"];
264: [str2 free];
265: [str1 verifyChars:"KLMNO"];
266: [str1 free];
267:
268: str1 = [[testClass alloc] init];
269: str2 = [[testClass alloc] init];
270: [str1 free];
271: str1 = [str2 copy];
272: str3 = [[testClass alloc] initFromCharacters:NULL length:0];
273: [str2 free];
274: [str3 verifyChars:""];
275: [str3 free];
276: [str1 verifyChars:""];
277: [str1 free];
278:
279: }
280:
281: void testCopy /* copy */ (id testClass)
282: {
283: id str1, str2, str3, str4;
284: unichar chars1[] = {'A', 'B', 'C', 'D', 'E'};
285: NXRange range = {1,3};
286:
287: TITLE ("mutable/immutable copy test");
288:
289: str1 = [[testClass alloc] initFromCharacters:chars1 length:5];
290: str2 = [str1 mutableCopy];
291: [str2 appendString:str1];
292: [str2 verifyChars:"ABCDEABCDE"];
293: str3 = [str1 copySubstring:range];
294: str4 = [str2 copySubstring:range];
295: [str4 appendString:str3];
296: [str4 verifyChars:"BCDBCD"];
297: [str1 free];
298: [str2 free];
299: str1 = [str3 mutableCopy];
300: [str1 insertString:str4 at:1];
301: [str1 verifyChars:"BBCDBCDCD"];
302: [str3 verifyChars:"BCD"];
303: [str4 verifyChars:"BCDBCD"];
304: [str3 free];
305: [str4 free];
306: [str1 verifyChars:"BBCDBCDCD"];
307: [str1 free];
308:
309: }
310:
311: void testRefCountedAndUniqued ()
312: {
313: id str1, str2, str3, str4;
314: unichar chars1[] = {'A', 'B', 'C', 'D', 'E'};
315: NXRange range = {1,3};
316: typedef struct {@defs(NXReadOnlyString);} ROString;
317:
318: TITLE1 ("NXReadOnlyString, NXReadWriteString, NXUniquedString tests");
319:
320: str1 = [[NXReadOnlyString alloc] initFromCharacters:chars1 length:5];
321: str2 = [str1 mutableCopy];
322: str3 = [str2 immutableCopy];
323: [str1 verifyInt:(int)str3 :(int)str1];
324: [str2 free];
325: str2 = [[NXReadWriteString alloc] initFromCharacters:chars1 length:3];
326: [str1 verifyInt:(int)str3 :(int)str1];
327: [str1 free];
328: [str3 verifyChars:"ABCDE"];
329: [str2 appendString:str3];
330: [str3 free];
331: [str2 verifyChars:"ABCABCDE"];
332:
333: str1 = [[NXReadOnlyString alloc] initFromCharactersNoCopy:chars1 length:5 freeWhenDone:NO];
334: str2 = [str1 mutableCopy];
335: str3 = [str2 immutableCopy];
336: [str2 free];
337: str2 = [str3 copySubstring:range];
338: [str1 verifyInt:(int)(((ROString *)str1)->characters)+1 :(int)(((ROString *)str2)->characters)];
339:
340: [str1 free];
341: [str3 verifyChars:"ABCDE"];
342: [str3 free];
343: str3 = [str2 mutableCopy];
344: [str3 insertString:str2 at:1];
345: [str3 verifyChars:"BBCDCD"];
346: [str3 deleteCharactersInRange:range];
347: [str3 verifyChars:"BCD"];
348: [str2 verifyChars:"BCD"];
349:
350: str1 = [NXUniquedString newFromString:str3];
351: str4 = [NXUniquedString newFromString:str2];
352: [str1 verifyInt:(int)str4 :(int)str1];
353: [str1 verifyInt:(int)[NXUniquedString newFromString:[str4 mutableCopy]] :(int)str1];
354:
355: }
356:
357:
358: void testEdit /* edit */ (id testClass)
359: {
360: id str1, str2, str3;
361: typedef struct _NXReadWriteStringKludge {
362: @defs(NXReadWriteString);
363: } NXReadWriteStringKludge;
364: typedef struct _NXReadOnlyStringKludge {
365: @defs(NXReadOnlyString);
366: } NXReadOnlyStringKludge;
367: unichar chars1[] = {'A', 'B', 'C', 'D', 'E'};
368: unichar chars2[] = {'F', 'G', 'H', 'I', 'J'};
369: unichar chars3[] = {'K', 'L', 'M', 'N', 'O'};
370: int addr = 0;
371: NXRange range = {1, 2};
372:
373: TITLE ("appendString/delete/insertString test");
374:
375: str1 = [[testClass alloc] initFromCharacters:chars1 length:5];
376: str2 = [[testClass alloc] initFromString:str1 range:range];
377: [str1 appendString:str2];
378: [str1 verifyChars:"ABCDEBC"];
379: [str2 verifyChars:"BC"];
380: [str1 insertString:str2 at:0];
381: [str1 insertString:str2 at:3];
382: [str1 deleteCharactersInRange:range];
383: [str1 verifyChars:"BBCBCDEBC"];
384: [str1 free];
385:
386: str1 = [[NXReadOnlyString alloc] initFromCharacters:chars3 length:5];
387: [str2 appendString:str1];
388: [str1 free];
389: [str2 verifyChars:"BCKLMNO"];
390: if (testClass == [NXReadWriteString class]) {
391: addr = (int)((NXReadOnlyStringKludge *)(((NXReadWriteStringKludge *)str2)->actualString))->characters;
392: }
393: str1 = [str2 copy];
394: str3 = [str1 copy];
395: [str2 free];
396: [str1 free];
397: str2 = [str3 copy];
398: [str3 verifyChars:"BCKLMNO"];
399: [str2 verifyChars:"BCKLMNO"];
400: if (testClass == [NXReadWriteString class]) {
401: [str2 verifyInt:(int)((NXReadOnlyStringKludge *)(((NXReadWriteStringKludge *)str2)->actualString))->characters :addr];
402: }
403: str1 = [[NXReadOnlyString alloc] initFromCharacters:chars2 length:1];
404: [str2 insertString:str1 at:2];
405: [str1 free];
406: [str3 verifyChars:"BCKLMNO"];
407: [str2 verifyChars:"BCFKLMNO"];
408: [str2 free];
409: [str3 free];
410:
411: str1 = [[testClass alloc] init];
412: str2 = [[testClass alloc] init];
413: [str1 appendString:@"Foo Bar"];
414: [str1 verifyChars:"Foo Bar"];
415: [str2 verifyChars:""];
416: [str1 free];
417: str1 = [[testClass alloc] init];
418: [str2 verifyChars:""];
419: [str1 appendString:str2];
420: [str2 free];
421: [str1 verifyChars:""];
422:
423: }
424:
425: void testLargeEdit /* large edit */ (id testClass)
426: {
427: int cnt;
428: id str1, str2, str3;
429: unichar chars1[] = {'A', 'B', 'C', 'D', 'E'};
430: NXRange range = {999, 25};
431: NXRange findRange;
432:
433: TITLE ("large appendString/delete/insertString test");
434:
435: str1 = [[testClass alloc] initFromCharacters:chars1 length:5];
436: str2 = [str1 copy];
437: for (cnt = 1; cnt < 64; cnt++) {
438: [str1 appendString:str2];
439: } // Resulting length is 320
440: [str2 free];
441: str2 = [str1 copy];
442: [str1 appendString:str2]; // 640
443: [str1 appendString:str2]; // 960
444: [str1 appendString:str2]; // 1280
445: [str2 free];
446: [str1 verifyInt:[str1 length] :1280];
447:
448: str2 = [[testClass alloc] initFromString:str1 range:range];
449: [str2 verifyChars:"EABCDEABCDEABCDEABCDEABCD"];
450: [str2 insertString:str1 at:2];
451: [str2 insertString:str1 at:[str2 length]];
452: [str1 free];
453: str3 = [str2 copySubstring:(NXRange){0, 10} fromZone:[str2 zone]];
454: [str3 verifyChars:"EAABCDEABC"];
455: str1 = [str2 copy];
456: [str2 replaceCharactersInRange:range withString:str1];
457: [str2 appendString:str3];
458: [str2 appendString:@"Howdy"];
459: [str3 free];
460: [str2 verifyInt:[str2 length] :5160];
461: findRange = [str2 findString:@"EAABCDEABCH"];
462: [str2 verifyInt:NX_LOCATION(findRange) :5145];
463: [str1 free];
464: NX_LOCATION(range) = 2;
465: NX_LENGTH(range) = [str2 length] - 4;
466: [str2 deleteCharactersInRange:range];
467: [str2 verifyChars:"EAdy"];
468: [str2 free];
469: }
470:
471: void testCompare /* compare */ (id testClass)
472: {
473: id str1, str2, str3, str4, str5;
474: unichar chars1[] = {'A', 'B', 'C', 'D', 'E'};
475: unichar chars2[] = {'F', 'G', 'h', 'f', 'g'};
476: unichar chars3[] = {'F', 'g', 'H', 'f', 'G'};
477:
478: TITLE ("compare test");
479:
480: str1 = [[testClass alloc] initFromCharacters:chars1 length:5];
481: str2 = [[testClass alloc] initFromCharacters:chars1 length:4];
482: str3 = [[testClass alloc] initFromCharacters:chars2 length:4];
483: [str1 verifyInt:[str1 compare:str1] :0];
484: [str1 verifyInt:[str1 compare:str2] :1];
485: [str1 verifyInt:[str1 compare:str3] :-1];
486: [str2 verifyInt:[str2 compare:str1] :-1];
487: [str2 verifyInt:[str2 compare:str3] :-1];
488: [str3 verifyInt:[str3 compare:str1] :1];
489: [str3 verifyInt:[str3 compare:str2] :1];
490: str4 = [[NXReadWriteString alloc] initFromString:str1];
491: str5 = [str4 copy];
492: [str1 verifyInt:[str1 compare:str4] :0];
493: [str5 verifyInt:[str5 compare:str1] :0];
494: [str4 appendString:str4];
495: [str1 verifyInt:[str1 compare:str4] :-1];
496: [str5 verifyInt:[str5 compare:str1] :0];
497: [str4 free];
498: [str5 free];
499: [str1 free];
500: [str2 free];
501: str4 = [[testClass alloc] initFromCharacters:chars3 length:4];
502: [str4 verifyInt:[str4 compare:str3] :1];
503: [str3 verifyInt:[str3 compare:str4] :-1];
504: [str4 verifyInt:[str4 compare:str3 mask:NX_CASE_INSENSITIVE table:NULL] :0];
505: [str3 verifyInt:[str3 compare:str4 mask:NX_CASE_INSENSITIVE table:NULL] :0];
506: str2 = [[NXReadOnlyString alloc] initFromString:str3];
507: [str4 verifyInt:[str4 compare:str2] :1];
508: [str2 verifyInt:[str2 compare:str4] :-1];
509: [str2 free];
510: [str3 free];
511: [str4 free];
512: }
513:
514: #define wholeRange(s) ((NXRange){0, [(s) length]})
515:
516: void testFind /* find */ (id testClass)
517: {
518: id str1, str2, str3, str4;
519: unichar chars1[] = {'A', 'B', 'C', 'D', 'E', 'F', 'g', 'h', 'a', 'b', 'B', 'C'};
520: unichar chars2[] = {'F', 'G', 'h', 'f', 'g'};
521: unichar chars3[] = {'F', 'g', 'H', 'f', 'G'};
522: NXRange findRange;
523:
524: TITLE ("find test");
525:
526: str1 = [[testClass alloc] initFromCharacters:chars1 length:12]; // ABCDEFghabBC
527: str2 = [[testClass alloc] initFromCharacters:chars1 length:2]; // AB
528: str3 = [[testClass alloc] initFromCharacters:chars2 length:2]; // FG
529: str4 = [[testClass alloc] initFromCharacters:chars3 length:2]; // Fg
530:
531: findRange = [str1 findString:str2];
532: [str1 verifyInt:NX_LOCATION(findRange) :0];
533: [str1 verifyInt:NX_LENGTH(findRange) :2];
534: findRange = [str1 findString:str3];
535: [str1 verifyInt:NX_LOCATION(findRange) :NX_STRING_NOT_FOUND];
536: [str1 verifyInt:NX_LENGTH(findRange) :0];
537: findRange = [str1 findString:str4];
538: [str1 verifyInt:NX_LOCATION(findRange) :5];
539: [str1 verifyInt:NX_LENGTH(findRange) :2];
540: findRange = [str1 findString:str3 range:wholeRange(str1) mask:NX_CASE_INSENSITIVE table:NULL];
541: [str1 verifyInt:NX_LOCATION(findRange) :5];
542: [str1 verifyInt:NX_LENGTH(findRange) :2];
543: findRange = [str1 findString:str2 range:wholeRange(str1) mask:NX_CASE_INSENSITIVE|NX_BACKWARDS_SEARCH table:NULL];
544: [str1 verifyInt:NX_LOCATION(findRange) :8];
545: [str1 verifyInt:NX_LENGTH(findRange) :2];
546: findRange = [str1 findString:str2 range:wholeRange(str1) mask:NX_BACKWARDS_SEARCH table:NULL];
547: [str1 verifyInt:NX_LOCATION(findRange) :0];
548: [str1 verifyInt:NX_LENGTH(findRange) :2];
549: findRange = [str3 findString:str4 range:wholeRange(str3) mask:NX_BACKWARDS_SEARCH table:NULL];
550: [str3 verifyInt:NX_LOCATION(findRange) :NX_STRING_NOT_FOUND];
551: [str3 verifyInt:NX_LENGTH(findRange) :0];
552: findRange = [str3 findString:str4 range:wholeRange(str3) mask:NX_CASE_INSENSITIVE|NX_BACKWARDS_SEARCH table:NULL];
553: [str3 verifyInt:NX_LOCATION(findRange) :0];
554: [str3 verifyInt:NX_LENGTH(findRange) :2];
555: findRange = [str3 findString:str4 range:wholeRange(str3) mask:NX_CASE_INSENSITIVE table:NULL];
556: [str3 verifyInt:NX_LOCATION(findRange) :0];
557: [str3 verifyInt:NX_LENGTH(findRange) :2];
558: findRange = [str2 findString:str1];
559: [str2 verifyInt:NX_LOCATION(findRange) :NX_STRING_NOT_FOUND];
560: [str2 verifyInt:NX_LENGTH(findRange) :0];
561:
562: NX_LOCATION(findRange) = 1;
563: NX_LENGTH(findRange) = [str1 length] - 1;
564: findRange = [str1 findString:str2 range:findRange mask:NX_CASE_INSENSITIVE table:NULL];
565: [str3 verifyInt:NX_LOCATION(findRange) :8];
566: [str3 verifyInt:NX_LENGTH(findRange) :2];
567:
568: }
569:
570: void testStream (id testClass)
571: {
572: const char *bytes = "Hello There. Hi There.";
573: unichar chars1[] = {'A', 'B', 'C', 0, 1, 2, '0', '1', '2'};
574: NXStream *stream;
575: id str1, str2, str3, str4;
576: NXCharacterSet *numberSet;
577:
578: TITLE ("stream test");
579:
580: numberSet = [[NXCharacterSet alloc] init];
581: [numberSet addRange:'0' :'9'];
582:
583: stream = NXOpenMemory(bytes, strlen(bytes), NX_READONLY);
584: str1 = [[testClass alloc] initFromCStringStream:stream untilOneOf:nil maxLength:1];
585: str2 = [[testClass alloc] initFromCStringStream:stream untilOneOf:nil maxLength:17];
586: str3 = [[testClass alloc] initFromCStringStream:stream untilOneOf:nil maxLength:120];
587:
588: [str1 verifyChars:"H"];
589: [str2 verifyChars:"ello There. Hi Th"];
590: [str3 verifyChars:"ere."];
591: [str1 free];
592: [str3 free];
593:
594: NXClose (stream);
595:
596: stream = NXOpenMemory(NULL, 0, NX_READWRITE);
597: [str2 writeCStringToStream:stream];
598: str1 = [[testClass alloc] initFromCharacters:chars1 length:9];
599: [str1 writeCStringToStream:stream];
600:
601: NXSeek(stream, 1, NX_FROMSTART);
602: str3 = [[testClass alloc] initFromCStringStream:stream untilOneOf:nil maxLength:NX_MAX_STRING_LENGTH];
603:
604: str4 = [[NXReadWriteString alloc] init];
605: [str4 append:str2];
606: [str4 deleteCharactersInRange:(NXRange){0,1}]; // Because we seeked to 1 above...
607: [str4 append:str1];
608:
609: [str3 verifyString:str4];
610: [str3 verifyInt:[str3 length] :[str2 length] - 1 + 9];
611:
612: [str3 free];
613:
614: NXSeek(stream, 1, NX_FROMSTART);
615: str3 = [[testClass alloc] initFromCStringStream:stream untilOneOf:numberSet maxLength:NX_MAX_STRING_LENGTH];
616:
617: [str4 deleteCharactersInRange:(NXRange){[str4 length]-3, 3}];
618: [str3 verifyString:str4];
619: [str3 verifyInt:[str3 length] :[str2 length] - 1 + 6];
620: [str3 free];
621:
622: NXSeek(stream, 1, NX_FROMSTART);
623: str3 = [[testClass alloc] initFromCStringStream:stream untilOneOf:numberSet maxLength:5];
624:
625: [str4 deleteCharactersInRange:(NXRange){5, [str4 length] - 5}];
626: [str3 verifyString:str4];
627: [str3 verifyInt:[str3 length] :5];
628: [str3 free];
629:
630: [str1 free];
631: [str2 free];
632: [str4 free];
633:
634: NXCloseMemory(stream, NX_FREEBUFFER);
635:
636: str1 = hugeString(testClass);
637:
638: stream = NXOpenMemory(NULL, 0, NX_READWRITE);
639: [str1 writeCStringToStream:stream];
640: NXSeek(stream, 0, NX_FROMSTART);
641: str2 = [[testClass alloc] initFromCStringStream:stream untilOneOf:nil maxLength:NX_MAX_STRING_LENGTH];
642: [str1 verifyString:str2];
643: [str2 free];
644: NXCloseMemory(stream, NX_FREEBUFFER);
645:
646: stream = NXOpenMemory(NULL, 0, NX_READWRITE);
647: [str1 writeToStream:stream];
648: NXSeek(stream, 0, NX_FROMSTART);
649: str2 = [[testClass alloc] initFromStream:stream untilOneOf:nil maxLength:NX_MAX_STRING_LENGTH];
650: [str1 verifyString:str2];
651: [str2 free];
652: NXCloseMemory(stream, NX_FREEBUFFER);
653:
654: [str1 free];
655: }
656:
657: void testHash (id testClass)
658: {
659: id str1;
660: unichar chars1[] = {'F', 'o', 'o'};
661:
662: TITLE ("hash test");
663:
664: str1 = [[testClass alloc] initFromCharacters:chars1 length:3];
665: [str1 verifyInt:[str1 hash] :32095];
666: [str1 verifyInt:[str1 hash] :[@"Foo" hash]];
667: [str1 free];
668:
669: str1 = [[testClass alloc] initFromString:@"Hello World"];
670: [str1 verifyInt:[str1 hash] :850486630];
671: [str1 free];
672: }
673:
674: void testFormat (id testClass)
675: {
676: id str1, str2, str3;
677: int cnt;
678: unichar chars1[] = {'F', 'o', 'o'};
679:
680: TITLE ("formatted create test");
681:
682: str1 = [[NXReadOnlyString alloc] initFromCString:"===%2.1f %d %s %@==="];
683: str2 = [[NXReadOnlyString alloc] initFromCharacters:chars1 length:3];
684: str3 = [[testClass alloc] initFromFormat:str1, 3.14, -42, "Hello World", str2];
685:
686: [str3 verifyChars:"===3.1 -42 Hello World Foo==="];
687:
688: [str1 free];
689: [str2 free];
690: [str3 free];
691:
692: str1 = [[NXReadOnlyString alloc] initFromCString:"Hello"];
693: str3 = [[NXReadWriteString alloc] initFromString:str1];
694: for (cnt = 0; cnt < 12; cnt++) {
695: str2 = [[testClass alloc] initFromFormat:@"%@*%@", str1, str1];
696: [str3 appendString:@"*"]; // Test string; we assume append works.
697: [str3 appendString:str1];
698: [str2 verifyString:str3];
699: [str1 free];
700: str1 = str2;
701: }
702: [str3 free];
703: str3 = [[NXReadOnlyString alloc] initFromString:str1 range:(NXRange){[str1 length] - 6, 6}];
704: [str3 verifyChars:"*Hello"];
705: [str1 free];
706: [str3 free];
707: }
708:
709: void testCStrings (id testClass)
710: {
711: id str1, str2;
712: char *cString;
713: NXAtom uString1, uString2;
714: #define CSTRBUFLEN 10
715: #define CSTRBIGBUFLEN 1000
716: char cStringBuffer[CSTRBIGBUFLEN+1];
717: int cnt;
718: NXRange range;
719:
720: TITLE ("CString test");
721:
722: str1 = [[NXReadOnlyString alloc] initFromCString:"Hello World"];
723: str2 = [str1 mutableCopy];
724: cString = [str1 cStringCopy];
725: [str1 verifyChars:cString];
726: free (cString);
727: uString1 = [str1 uniqueCStringCopy];
728: [str1 verifyChars:uString1];
729: uString2 = [str1 uniqueCStringCopy];
730: [str1 verifyInt:(int)uString1 :(int)uString2];
731: uString2 = [str2 uniqueCStringCopy];
732: [str1 verifyInt:(int)uString1 :(int)uString2];
733: [str2 appendString:@""];
734: uString2 = [str2 uniqueCStringCopy];
735: [str1 verifyInt:(int)uString1 :(int)uString2];
736: [str2 appendString:@" "];
737: uString1 = [str2 uniqueCStringCopy];
738: uString2 = [@"Hello World " uniqueCStringCopy];
739: [str2 verifyInt:(int)uString1 :(int)uString2];
740: [str1 free];
741: [str2 free];
742:
743: str1 = [[testClass alloc] initFromCString:"Bonjour Everyone"];
744: [str1 getCString:cStringBuffer maxLength:3];
745: [str1 verifyCStrings:cStringBuffer :"Bon"];
746: [str1 getCString:cStringBuffer maxLength:0];
747: [str1 verifyCStrings:cStringBuffer :""];
748: NX_LOCATION(range) = 8; NX_LENGTH(range) = 5;
749: [str1 getCString:cStringBuffer maxLength:NX_MAX_STRING_LENGTH range:range remainingRange:NULL];
750: [str1 verifyCStrings:cStringBuffer :"Every"];
751: [str1 getCString:cStringBuffer maxLength:2 range:range remainingRange:NULL];
752: [str1 verifyCStrings:cStringBuffer :"Ev"];
753: [str1 getCString:cStringBuffer maxLength:CSTRBUFLEN range:range remainingRange:NULL];
754: [str1 verifyCStrings:cStringBuffer :"Every"];
755: [str1 getCString:cStringBuffer maxLength:CSTRBUFLEN];
756: [str1 verifyCStrings:cStringBuffer :"Bonjour Ev"];
757: NX_LOCATION(range) = 0;
758: NX_LENGTH(range) = 11;
759: [str1 getCString:cStringBuffer maxLength:0 range:range remainingRange:&range];
760: [str1 verifyCStrings:cStringBuffer :""];
761: [str1 verifyInt:NX_LOCATION(range) :0];
762: [str1 verifyInt:NX_LENGTH(range) :11];
763: [str1 getCString:cStringBuffer maxLength:5 range:range remainingRange:&range];
764: [str1 verifyCStrings:cStringBuffer :"Bonjo"];
765: [str1 verifyInt:NX_LOCATION(range) :5];
766: [str1 verifyInt:NX_LENGTH(range) :6];
767: [str1 getCString:cStringBuffer maxLength:10 range:range remainingRange:&range];
768: [str1 verifyCStrings:cStringBuffer :"ur Eve"];
769: [str1 verifyInt:NX_LOCATION(range) :11];
770: [str1 verifyInt:NX_LENGTH(range) :0];
771: [str1 free];
772:
773: str1 = hugeString(testClass);
774: [str1 getCString:cStringBuffer maxLength:CSTRBIGBUFLEN range:(NXRange){0,[str1 length]} remainingRange:&range];
775: cnt = 26 * ((int)(CSTRBIGBUFLEN / 26) - 1);
776: cStringBuffer[cnt + 26] = '\0';
777: [str1 verifyCStrings:&cStringBuffer[cnt] :"abcdefghijklmnopqrstuvwxyz"];
778: [str1 verifyInt:NX_LOCATION(range) :CSTRBIGBUFLEN];
779: [str1 verifyInt:NX_LENGTH(range) :[str1 length] - CSTRBIGBUFLEN];
780: [str1 free];
781: }
782:
783: void testFindAndSets (id testClass)
784: {
785: id str1;
786: unichar chars1[] = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '1', 'h', '3'};
787: unichar chars2[] = {' ', '\t'};
788: NXCharacterSet *numberSet, *alphaSet, *spaceSet, *notAlphaSet, *numAndAlphaSet;
789:
790: TITLE ("find and NXCharacterSet test");
791:
792: numberSet = [[NXCharacterSet alloc] init];
793: [numberSet addRange:'0' :'9'];
794:
795: alphaSet = [[NXCharacterSet alloc] init];
796: [alphaSet addRange:'a' :'z'];
797: [alphaSet addRange:'A' :'Z'];
798:
799: notAlphaSet = [[NXCharacterSet alloc] init];
800: [notAlphaSet addRange:'a' :'z'];
801: [notAlphaSet addRange:'A' :'Z'];
802: [notAlphaSet invert];
803:
804: spaceSet = [[NXCharacterSet alloc] init];
805: [spaceSet addCharacters:chars2 length:2];
806: [spaceSet addCharacters:chars1 length:14];
807: [spaceSet removeCharacters:chars1 length:14];
808: [spaceSet addCharacters:chars2 length:2];
809:
810: numAndAlphaSet = [[NXCharacterSet alloc] init];
811: [numAndAlphaSet unionWith:alphaSet];
812: [numAndAlphaSet unionWith:numberSet];
813:
814: str1 = [[testClass alloc] initFromCharacters:chars1 length:14];
815: [str1 verifyInt:[str1 findCharacter:'l'] :2];
816: [str1 verifyInt:[str1 findCharacter:'l' range:wholeRange(str1) mask:NX_BACKWARDS_SEARCH table:NULL] :9];
817: [str1 verifyInt:[str1 findCharacter:'h' range:wholeRange(str1) mask:NX_CASE_INSENSITIVE table:NULL] :0];
818: [str1 verifyInt:[str1 findCharacter:'h' range:wholeRange(str1) mask:NX_BACKWARDS_SEARCH table:NULL] :12];
819:
820: [str1 verifyInt:[str1 findOneOf:alphaSet] :0];
821: [str1 verifyInt:[str1 findOneOf:notAlphaSet] :5];
822: [str1 verifyInt:[str1 findOneOf:spaceSet] :5];
823: [str1 verifyInt:[str1 findOneOf:numberSet] :11];
824: [str1 verifyInt:[str1 findOneOf:numberSet range:wholeRange(str1) mask:NX_BACKWARDS_SEARCH table:NULL] :13];
825: }
826:
827: #ifdef TESTCONSTANTSTRING
828: void testConstant /* basic constant string functionality */ ()
829: {
830: id str1, str2, str3;
831: unichar *charPtr;
832: NXRange range = {1, 2};
833: NXRange tmpRange = {0, 0};
834:
835: TITLE1 ("NXConstantString test");
836:
837: str1 = [[NXReadOnlyString alloc] initFromString:@"ABCDE"];
838: str2 = [[NXReadOnlyString alloc] initFromString:str1];
839: str3 = [[NXReadOnlyString alloc] initFromString:str2 range:range];
840: [str3 verifyChars:"BC"];
841: [str3 free];
842: str3 = [str2 copy];
843: [str3 verifyChars:"ABCDE"];
844: [str2 free];
845: [str3 verifyChars:"ABCDE"];
846: [str3 free];
847:
848: str3 = [[NXReadOnlyString alloc] initFromString:@"FGHIJ"];
849: CHARALLOC(NXDefaultMallocZone(), charPtr, NX_LENGTH(range));
850: [str3 getCharacters:charPtr range:range];
851: str2 = [[NXReadOnlyString alloc] initFromCharacters:charPtr length:NX_LENGTH(range)];
852: [str3 verifyChars:"FGHIJ"];
853: [str2 verifyChars:"GH"];
854: [str2 free];
855: NX_FREE (charPtr);
856:
857: NX_LOCATION(tmpRange) = 1;
858: NX_LENGTH(tmpRange) = [str3 length] - 1;
859: CHARALLOC(NXDefaultMallocZone(), charPtr, NX_LENGTH(tmpRange));
860: [str3 getCharacters:charPtr range:tmpRange];
861: str2 = [[NXReadOnlyString alloc] initFromCharacters:charPtr length:NX_LENGTH(tmpRange)];
862: [str2 verifyChars:"GHIJ"];
863: [str2 free];
864: [str3 free];
865: [str1 free];
866: NX_FREE (charPtr);
867:
868: str3 = [[NXReadOnlyString alloc] initFromString:@"KLM" @"NO"];
869: str2 = [str3 copy];
870: NX_LOCATION(tmpRange) = 0;
871: NX_LENGTH(tmpRange) = [str2 length];
872: CHARALLOC(NXDefaultMallocZone(), charPtr, NX_LENGTH(tmpRange));
873: [str2 getCharacters:charPtr range:tmpRange];
874: str1 = [[NXReadOnlyString alloc] initFromCharactersNoCopy:charPtr length:NX_LENGTH(tmpRange)];
875: [str3 free];
876: [str2 verifyChars:"KLMNO"];
877: [str2 free];
878: [str1 verifyChars:"KLMNO"];
879: [str1 free];
880:
881: str1 = [[NXReadWriteString alloc] init];
882: str2 = [str1 copy];
883: [str1 appendString:@"Foo"];
884: [str1 verifyInt:[str1 isEqual:@""] :NO];
885: [str2 verifyInt:[str2 isEqual:@""] :YES];
886: [str1 free];
887: [str2 verifyInt:[str2 isEqual:@""] :YES];
888: [str2 free];
889: }
890:
891:
892: #endif
893:
894: void main (int argc, char **argv)
895: {
896: numErrors = 0;
897: verbose = (argc > 1) && (strcmp(argv[1], "-v") == 0);
898:
899: #ifdef TESTTESTEDSTUFF
900: testBasic ([NXReadOnlyString class]);
901: testBasic ([NXReadWriteString class]);
902: testBasic ([NXUniquedString class]);
903: testBasic ([NXSimpleReadOnlyString class]);
904:
905: testCopy ([NXReadOnlyString class]);
906: testCopy ([NXReadWriteString class]);
907: testCopy ([NXUniquedString class]);
908: testCopy ([NXSimpleReadOnlyString class]);
909:
910: testRefCountedAndUniqued ();
911:
912: testEdit ([NXReadWriteString class]);
913: testLargeEdit ([NXReadWriteString class]);
914:
915: testCompare ([NXReadOnlyString class]);
916: testCompare ([NXReadWriteString class]);
917: testCompare ([NXUniquedString class]);
918: testCompare ([NXSimpleReadOnlyString class]);
919:
920: testFind ([NXReadOnlyString class]);
921: testFind ([NXReadWriteString class]);
922: testFind ([NXUniquedString class]);
923: testFind ([NXSimpleReadOnlyString class]);
924:
925: testStream ([NXReadOnlyString class]);
926: testStream ([NXReadWriteString class]);
927: testStream ([NXUniquedString class]);
928: testStream ([NXSimpleReadOnlyString class]);
929:
930: testFormat ([NXReadOnlyString class]);
931: testFormat ([NXReadWriteString class]);
932: testFormat ([NXUniquedString class]);
933: testFormat ([NXSimpleReadOnlyString class]);
934:
935: testFindAndSets ([NXReadOnlyString class]);
936: testFindAndSets ([NXReadWriteString class]);
937: testFindAndSets ([NXUniquedString class]);
938: testFindAndSets ([NXSimpleReadOnlyString class]);
939:
940: testCStrings ([NXReadOnlyString class]);
941: testCStrings ([NXReadWriteString class]);
942: testCStrings ([NXUniquedString class]);
943: testCStrings ([NXSimpleReadOnlyString class]);
944:
945: testHash ([NXReadOnlyString class]);
946: testHash ([NXReadWriteString class]);
947: testHash ([NXUniquedString class]);
948: testHash ([NXSimpleReadOnlyString class]);
949: #endif
950:
951: #ifdef TESTGAPSTRING
952: testBasic ([NXGapString class]);
953: testCopy ([NXGapString class]);
954: testEdit ([NXGapString class]);
955: testCompare ([NXGapString class]);
956: testFind ([NXGapString class]);
957: testLargeEdit ([NXGapString class]);
958: testStream ([NXGapString class]);
959: testFormat ([NXGapString class]);
960: testFindAndSets ([NXGapString class]);
961: testCStrings ([NXGapString class]);
962: testHash ([NXGapString class]);
963: #endif
964:
965: #ifdef TESTBIGSTRING
966: testBasic ([NXBigString class]);
967: testCopy ([NXBigString class]);
968: testEdit ([NXBigString class]);
969: testCompare ([NXBigString class]);
970: testFind ([NXBigString class]);
971: testLargeEdit ([NXBigString class]);
972: testStream ([NXBigString class]);
973: testFormat ([NXBigString class]);
974: testFindAndSets ([NXBigString class]);
975: testCStrings ([NXBigString class]);
976: testHash ([NXBigString class]);
977: #endif
978:
979: #ifdef TESTCONSTANTSTRING
980: testConstant();
981: #endif
982:
983: fprintf (stderr, "\n%s%d error%s.\n", numErrors ? "*** " : "", numErrors, numErrors == 1 ? "" : "s");
984: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.