?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bug 1842773 - Part 36: Rename ArrayBufferObject::MaxByteLength to ByteLengthLimit...
[gecko.git] / nsprpub / lib / tests / string.c
blob7765d12dc1820b44cfe60bee4c01cae9d65e31ba
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 #include "plstr.h"
7 #include "nspr.h"
8
9 #include <stdio.h>
10
11 /* PL_strlen */
12 PRBool test_001(void)
13 {
14 static struct
15 {
16 const char *str;
17 PRUint32 len;
18 } array[] =
19 {
20 { (const char *)0, 0 },
21 { "", 0 },
22 { "a", 1 },
23 { "abcdefg", 7 },
24 { "abcdefg\0hijk", 7 }
25 };
26
27 int i;
28
29 printf("Test 001 (PL_strlen) ..."); fflush(stdout);
30
31 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
32 {
33 if( PL_strlen(array[i].str) != array[i].len )
34 {
35 printf("FAIL (%d: %s->%d, %d)\n", i,
36 array[i].str ? array[i].str : "(null)",
37 PL_strlen(array[i].str), array[i].len);
38 return PR_FALSE;
39 }
40 }
41
42 printf("PASS\n");
43 return PR_TRUE;
44 }
45
46 /* PL_strnlen */
47 PRBool test_002(void)
48 {
49 static struct
50 {
51 const char *str;
52 PRUint32 max;
53 PRUint32 len;
54 } array[] =
55 {
56 { (const char *)0, 0, 0 },
57 { (const char *)0, 12, 0 },
58 { "", 0, 0 },
59 { "", 12, 0 },
60 { "a", 0, 0 },
61 { "a", 1, 1 },
62 { "a", 12, 1 },
63 { "abcdefg", 0, 0 },
64 { "abcdefg", 1, 1 },
65 { "abcdefg", 7, 7 },
66 { "abcdefg", 12, 7 },
67 { "abcdefg\0hijk", 0, 0 },
68 { "abcdefg\0hijk", 1, 1 },
69 { "abcdefg\0hijk", 7, 7 },
70 { "abcdefg\0hijk", 12, 7 },
71 };
72
73 int i;
74
75 printf("Test 002 (PL_strnlen) ..."); fflush(stdout);
76
77 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
78 {
79 if( PL_strnlen(array[i].str, array[i].max) != array[i].len )
80 {
81 printf("FAIL (%d: %s,%d->%d, %d)\n", i,
82 array[i].str ? array[i].str : "(null)", array[i].max,
83 PL_strnlen(array[i].str, array[i].max), array[i].len);
84 return PR_FALSE;
85 }
86 }
87
88 printf("PASS\n");
89 return PR_TRUE;
90 }
91
92 /* PL_strcpy */
93 PRBool test_003(void)
94 {
95 static char buffer[ 1024 ];
96
97 static struct
98 {
99 const char *str;
100 char *dest;
101 char *rv;
102 PRBool comp;
103 } array[] =
104 {
105 { (const char *)0, (char *)0, (char *)0, PR_FALSE },
106 { (const char *)0, buffer, (char *)0, PR_FALSE },
107 { "", (char *)0, (char *)0, PR_FALSE },
108 { "", buffer, buffer, PR_TRUE },
109 { "a", (char *)0, (char *)0, PR_FALSE },
110 { "a", buffer, buffer, PR_TRUE },
111 { "abcdefg", (char *)0, (char *)0, PR_FALSE },
112 { "abcdefg", buffer, buffer, PR_TRUE },
113 { "wxyz\0abcdefg", (char *)0, (char *)0, PR_FALSE },
114 { "wxyz\0abcdefg", buffer, buffer, PR_TRUE }
115 };
116
117 int i;
118
119 printf("Test 003 (PL_strcpy) ..."); fflush(stdout);
120
121 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
122 {
123 char *rv;
124 const char *a = array[i].str;
125 const char *b = (const char *)array[i].dest;
126
127 rv = PL_strcpy(array[i].dest, array[i].str);
128 if( array[i].rv != rv )
129 {
130 printf("FAIL %d: (0x%x, %s)->0x%x\n", i, array[i].dest,
131 array[i].str ? array[i].str : "(null)", rv);
132 return PR_FALSE;
133 }
134
135 if( array[i].comp )
136 {
137 while( 1 )
138 {
139 if( *a != *b )
140 {
141 printf("FAIL %d: %s->%.32s\n", i,
142 array[i].str ? array[i].str : "(null)",
143 array[i].dest ? array[i].dest : "(null)");
144 return PR_FALSE;
145 }
146
147 if( (char)0 == *a ) {
148 break;
149 }
150
151 a++;
152 b++;
153 }
154 }
155 }
156
157 printf("PASS\n");
158 return PR_TRUE;
159 }
160
161 /* PL_strncpy */
162 PRBool test_004(void)
163 {
164 static char buffer[ 1024 ];
165
166 static struct
167 {
168 const char *str;
169 PRUint32 len;
170 char *dest;
171 char *rv;
172 PRBool comp;
173 const char *result;
174 PRBool nulled;
175 } array[] =
176 {
177 { (const char *)0, 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
178 { (const char *)0, 0, buffer, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
179 { (const char *)0, 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
180 { (const char *)0, 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
181 { (const char *)0, 1, buffer, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
182 { (const char *)0, 7, buffer, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
183 { "", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
184 { "", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
185 { "", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
186 { "", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
187 { "", 1, buffer, buffer, PR_TRUE, "", PR_TRUE },
188 { "", 7, buffer, buffer, PR_TRUE, "", PR_TRUE },
189 { "a", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
190 { "a", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
191 { "a", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
192 { "a", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
193 { "b", 1, buffer, buffer, PR_TRUE, "b", PR_FALSE },
194 { "c", 7, buffer, buffer, PR_TRUE, "c", PR_TRUE },
195 { "de", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
196 { "de", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
197 { "de", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
198 { "de", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
199 { "fg", 1, buffer, buffer, PR_TRUE, "f", PR_FALSE },
200 { "hi", 7, buffer, buffer, PR_TRUE, "hi", PR_TRUE },
201 { "jklmnopq", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
202 { "jklmnopq", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
203 { "jklmnopq", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
204 { "jklmnopq", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
205 { "rstuvwxy", 1, buffer, buffer, PR_TRUE, "r", PR_FALSE },
206 { "zABCDEFG", 7, buffer, buffer, PR_TRUE, "zABCDEF", PR_FALSE },
207 { "a\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
208 { "a\0XXX", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
209 { "a\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
210 { "a\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
211 { "b\0XXX", 1, buffer, buffer, PR_TRUE, "b", PR_FALSE },
212 { "c\0XXX", 7, buffer, buffer, PR_TRUE, "c", PR_TRUE },
213 { "de\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
214 { "de\0XXX", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
215 { "de\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
216 { "de\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
217 { "fg\0XXX", 1, buffer, buffer, PR_TRUE, "f", PR_FALSE },
218 { "hi\0XXX", 7, buffer, buffer, PR_TRUE, "hi", PR_TRUE },
219 { "jklmnopq\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
220 { "jklmnopq\0XXX", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
221 { "jklmnopq\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
222 { "jklmnopq\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
223 { "rstuvwxy\0XXX", 1, buffer, buffer, PR_TRUE, "r", PR_FALSE },
224 { "zABCDEFG\0XXX", 7, buffer, buffer, PR_TRUE, "zABCDEF", PR_FALSE },
225 };
226
227 int i;
228
229 printf("Test 004 (PL_strncpy) ..."); fflush(stdout);
230
231 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
232 {
233 char *rv;
234 int j;
235
236 for( j = 0; j < sizeof(buffer); j++ ) {
237 buffer[j] = '-';
238 }
239
240 rv = PL_strncpy(array[i].dest, array[i].str, array[i].len);
241 if( array[i].rv != rv )
242 {
243 printf("FAIL %d: (0x%x, %s, %lu)->0x%x\n", i, array[i].dest,
244 array[i].str ? array[i].str : "(null)", array[i].len, rv);
245 return PR_FALSE;
246 }
247
248 if( array[i].comp )
249 {
250 const char *a = array[i].result;
251 const char *b = array[i].dest;
252
253 while( *a )
254 {
255 if( *a != *b )
256 {
257 printf("FAIL %d: %s != %.32s\n", i,
258 array[i].result, array[i].dest);
259 return PR_FALSE;
260 }
261
262 a++;
263 b++;
264 }
265
266 if( array[i].nulled )
267 {
268 if( *b != '\0' )
269 {
270 printf("FAIL %d: not terminated\n", i);
271 return PR_FALSE;
272 }
273 }
274 else
275 {
276 if( *b != '-' )
277 {
278 printf("FAIL %d: overstepped\n", i);
279 return PR_FALSE;
280 }
281 }
282 }
283 }
284
285 printf("PASS\n");
286 return PR_TRUE;
287 }
288
289 /* PL_strncpyz */
290 PRBool test_005(void)
291 {
292 static char buffer[ 1024 ];
293
294 static struct
295 {
296 const char *str;
297 PRUint32 len;
298 char *dest;
299 char *rv;
300 PRBool comp;
301 const char *result;
302 } array[] =
303 {
304 { (const char *)0, 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
305 { (const char *)0, 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
306 { (const char *)0, 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
307 { (const char *)0, 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
308 { (const char *)0, 1, buffer, (char *)0, PR_FALSE, (const char *)0 },
309 { (const char *)0, 7, buffer, (char *)0, PR_FALSE, (const char *)0 },
310 { "", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
311 { "", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
312 { "", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
313 { "", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
314 { "", 1, buffer, buffer, PR_TRUE, "" },
315 { "", 7, buffer, buffer, PR_TRUE, "" },
316 { "a", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
317 { "a", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
318 { "a", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
319 { "a", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
320 { "b", 1, buffer, buffer, PR_TRUE, "" },
321 { "c", 7, buffer, buffer, PR_TRUE, "c" },
322 { "de", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
323 { "de", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
324 { "de", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
325 { "de", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
326 { "fg", 1, buffer, buffer, PR_TRUE, "" },
327 { "hi", 7, buffer, buffer, PR_TRUE, "hi" },
328 { "jklmnopq", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
329 { "jklmnopq", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
330 { "jklmnopq", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
331 { "jklmnopq", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
332 { "rstuvwxy", 1, buffer, buffer, PR_TRUE, "" },
333 { "zABCDEFG", 7, buffer, buffer, PR_TRUE, "zABCDE" },
334 { "a\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
335 { "a\0XXX", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
336 { "a\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
337 { "a\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
338 { "b\0XXX", 1, buffer, buffer, PR_TRUE, "" },
339 { "c\0XXX", 7, buffer, buffer, PR_TRUE, "c" },
340 { "de\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
341 { "de\0XXX", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
342 { "de\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
343 { "de\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
344 { "fg\0XXX", 1, buffer, buffer, PR_TRUE, "" },
345 { "hi\0XXX", 7, buffer, buffer, PR_TRUE, "hi" },
346 { "jklmnopq\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
347 { "jklmnopq\0XXX", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
348 { "jklmnopq\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
349 { "jklmnopq\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
350 { "rstuvwxy\0XXX", 1, buffer, buffer, PR_TRUE, "" },
351 { "zABCDEFG\0XXX", 7, buffer, buffer, PR_TRUE, "zABCDE" },
352 };
353
354 int i;
355
356 printf("Test 005 (PL_strncpyz) ..."); fflush(stdout);
357
358 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
359 {
360 char *rv;
361 int j;
362
363 for( j = 0; j < sizeof(buffer); j++ ) {
364 buffer[j] = '-';
365 }
366
367 rv = PL_strncpyz(array[i].dest, array[i].str, array[i].len);
368 if( array[i].rv != rv )
369 {
370 printf("FAIL %d: (0x%x, %s, %lu)->0x%x\n", i, array[i].dest,
371 array[i].str ? array[i].str : "(null)", array[i].len, rv);
372 return PR_FALSE;
373 }
374
375 if( array[i].comp )
376 {
377 const char *a = array[i].result;
378 const char *b = array[i].dest;
379
380 while( 1 )
381 {
382 if( *a != *b )
383 {
384 printf("FAIL %d: %s != %.32s\n", i,
385 array[i].result, array[i].dest);
386 return PR_FALSE;
387 }
388
389 if( (char)0 == *a ) {
390 break;
391 }
392
393 a++;
394 b++;
395 }
396 }
397 }
398
399 printf("PASS\n");
400 return PR_TRUE;
401 }
402
403 /* PL_strdup */
404 PRBool test_006(void)
405 {
406 static const char *array[] =
407 {
408 (const char *)0,
409 "",
410 "a",
411 "abcdefg"
412 };
413
414 int i;
415
416 printf("Test 006 (PL_strdup) ..."); fflush(stdout);
417
418 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
419 {
420 char *rv = PL_strdup(array[i]);
421
422 if( (char *)0 == rv )
423 {
424 printf("FAIL %d: 0x%x -> 0\n", i, array[i]);
425 return PR_FALSE;
426 }
427
428 if( (const char *)0 == array[i] )
429 {
430 if( (char)0 != *rv )
431 {
432 printf("FAIL %d: (const char *)0 -> %.32s\n", i, rv);
433 return PR_FALSE;
434 }
435 }
436 else
437 {
438 const char *a = array[i];
439 const char *b = (const char *)rv;
440
441 while( 1 )
442 {
443 if( *a != *b )
444 {
445 printf("FAIL %d: %s != %.32s\n", i, array[i], rv);
446 return PR_FALSE;
447 }
448
449 if( (char)0 == *a ) {
450 break;
451 }
452
453 a++;
454 b++;
455 }
456
457 }
458 PL_strfree(rv);
459 }
460
461 printf("PASS\n");
462 return PR_TRUE;
463 }
464
465 /* PL_strndup */
466 PRBool test_007(void)
467 {
468 static struct
469 {
470 const char *str;
471 PRUint32 len;
472 const char *result;
473 } array[] =
474 {
475 { (const char *)0, 0, "" },
476 { (const char *)0, 1, "" },
477 { (const char *)0, 7, "" },
478 { "", 0, "" },
479 { "", 1, "" },
480 { "", 7, "" },
481 { "a", 0, "" },
482 { "a", 1, "a" },
483 { "a", 7, "a" },
484 { "ab", 0, "" },
485 { "ab", 1, "a" },
486 { "ab", 7, "ab" },
487 { "abcdefg", 0, "" },
488 { "abcdefg", 1, "a" },
489 { "abcdefg", 7, "abcdefg" },
490 { "abcdefghijk", 0, "" },
491 { "abcdefghijk", 1, "a" },
492 { "abcdefghijk", 7, "abcdefg" },
493 { "abcdef\0ghijk", 0, "" },
494 { "abcdef\0ghijk", 1, "a" },
495 { "abcdef\0ghijk", 7, "abcdef" }
496 };
497
498 int i;
499
500 printf("Test 007 (PL_strndup) ..."); fflush(stdout);
501
502 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
503 {
504 char *rv = PL_strndup(array[i].str, array[i].len);
505 const char *a;
506 const char *b;
507
508 if( (char *)0 == rv )
509 {
510 printf("FAIL %d: %s,%lu -> 0\n", i,
511 array[i].str ? array[i].str : "(null)", array[i].len);
512 return PR_FALSE;
513 }
514
515 a = array[i].result;
516 b = (const char *)rv;
517
518 while( 1 )
519 {
520 if( *a != *b )
521 {
522 printf("FAIL %d: %s != %.32s\n", i, array[i].result, rv);
523 return PR_FALSE;
524 }
525
526 if( (char)0 == *a ) {
527 break;
528 }
529
530 a++;
531 b++;
532 }
533
534 free(rv);
535 }
536
537 printf("PASS\n");
538 return PR_TRUE;
539 }
540
541 /* PL_strcat */
542 PRBool test_008(void)
543 {
544 static struct
545 {
546 const char *first;
547 const char *second;
548 const char *result;
549 } array[] =
550 {
551 { (const char *)0, (const char *)0, (const char *)0 },
552 { (const char *)0, "xyz", (const char *)0 },
553 { "", (const char *)0, "" },
554 { "", "", "" },
555 { "ab", "", "ab" },
556 { "cd", "ef", "cdef" },
557 { "gh\0X", "", "gh" },
558 { "ij\0X", "kl", "ijkl" },
559 { "mn\0X", "op\0X", "mnop" },
560 { "qr", "st\0X", "qrst" },
561 { "uv\0X", "wx\0X", "uvwx" }
562 };
563
564 int i;
565
566 printf("Test 008 (PL_strcat) ..."); fflush(stdout);
567
568 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
569 {
570 char buffer[ 1024 ];
571 int j;
572 char *rv;
573
574 for( j = 0; j < sizeof(buffer); j++ ) {
575 buffer[j] = '-';
576 }
577
578 if( (const char *)0 != array[i].first ) {
579 (void)PL_strcpy(buffer, array[i].first);
580 }
581
582 rv = PL_strcat(((const char *)0 == array[i].first) ? (char *)0 : buffer,
583 array[i].second);
584
585 if( (const char *)0 == array[i].result )
586 {
587 if( (char *)0 != rv )
588 {
589 printf("FAIL %d: %s+%s -> %.32s, not zero\n", i,
590 array[i].first ? array[i].first : "(null)",
591 array[i].second ? array[i].second : "(null)",
592 rv);
593 return PR_FALSE;
594 }
595 }
596 else
597 {
598 if( (char *)0 == rv )
599 {
600 printf("FAIL %d: %s+%s -> null, not %s\n", i,
601 array[i].first ? array[i].first : "(null)",
602 array[i].second ? array[i].second : "(null)",
603 array[i].result);
604 return PR_FALSE;
605 }
606 else
607 {
608 const char *a = array[i].result;
609 const char *b = (const char *)rv;
610
611 while( 1 )
612 {
613 if( *a != *b )
614 {
615 printf("FAIL %d: %s+%s -> %.32s, not %s\n", i,
616 array[i].first ? array[i].first : "(null)",
617 array[i].second ? array[i].second : "(null)",
618 rv, array[i].result);
619 return PR_FALSE;
620 }
621
622 if( (char)0 == *a ) {
623 break;
624 }
625
626 a++;
627 b++;
628 }
629 }
630 }
631 }
632
633 printf("PASS\n");
634 return PR_TRUE;
635 }
636
637 /* PL_strncat */
638 PRBool test_009(void)
639 {
640 static struct
641 {
642 const char *first;
643 const char *second;
644 PRUint32 length;
645 PRBool nulled;
646 const char *result;
647 } array[] =
648 {
649 { (const char *)0, (const char *)0, 0, PR_FALSE, (const char *)0 },
650 { (const char *)0, (const char *)0, 1, PR_FALSE, (const char *)0 },
651 { (const char *)0, (const char *)0, 7, PR_FALSE, (const char *)0 },
652 { (const char *)0, "", 0, PR_FALSE, (const char *)0 },
653 { (const char *)0, "", 1, PR_FALSE, (const char *)0 },
654 { (const char *)0, "", 7, PR_FALSE, (const char *)0 },
655 { (const char *)0, "stuff", 0, PR_FALSE, (const char *)0 },
656 { (const char *)0, "stuff", 1, PR_FALSE, (const char *)0 },
657 { (const char *)0, "stuff", 7, PR_FALSE, (const char *)0 },
658 { "", (const char *)0, 0, PR_TRUE, "" },
659 { "", (const char *)0, 1, PR_TRUE, "" },
660 { "", (const char *)0, 7, PR_TRUE, "" },
661 { "", "", 0, PR_TRUE, "" },
662 { "", "", 1, PR_TRUE, "" },
663 { "", "", 7, PR_TRUE, "" },
664 { "", "abcdefgh", 0, PR_TRUE, "" },
665 { "", "abcdefgh", 1, PR_FALSE, "a" },
666 { "", "abcdefgh", 7, PR_FALSE, "abcdefg" },
667 { "xyz", (const char *)0, 0, PR_TRUE, "xyz" },
668 { "xyz", (const char *)0, 1, PR_TRUE, "xyz" },
669 { "xyz", (const char *)0, 7, PR_TRUE, "xyz" },
670 { "xyz", "", 0, PR_TRUE, "xyz" },
671 { "xyz", "", 1, PR_TRUE, "xyz" },
672 { "xyz", "", 7, PR_TRUE, "xyz" },
673 { "xyz", "abcdefgh", 0, PR_TRUE, "xyz" },
674 { "xyz", "abcdefgh", 1, PR_FALSE, "xyza" },
675 { "xyz", "abcdefgh", 7, PR_FALSE, "xyzabcdefg" }
676 };
677
678 int i;
679
680 printf("Test 009 (PL_strncat) ..."); fflush(stdout);
681
682 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
683 {
684 char buffer[ 1024 ];
685 int j;
686 char *rv;
687
688 for( j = 0; j < sizeof(buffer); j++ ) {
689 buffer[j] = '-';
690 }
691
692 if( (const char *)0 != array[i].first ) {
693 (void)PL_strcpy(buffer, array[i].first);
694 }
695
696 rv = PL_strncat(((const char *)0 == array[i].first) ? (char *)0 : buffer,
697 array[i].second, array[i].length);
698
699 if( (const char *)0 == array[i].result )
700 {
701 if( (char *)0 != rv )
702 {
703 printf("FAIL %d: %s+%s/%lu -> %.32s, not zero\n", i,
704 array[i].first ? array[i].first : "(null)",
705 array[i].second ? array[i].second : "(null)",
706 array[i].length, rv);
707 return PR_FALSE;
708 }
709 }
710 else
711 {
712 if( (char *)0 == rv )
713 {
714 printf("FAIL %d: %s+%s/%lu -> null, not %s\n", i,
715 array[i].first ? array[i].first : "(null)",
716 array[i].second ? array[i].second : "(null)",
717 array[i].length, array[i].result);
718 return PR_FALSE;
719 }
720 else
721 {
722 const char *a = array[i].result;
723 const char *b = (const char *)rv;
724
725 while( *a )
726 {
727 if( *a != *b )
728 {
729 printf("FAIL %d: %s+%s/%lu -> %.32s, not %s\n", i,
730 array[i].first ? array[i].first : "(null)",
731 array[i].second ? array[i].second : "(null)",
732 array[i].length, rv, array[i].result);
733 return PR_FALSE;
734 }
735
736 a++;
737 b++;
738 }
739
740 if( array[i].nulled )
741 {
742 if( (char)0 != *b )
743 {
744 printf("FAIL %d: %s+%s/%lu -> not nulled\n", i,
745 array[i].first ? array[i].first : "(null)",
746 array[i].second ? array[i].second : "(null)",
747 array[i].length);
748 return PR_FALSE;
749 }
750 }
751 else
752 {
753 if( (char)0 == *b )
754 {
755 printf("FAIL %d: %s+%s/%lu -> overrun\n", i,
756 array[i].first ? array[i].first : "(null)",
757 array[i].second ? array[i].second : "(null)",
758 array[i].length);
759 return PR_FALSE;
760 }
761 }
762 }
763 }
764 }
765
766 printf("PASS\n");
767 return PR_TRUE;
768 }
769
770 /* PL_strcatn */
771 PRBool test_010(void)
772 {
773 static struct
774 {
775 const char *first;
776 const char *second;
777 PRUint32 length;
778 const char *result;
779 } array[] =
780 {
781 { (const char *)0, (const char *)0, 0, (const char *)0 },
782 { (const char *)0, (const char *)0, 1, (const char *)0 },
783 { (const char *)0, (const char *)0, 7, (const char *)0 },
784 { (const char *)0, "", 0, (const char *)0 },
785 { (const char *)0, "", 1, (const char *)0 },
786 { (const char *)0, "", 7, (const char *)0 },
787 { (const char *)0, "stuff", 0, (const char *)0 },
788 { (const char *)0, "stuff", 1, (const char *)0 },
789 { (const char *)0, "stuff", 7, (const char *)0 },
790 { "", (const char *)0, 0, "" },
791 { "", (const char *)0, 1, "" },
792 { "", (const char *)0, 7, "" },
793 { "", "", 0, "" },
794 { "", "", 1, "" },
795 { "", "", 7, "" },
796 { "", "abcdefgh", 0, "" },
797 { "", "abcdefgh", 1, "" },
798 { "", "abcdefgh", 7, "abcdef" },
799 { "xyz", (const char *)0, 0, "xyz" },
800 { "xyz", (const char *)0, 1, "xyz" },
801 { "xyz", (const char *)0, 7, "xyz" },
802 { "xyz", "", 0, "xyz" },
803 { "xyz", "", 1, "xyz" },
804 { "xyz", "", 7, "xyz" },
805 { "xyz", "abcdefgh", 0, "xyz" },
806 { "xyz", "abcdefgh", 1, "xyz" },
807 { "xyz", "abcdefgh", 7, "xyzabc" }
808 };
809
810 int i;
811
812 printf("Test 010 (PL_strcatn) ..."); fflush(stdout);
813
814 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
815 {
816 char buffer[ 1024 ];
817 int j;
818 char *rv;
819
820 for( j = 0; j < sizeof(buffer); j++ ) {
821 buffer[j] = '-';
822 }
823
824 if( (const char *)0 != array[i].first ) {
825 (void)PL_strcpy(buffer, array[i].first);
826 }
827
828 rv = PL_strcatn(((const char *)0 == array[i].first) ? (char *)0 : buffer,
829 array[i].length, array[i].second);
830
831 if( (const char *)0 == array[i].result )
832 {
833 if( (char *)0 != rv )
834 {
835 printf("FAIL %d: %s+%s/%lu -> %.32s, not zero\n", i,
836 array[i].first ? array[i].first : "(null)",
837 array[i].second ? array[i].second : "(null)",
838 array[i].length, rv);
839 return PR_FALSE;
840 }
841 }
842 else
843 {
844 if( (char *)0 == rv )
845 {
846 printf("FAIL %d: %s+%s/%lu -> null, not %s\n", i,
847 array[i].first ? array[i].first : "(null)",
848 array[i].second ? array[i].second : "(null)",
849 array[i].length, array[i].result);
850 return PR_FALSE;
851 }
852 else
853 {
854 const char *a = array[i].result;
855 const char *b = (const char *)rv;
856
857 while( 1 )
858 {
859 if( *a != *b )
860 {
861 printf("FAIL %d: %s+%s/%lu -> %.32s, not %s\n", i,
862 array[i].first ? array[i].first : "(null)",
863 array[i].second ? array[i].second : "(null)",
864 array[i].length, rv, array[i].result);
865 return PR_FALSE;
866 }
867
868 if( (char)0 == *a ) {
869 break;
870 }
871
872 a++;
873 b++;
874 }
875 }
876 }
877 }
878
879 printf("PASS\n");
880 return PR_TRUE;
881 }
882
883 /* PL_strcmp */
884 PRBool test_011(void)
885 {
886 static struct
887 {
888 const char *one;
889 const char *two;
890 PRIntn sign;
891 } array[] =
892 {
893 { (const char *)0, (const char *)0, 0 },
894 { (const char *)0, "word", -1 },
895 { "word", (const char *)0, 1 },
896 { "word", "word", 0 },
897 { "aZYXVUT", "bZYXVUT", -1 },
898 { "aZYXVUT", "bAAAAAA", -1 },
899 { "a", "aa", -1 },
900 { "a", "a", 0 },
901 { "a", "A", 1 },
902 { "aaaaa", "baaaa", -1 },
903 { "aaaaa", "abaaa", -1 },
904 { "aaaaa", "aabaa", -1 },
905 { "aaaaa", "aaaba", -1 },
906 { "aaaaa", "aaaab", -1 },
907 { "bZYXVUT", "aZYXVUT", 1 },
908 { "bAAAAAA", "aZYXVUT", 1 },
909 { "aa", "a", 1 },
910 { "A", "a", -1 },
911 { "baaaa", "aaaaa", 1 },
912 { "abaaa", "aaaaa", 1 },
913 { "aabaa", "aaaaa", 1 },
914 { "aaaba", "aaaaa", 1 },
915 { "aaaab", "aaaaa", 1 },
916 { "word", "Word", 1 },
917 { "word", "wOrd", 1 },
918 { "word", "woRd", 1 },
919 { "word", "worD", 1 },
920 { "WORD", "wORD", -1 },
921 { "WORD", "WoRD", -1 },
922 { "WORD", "WOrD", -1 },
923 { "WORD", "WORd", -1 }
924 };
925
926 int i;
927
928 printf("Test 011 (PL_strcmp) ..."); fflush(stdout);
929
930 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
931 {
932 PRIntn rv = PL_strcmp(array[i].one, array[i].two);
933
934 switch( array[i].sign )
935 {
936 case -1:
937 if( rv < 0 ) {
938 continue;
939 }
940 break;
941 case 1:
942 if( rv > 0 ) {
943 continue;
944 }
945 break;
946 case 0:
947 if( 0 == rv ) {
948 continue;
949 }
950 break;
951 default:
952 PR_NOT_REACHED("static data inconsistancy");
953 break;
954 }
955
956 printf("FAIL %d: %s-%s -> %d, not %d\n", i,
957 array[i].one ? array[i].one : "(null)",
958 array[i].two ? array[i].two : "(null)",
959 rv, array[i].sign);
960 return PR_FALSE;
961 }
962
963 printf("PASS\n");
964 return PR_TRUE;
965 }
966
967 /* PL_strncmp */
968 PRBool test_012(void)
969 {
970 static struct
971 {
972 const char *one;
973 const char *two;
974 PRUint32 max;
975 PRIntn sign;
976 } array[] =
977 {
978 { (const char *)0, (const char *)0, 0, 0 },
979 { (const char *)0, (const char *)0, 1, 0 },
980 { (const char *)0, (const char *)0, 4, 0 },
981 { (const char *)0, "word", 0, -1 },
982 { (const char *)0, "word", 1, -1 },
983 { (const char *)0, "word", 4, -1 },
984 { "word", (const char *)0, 0, 1 },
985 { "word", (const char *)0, 1, 1 },
986 { "word", (const char *)0, 4, 1 },
987 { "word", "word", 0, 0 },
988 { "word", "word", 1, 0 },
989 { "word", "word", 3, 0 },
990 { "word", "word", 5, 0 },
991 { "aZYXVUT", "bZYXVUT", 0, 0 },
992 { "aZYXVUT", "bZYXVUT", 1, -1 },
993 { "aZYXVUT", "bZYXVUT", 4, -1 },
994 { "aZYXVUT", "bZYXVUT", 9, -1 },
995 { "aZYXVUT", "bAAAAAA", 0, 0 },
996 { "aZYXVUT", "bAAAAAA", 1, -1 },
997 { "aZYXVUT", "bAAAAAA", 4, -1 },
998 { "aZYXVUT", "bAAAAAA", 5, -1 },
999 { "a", "aa", 0, 0 },
1000 { "a", "aa", 1, 0 },
1001 { "a", "aa", 4, -1 },
1002 { "a", "a", 0, 0 },
1003 { "a", "a", 1, 0 },
1004 { "a", "a", 4, 0 },
1005 { "a", "A", 0, 0 },
1006 { "a", "A", 1, 1 },
1007 { "a", "A", 4, 1 },
1008 { "aaaaa", "baaaa", 0, 0 },
1009 { "aaaaa", "baaaa", 1, -1 },
1010 { "aaaaa", "baaaa", 4, -1 },
1011 { "aaaaa", "abaaa", 0, 0 },
1012 { "aaaaa", "abaaa", 1, 0 },
1013 { "aaaaa", "abaaa", 4, -1 },
1014 { "aaaaa", "aabaa", 0, 0 },
1015 { "aaaaa", "aabaa", 1, 0 },
1016 { "aaaaa", "aabaa", 4, -1 },
1017 { "aaaaa", "aaaba", 0, 0 },
1018 { "aaaaa", "aaaba", 1, 0 },
1019 { "aaaaa", "aaaba", 4, -1 },
1020 { "aaaaa", "aaaab", 0, 0 },
1021 { "aaaaa", "aaaab", 1, 0 },
1022 { "aaaaa", "aaaab", 4, 0 },
1023 { "bZYXVUT", "aZYXVUT", 0, 0 },
1024 { "bZYXVUT", "aZYXVUT", 1, 1 },
1025 { "bZYXVUT", "aZYXVUT", 4, 1 },
1026 { "bAAAAAA", "aZYXVUT", 0, 0 },
1027 { "bAAAAAA", "aZYXVUT", 1, 1 },
1028 { "bAAAAAA", "aZYXVUT", 4, 1 },
1029 { "aa", "a", 0, 0 },
1030 { "aa", "a", 1, 0 },
1031 { "aa", "a", 4, 1 },
1032 { "A", "a", 0, 0 },
1033 { "A", "a", 1, -1 },
1034 { "A", "a", 4, -1 },
1035 { "baaaa", "aaaaa", 0, 0 },
1036 { "baaaa", "aaaaa", 1, 1 },
1037 { "baaaa", "aaaaa", 4, 1 },
1038 { "abaaa", "aaaaa", 0, 0 },
1039 { "abaaa", "aaaaa", 1, 0 },
1040 { "abaaa", "aaaaa", 4, 1 },
1041 { "aabaa", "aaaaa", 0, 0 },
1042 { "aabaa", "aaaaa", 1, 0 },
1043 { "aabaa", "aaaaa", 4, 1 },
1044 { "aaaba", "aaaaa", 0, 0 },
1045 { "aaaba", "aaaaa", 1, 0 },
1046 { "aaaba", "aaaaa", 4, 1 },
1047 { "aaaab", "aaaaa", 0, 0 },
1048 { "aaaab", "aaaaa", 1, 0 },
1049 { "aaaab", "aaaaa", 4, 0 },
1050 { "word", "Word", 0, 0 },
1051 { "word", "Word", 1, 1 },
1052 { "word", "Word", 3, 1 },
1053 { "word", "wOrd", 0, 0 },
1054 { "word", "wOrd", 1, 0 },
1055 { "word", "wOrd", 3, 1 },
1056 { "word", "woRd", 0, 0 },
1057 { "word", "woRd", 1, 0 },
1058 { "word", "woRd", 3, 1 },
1059 { "word", "worD", 0, 0 },
1060 { "word", "worD", 1, 0 },
1061 { "word", "worD", 3, 0 },
1062 { "WORD", "wORD", 0, 0 },
1063 { "WORD", "wORD", 1, -1 },
1064 { "WORD", "wORD", 3, -1 },
1065 { "WORD", "WoRD", 0, 0 },
1066 { "WORD", "WoRD", 1, 0 },
1067 { "WORD", "WoRD", 3, -1 },
1068 { "WORD", "WOrD", 0, 0 },
1069 { "WORD", "WOrD", 1, 0 },
1070 { "WORD", "WOrD", 3, -1 },
1071 { "WORD", "WORd", 0, 0 },
1072 { "WORD", "WORd", 1, 0 },
1073 { "WORD", "WORd", 3, 0 }
1074
1075 };
1076
1077 int i;
1078
1079 printf("Test 012 (PL_strncmp) ..."); fflush(stdout);
1080
1081 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1082 {
1083 PRIntn rv = PL_strncmp(array[i].one, array[i].two, array[i].max);
1084
1085 switch( array[i].sign )
1086 {
1087 case -1:
1088 if( rv < 0 ) {
1089 continue;
1090 }
1091 break;
1092 case 1:
1093 if( rv > 0 ) {
1094 continue;
1095 }
1096 break;
1097 case 0:
1098 if( 0 == rv ) {
1099 continue;
1100 }
1101 break;
1102 default:
1103 PR_NOT_REACHED("static data inconsistancy");
1104 break;
1105 }
1106
1107 printf("FAIL %d: %s-%s/%ld -> %d, not %d\n", i,
1108 array[i].one ? array[i].one : "(null)",
1109 array[i].two ? array[i].two : "(null)",
1110 array[i].max, rv, array[i].sign);
1111 return PR_FALSE;
1112 }
1113
1114 printf("PASS\n");
1115 return PR_TRUE;
1116 }
1117
1118 /* PL_strcasecmp */
1119 PRBool test_013(void)
1120 {
1121 static struct
1122 {
1123 const char *one;
1124 const char *two;
1125 PRIntn sign;
1126 } array[] =
1127 {
1128 { (const char *)0, (const char *)0, 0 },
1129 { (const char *)0, "word", -1 },
1130 { "word", (const char *)0, 1 },
1131 { "word", "word", 0 },
1132 { "aZYXVUT", "bZYXVUT", -1 },
1133 { "aZYXVUT", "bAAAAAA", -1 },
1134 { "a", "aa", -1 },
1135 { "a", "a", 0 },
1136 { "a", "A", 0 },
1137 { "aaaaa", "baaaa", -1 },
1138 { "aaaaa", "abaaa", -1 },
1139 { "aaaaa", "aabaa", -1 },
1140 { "aaaaa", "aaaba", -1 },
1141 { "aaaaa", "aaaab", -1 },
1142 { "bZYXVUT", "aZYXVUT", 1 },
1143 { "bAAAAAA", "aZYXVUT", 1 },
1144 { "aa", "a", 1 },
1145 { "A", "a", 0 },
1146 { "baaaa", "aaaaa", 1 },
1147 { "abaaa", "aaaaa", 1 },
1148 { "aabaa", "aaaaa", 1 },
1149 { "aaaba", "aaaaa", 1 },
1150 { "aaaab", "aaaaa", 1 },
1151 { "word", "Word", 0 },
1152 { "word", "wOrd", 0 },
1153 { "word", "woRd", 0 },
1154 { "word", "worD", 0 },
1155 { "WORD", "wORD", 0 },
1156 { "WORD", "WoRD", 0 },
1157 { "WORD", "WOrD", 0 },
1158 { "WORD", "WORd", 0 }
1159 };
1160
1161 int i;
1162
1163 printf("Test 013 (PL_strcasecmp) ..."); fflush(stdout);
1164
1165 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1166 {
1167 PRIntn rv = PL_strcasecmp(array[i].one, array[i].two);
1168
1169 switch( array[i].sign )
1170 {
1171 case -1:
1172 if( rv < 0 ) {
1173 continue;
1174 }
1175 break;
1176 case 1:
1177 if( rv > 0 ) {
1178 continue;
1179 }
1180 break;
1181 case 0:
1182 if( 0 == rv ) {
1183 continue;
1184 }
1185 break;
1186 default:
1187 PR_NOT_REACHED("static data inconsistancy");
1188 break;
1189 }
1190
1191 printf("FAIL %d: %s-%s -> %d, not %d\n", i,
1192 array[i].one ? array[i].one : "(null)",
1193 array[i].two ? array[i].two : "(null)",
1194 rv, array[i].sign);
1195 return PR_FALSE;
1196 }
1197
1198 printf("PASS\n");
1199 return PR_TRUE;
1200 }
1201
1202 /* PL_strncasecmp */
1203 PRBool test_014(void)
1204 {
1205 static struct
1206 {
1207 const char *one;
1208 const char *two;
1209 PRUint32 max;
1210 PRIntn sign;
1211 } array[] =
1212 {
1213 { (const char *)0, (const char *)0, 0, 0 },
1214 { (const char *)0, (const char *)0, 1, 0 },
1215 { (const char *)0, (const char *)0, 4, 0 },
1216 { (const char *)0, "word", 0, -1 },
1217 { (const char *)0, "word", 1, -1 },
1218 { (const char *)0, "word", 4, -1 },
1219 { "word", (const char *)0, 0, 1 },
1220 { "word", (const char *)0, 1, 1 },
1221 { "word", (const char *)0, 4, 1 },
1222 { "word", "word", 0, 0 },
1223 { "word", "word", 1, 0 },
1224 { "word", "word", 3, 0 },
1225 { "word", "word", 5, 0 },
1226 { "aZYXVUT", "bZYXVUT", 0, 0 },
1227 { "aZYXVUT", "bZYXVUT", 1, -1 },
1228 { "aZYXVUT", "bZYXVUT", 4, -1 },
1229 { "aZYXVUT", "bZYXVUT", 9, -1 },
1230 { "aZYXVUT", "bAAAAAA", 0, 0 },
1231 { "aZYXVUT", "bAAAAAA", 1, -1 },
1232 { "aZYXVUT", "bAAAAAA", 4, -1 },
1233 { "aZYXVUT", "bAAAAAA", 5, -1 },
1234 { "a", "aa", 0, 0 },
1235 { "a", "aa", 1, 0 },
1236 { "a", "aa", 4, -1 },
1237 { "a", "a", 0, 0 },
1238 { "a", "a", 1, 0 },
1239 { "a", "a", 4, 0 },
1240 { "a", "A", 0, 0 },
1241 { "a", "A", 1, 0 },
1242 { "a", "A", 4, 0 },
1243 { "aaaaa", "baaaa", 0, 0 },
1244 { "aaaaa", "baaaa", 1, -1 },
1245 { "aaaaa", "baaaa", 4, -1 },
1246 { "aaaaa", "abaaa", 0, 0 },
1247 { "aaaaa", "abaaa", 1, 0 },
1248 { "aaaaa", "abaaa", 4, -1 },
1249 { "aaaaa", "aabaa", 0, 0 },
1250 { "aaaaa", "aabaa", 1, 0 },
1251 { "aaaaa", "aabaa", 4, -1 },
1252 { "aaaaa", "aaaba", 0, 0 },
1253 { "aaaaa", "aaaba", 1, 0 },
1254 { "aaaaa", "aaaba", 4, -1 },
1255 { "aaaaa", "aaaab", 0, 0 },
1256 { "aaaaa", "aaaab", 1, 0 },
1257 { "aaaaa", "aaaab", 4, 0 },
1258 { "bZYXVUT", "aZYXVUT", 0, 0 },
1259 { "bZYXVUT", "aZYXVUT", 1, 1 },
1260 { "bZYXVUT", "aZYXVUT", 4, 1 },
1261 { "bAAAAAA", "aZYXVUT", 0, 0 },
1262 { "bAAAAAA", "aZYXVUT", 1, 1 },
1263 { "bAAAAAA", "aZYXVUT", 4, 1 },
1264 { "aa", "a", 0, 0 },
1265 { "aa", "a", 1, 0 },
1266 { "aa", "a", 4, 1 },
1267 { "A", "a", 0, 0 },
1268 { "A", "a", 1, 0 },
1269 { "A", "a", 4, 0 },
1270 { "baaaa", "aaaaa", 0, 0 },
1271 { "baaaa", "aaaaa", 1, 1 },
1272 { "baaaa", "aaaaa", 4, 1 },
1273 { "abaaa", "aaaaa", 0, 0 },
1274 { "abaaa", "aaaaa", 1, 0 },
1275 { "abaaa", "aaaaa", 4, 1 },
1276 { "aabaa", "aaaaa", 0, 0 },
1277 { "aabaa", "aaaaa", 1, 0 },
1278 { "aabaa", "aaaaa", 4, 1 },
1279 { "aaaba", "aaaaa", 0, 0 },
1280 { "aaaba", "aaaaa", 1, 0 },
1281 { "aaaba", "aaaaa", 4, 1 },
1282 { "aaaab", "aaaaa", 0, 0 },
1283 { "aaaab", "aaaaa", 1, 0 },
1284 { "aaaab", "aaaaa", 4, 0 },
1285 { "word", "Word", 0, 0 },
1286 { "word", "Word", 1, 0 },
1287 { "word", "Word", 3, 0 },
1288 { "word", "wOrd", 0, 0 },
1289 { "word", "wOrd", 1, 0 },
1290 { "word", "wOrd", 3, 0 },
1291 { "word", "woRd", 0, 0 },
1292 { "word", "woRd", 1, 0 },
1293 { "word", "woRd", 3, 0 },
1294 { "word", "worD", 0, 0 },
1295 { "word", "worD", 1, 0 },
1296 { "word", "worD", 3, 0 },
1297 { "WORD", "wORD", 0, 0 },
1298 { "WORD", "wORD", 1, 0 },
1299 { "WORD", "wORD", 3, 0 },
1300 { "WORD", "WoRD", 0, 0 },
1301 { "WORD", "WoRD", 1, 0 },
1302 { "WORD", "WoRD", 3, 0 },
1303 { "WORD", "WOrD", 0, 0 },
1304 { "WORD", "WOrD", 1, 0 },
1305 { "WORD", "WOrD", 3, 0 },
1306 { "WORD", "WORd", 0, 0 },
1307 { "WORD", "WORd", 1, 0 },
1308 { "WORD", "WORd", 3, 0 }
1309 };
1310
1311 int i;
1312
1313 printf("Test 014 (PL_strncasecmp) ..."); fflush(stdout);
1314
1315 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1316 {
1317 PRIntn rv = PL_strncasecmp(array[i].one, array[i].two, array[i].max);
1318
1319 switch( array[i].sign )
1320 {
1321 case -1:
1322 if( rv < 0 ) {
1323 continue;
1324 }
1325 break;
1326 case 1:
1327 if( rv > 0 ) {
1328 continue;
1329 }
1330 break;
1331 case 0:
1332 if( 0 == rv ) {
1333 continue;
1334 }
1335 break;
1336 default:
1337 PR_NOT_REACHED("static data inconsistancy");
1338 break;
1339 }
1340
1341 printf("FAIL %d: %s-%s/%ld -> %d, not %d\n", i,
1342 array[i].one ? array[i].one : "(null)",
1343 array[i].two ? array[i].two : "(null)",
1344 array[i].max, rv, array[i].sign);
1345 return PR_FALSE;
1346 }
1347
1348 printf("PASS\n");
1349 return PR_TRUE;
1350 }
1351
1352 /* PL_strchr */
1353 PRBool test_015(void)
1354 {
1355 static struct
1356 {
1357 const char *str;
1358 char chr;
1359 PRBool ret;
1360 PRUint32 off;
1361 } array[] =
1362 {
1363 { (const char *)0, 'a', PR_FALSE, 0 },
1364 { (const char *)0, '\0', PR_FALSE, 0 },
1365 { "abcdefg", 'a', PR_TRUE, 0 },
1366 { "abcdefg", 'b', PR_TRUE, 1 },
1367 { "abcdefg", 'c', PR_TRUE, 2 },
1368 { "abcdefg", 'd', PR_TRUE, 3 },
1369 { "abcdefg", 'e', PR_TRUE, 4 },
1370 { "abcdefg", 'f', PR_TRUE, 5 },
1371 { "abcdefg", 'g', PR_TRUE, 6 },
1372 { "abcdefg", 'h', PR_FALSE, 0 },
1373 { "abcdefg", '\0', PR_TRUE, 7 },
1374 { "abcdefg", 'A', PR_FALSE, 0 },
1375 { "abcdefg", 'B', PR_FALSE, 0 },
1376 { "abcdefg", 'C', PR_FALSE, 0 },
1377 { "abcdefg", 'D', PR_FALSE, 0 },
1378 { "abcdefg", 'E', PR_FALSE, 0 },
1379 { "abcdefg", 'F', PR_FALSE, 0 },
1380 { "abcdefg", 'G', PR_FALSE, 0 },
1381 { "abcdefg", 'H', PR_FALSE, 0 },
1382 { "abcdefgabcdefg", 'a', PR_TRUE, 0 },
1383 { "abcdefgabcdefg", 'b', PR_TRUE, 1 },
1384 { "abcdefgabcdefg", 'c', PR_TRUE, 2 },
1385 { "abcdefgabcdefg", 'd', PR_TRUE, 3 },
1386 { "abcdefgabcdefg", 'e', PR_TRUE, 4 },
1387 { "abcdefgabcdefg", 'f', PR_TRUE, 5 },
1388 { "abcdefgabcdefg", 'g', PR_TRUE, 6 },
1389 { "abcdefgabcdefg", 'h', PR_FALSE, 0 },
1390 { "abcdefgabcdefg", '\0', PR_TRUE, 14 }
1391 };
1392
1393 int i;
1394
1395 printf("Test 015 (PL_strchr) ..."); fflush(stdout);
1396
1397 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1398 {
1399 char *rv = PL_strchr(array[i].str, array[i].chr);
1400
1401 if( PR_FALSE == array[i].ret )
1402 {
1403 if( (char *)0 != rv )
1404 {
1405 printf("FAIL %d: %s,%c -> %.32s, not zero\n", i, array[i].str,
1406 array[i].chr, rv);
1407 return PR_FALSE;
1408 }
1409 }
1410 else
1411 {
1412 if( (char *)0 == rv )
1413 {
1414 printf("FAIL %d: %s,%c -> null, not +%lu\n", i, array[i].str,
1415 array[i].chr, array[i].off);
1416 return PR_FALSE;
1417 }
1418
1419 if( &array[i].str[ array[i].off ] != rv )
1420 {
1421 printf("FAIL %d: %s,%c -> 0x%x, not 0x%x+%lu\n", i, array[i].str,
1422 array[i].chr, rv, array[i].str, array[i].off);
1423 return PR_FALSE;
1424 }
1425 }
1426 }
1427
1428 printf("PASS\n");
1429 return PR_TRUE;
1430 }
1431
1432 /* PL_strrchr */
1433 PRBool test_016(void)
1434 {
1435 static struct
1436 {
1437 const char *str;
1438 char chr;
1439 PRBool ret;
1440 PRUint32 off;
1441 } array[] =
1442 {
1443 { (const char *)0, 'a', PR_FALSE, 0 },
1444 { (const char *)0, '\0', PR_FALSE, 0 },
1445 { "abcdefg", 'a', PR_TRUE, 0 },
1446 { "abcdefg", 'b', PR_TRUE, 1 },
1447 { "abcdefg", 'c', PR_TRUE, 2 },
1448 { "abcdefg", 'd', PR_TRUE, 3 },
1449 { "abcdefg", 'e', PR_TRUE, 4 },
1450 { "abcdefg", 'f', PR_TRUE, 5 },
1451 { "abcdefg", 'g', PR_TRUE, 6 },
1452 { "abcdefg", 'h', PR_FALSE, 0 },
1453 { "abcdefg", '\0', PR_TRUE, 7 },
1454 { "abcdefg", 'A', PR_FALSE, 0 },
1455 { "abcdefg", 'B', PR_FALSE, 0 },
1456 { "abcdefg", 'C', PR_FALSE, 0 },
1457 { "abcdefg", 'D', PR_FALSE, 0 },
1458 { "abcdefg", 'E', PR_FALSE, 0 },
1459 { "abcdefg", 'F', PR_FALSE, 0 },
1460 { "abcdefg", 'G', PR_FALSE, 0 },
1461 { "abcdefg", 'H', PR_FALSE, 0 },
1462 { "abcdefgabcdefg", 'a', PR_TRUE, 7 },
1463 { "abcdefgabcdefg", 'b', PR_TRUE, 8 },
1464 { "abcdefgabcdefg", 'c', PR_TRUE, 9 },
1465 { "abcdefgabcdefg", 'd', PR_TRUE, 10 },
1466 { "abcdefgabcdefg", 'e', PR_TRUE, 11 },
1467 { "abcdefgabcdefg", 'f', PR_TRUE, 12 },
1468 { "abcdefgabcdefg", 'g', PR_TRUE, 13 },
1469 { "abcdefgabcdefg", 'h', PR_FALSE, 0 },
1470 { "abcdefgabcdefg", '\0', PR_TRUE, 14 }
1471 };
1472
1473 int i;
1474
1475 printf("Test 016 (PL_strrchr) ..."); fflush(stdout);
1476
1477 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1478 {
1479 char *rv = PL_strrchr(array[i].str, array[i].chr);
1480
1481 if( PR_FALSE == array[i].ret )
1482 {
1483 if( (char *)0 != rv )
1484 {
1485 printf("FAIL %d: %s,%c -> %.32s, not zero\n", i, array[i].str,
1486 array[i].chr, rv);
1487 return PR_FALSE;
1488 }
1489 }
1490 else
1491 {
1492 if( (char *)0 == rv )
1493 {
1494 printf("FAIL %d: %s,%c -> null, not +%lu\n", i, array[i].str,
1495 array[i].chr, array[i].off);
1496 return PR_FALSE;
1497 }
1498
1499 if( &array[i].str[ array[i].off ] != rv )
1500 {
1501 printf("FAIL %d: %s,%c -> 0x%x, not 0x%x+%lu\n", i, array[i].str,
1502 array[i].chr, rv, array[i].str, array[i].off);
1503 return PR_FALSE;
1504 }
1505 }
1506 }
1507
1508 printf("PASS\n");
1509 return PR_TRUE;
1510 }
1511
1512 /* PL_strnchr */
1513 PRBool test_017(void)
1514 {
1515 static struct
1516 {
1517 const char *str;
1518 char chr;
1519 PRUint32 max;
1520 PRBool ret;
1521 PRUint32 off;
1522 } array[] =
1523 {
1524 { (const char *)0, 'a', 2, PR_FALSE, 0 },
1525 { (const char *)0, '\0', 2, PR_FALSE, 0 },
1526 { "abcdefg", 'a', 5, PR_TRUE, 0 },
1527 { "abcdefg", 'b', 5, PR_TRUE, 1 },
1528 { "abcdefg", 'c', 5, PR_TRUE, 2 },
1529 { "abcdefg", 'd', 5, PR_TRUE, 3 },
1530 { "abcdefg", 'e', 5, PR_TRUE, 4 },
1531 { "abcdefg", 'f', 5, PR_FALSE, 0 },
1532 { "abcdefg", 'g', 5, PR_FALSE, 0 },
1533 { "abcdefg", 'h', 5, PR_FALSE, 0 },
1534 { "abcdefg", '\0', 5, PR_FALSE, 0 },
1535 { "abcdefg", '\0', 15, PR_TRUE, 7 },
1536 { "abcdefg", 'A', 5, PR_FALSE, 0 },
1537 { "abcdefg", 'B', 5, PR_FALSE, 0 },
1538 { "abcdefg", 'C', 5, PR_FALSE, 0 },
1539 { "abcdefg", 'D', 5, PR_FALSE, 0 },
1540 { "abcdefg", 'E', 5, PR_FALSE, 0 },
1541 { "abcdefg", 'F', 5, PR_FALSE, 0 },
1542 { "abcdefg", 'G', 5, PR_FALSE, 0 },
1543 { "abcdefg", 'H', 5, PR_FALSE, 0 },
1544 { "abcdefgabcdefg", 'a', 10, PR_TRUE, 0 },
1545 { "abcdefgabcdefg", 'b', 10, PR_TRUE, 1 },
1546 { "abcdefgabcdefg", 'c', 10, PR_TRUE, 2 },
1547 { "abcdefgabcdefg", 'd', 10, PR_TRUE, 3 },
1548 { "abcdefgabcdefg", 'e', 10, PR_TRUE, 4 },
1549 { "abcdefgabcdefg", 'f', 10, PR_TRUE, 5 },
1550 { "abcdefgabcdefg", 'g', 10, PR_TRUE, 6 },
1551 { "abcdefgabcdefg", 'h', 10, PR_FALSE, 0 },
1552 { "abcdefgabcdefg", '\0', 10, PR_FALSE, 0 },
1553 { "abcdefgabcdefg", '\0', 14, PR_FALSE, 0 },
1554 { "abcdefgabcdefg", '\0', 15, PR_TRUE, 14 }
1555 };
1556
1557 int i;
1558
1559 printf("Test 017 (PL_strnchr) ..."); fflush(stdout);
1560
1561 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1562 {
1563 char *rv = PL_strnchr(array[i].str, array[i].chr, array[i].max);
1564
1565 if( PR_FALSE == array[i].ret )
1566 {
1567 if( (char *)0 != rv )
1568 {
1569 printf("FAIL %d: %s,%c/%lu -> %.32s, not zero\n", i, array[i].str,
1570 array[i].chr, array[i].max, rv);
1571 return PR_FALSE;
1572 }
1573 }
1574 else
1575 {
1576 if( (char *)0 == rv )
1577 {
1578 printf("FAIL %d: %s,%c/%lu -> null, not +%lu\n", i, array[i].str,
1579 array[i].chr, array[i].max, array[i].off);
1580 return PR_FALSE;
1581 }
1582
1583 if( &array[i].str[ array[i].off ] != rv )
1584 {
1585 printf("FAIL %d: %s,%c/%lu -> 0x%x, not 0x%x+%lu\n", i, array[i].str,
1586 array[i].chr, array[i].max, rv, array[i].str, array[i].off);
1587 return PR_FALSE;
1588 }
1589 }
1590 }
1591
1592 printf("PASS\n");
1593 return PR_TRUE;
1594 }
1595
1596 /* PL_strnrchr */
1597 PRBool test_018(void)
1598 {
1599 static struct
1600 {
1601 const char *str;
1602 char chr;
1603 PRUint32 max;
1604 PRBool ret;
1605 PRUint32 off;
1606 } array[] =
1607 {
1608 { (const char *)0, 'a', 2, PR_FALSE, 0 },
1609 { (const char *)0, '\0', 2, PR_FALSE, 0 },
1610 { "abcdefg", 'a', 5, PR_TRUE, 0 },
1611 { "abcdefg", 'b', 5, PR_TRUE, 1 },
1612 { "abcdefg", 'c', 5, PR_TRUE, 2 },
1613 { "abcdefg", 'd', 5, PR_TRUE, 3 },
1614 { "abcdefg", 'e', 5, PR_TRUE, 4 },
1615 { "abcdefg", 'f', 5, PR_FALSE, 0 },
1616 { "abcdefg", 'g', 5, PR_FALSE, 0 },
1617 { "abcdefg", 'h', 5, PR_FALSE, 0 },
1618 { "abcdefg", '\0', 5, PR_FALSE, 0 },
1619 { "abcdefg", '\0', 15, PR_TRUE, 7 },
1620 { "abcdefg", 'A', 5, PR_FALSE, 0 },
1621 { "abcdefg", 'B', 5, PR_FALSE, 0 },
1622 { "abcdefg", 'C', 5, PR_FALSE, 0 },
1623 { "abcdefg", 'D', 5, PR_FALSE, 0 },
1624 { "abcdefg", 'E', 5, PR_FALSE, 0 },
1625 { "abcdefg", 'F', 5, PR_FALSE, 0 },
1626 { "abcdefg", 'G', 5, PR_FALSE, 0 },
1627 { "abcdefg", 'H', 5, PR_FALSE, 0 },
1628 { "abcdefgabcdefg", 'a', 10, PR_TRUE, 7 },
1629 { "abcdefgabcdefg", 'b', 10, PR_TRUE, 8 },
1630 { "abcdefgabcdefg", 'c', 10, PR_TRUE, 9 },
1631 { "abcdefgabcdefg", 'd', 10, PR_TRUE, 3 },
1632 { "abcdefgabcdefg", 'e', 10, PR_TRUE, 4 },
1633 { "abcdefgabcdefg", 'f', 10, PR_TRUE, 5 },
1634 { "abcdefgabcdefg", 'g', 10, PR_TRUE, 6 },
1635 { "abcdefgabcdefg", 'h', 10, PR_FALSE, 0 },
1636 { "abcdefgabcdefg", '\0', 10, PR_FALSE, 0 },
1637 { "abcdefgabcdefg", '\0', 14, PR_FALSE, 0 },
1638 { "abcdefgabcdefg", '\0', 15, PR_TRUE, 14 }
1639 };
1640
1641 int i;
1642
1643 printf("Test 018 (PL_strnrchr) ..."); fflush(stdout);
1644
1645 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1646 {
1647 char *rv = PL_strnrchr(array[i].str, array[i].chr, array[i].max);
1648
1649 if( PR_FALSE == array[i].ret )
1650 {
1651 if( (char *)0 != rv )
1652 {
1653 printf("FAIL %d: %s,%c/%lu -> %.32s, not zero\n", i, array[i].str,
1654 array[i].chr, array[i].max, rv);
1655 return PR_FALSE;
1656 }
1657 }
1658 else
1659 {
1660 if( (char *)0 == rv )
1661 {
1662 printf("FAIL %d: %s,%c/%lu -> null, not +%lu\n", i, array[i].str,
1663 array[i].chr, array[i].max, array[i].off);
1664 return PR_FALSE;
1665 }
1666
1667 if( &array[i].str[ array[i].off ] != rv )
1668 {
1669 printf("FAIL %d: %s,%c/%lu -> 0x%x, not 0x%x+%lu\n", i, array[i].str,
1670 array[i].chr, array[i].max, rv, array[i].str, array[i].off);
1671 return PR_FALSE;
1672 }
1673 }
1674 }
1675
1676 printf("PASS\n");
1677 return PR_TRUE;
1678 }
1679
1680 /* PL_strpbrk */
1681 PRBool test_019(void)
1682 {
1683 static struct
1684 {
1685 const char *str;
1686 const char *chrs;
1687 PRBool ret;
1688 PRUint32 off;
1689 } array[] =
1690 {
1691 { (const char *)0, (const char *)0, PR_FALSE, 0 },
1692 { (const char *)0, "abc", PR_FALSE, 0 },
1693 { "abc", (const char *)0, PR_FALSE, 0 },
1694 { "abcdefg", "", PR_FALSE, 0 },
1695 { "", "aeiou", PR_FALSE, 0 },
1696 { "abcdefg", "ae", PR_TRUE, 0 },
1697 { "abcdefg", "ei", PR_TRUE, 4 },
1698 { "abcdefg", "io", PR_FALSE, 0 },
1699 { "abcdefg", "bcd", PR_TRUE, 1 },
1700 { "abcdefg", "cbd", PR_TRUE, 1 },
1701 { "abcdefg", "dbc", PR_TRUE, 1 },
1702 { "abcdefg", "ghi", PR_TRUE, 6 },
1703 { "abcdefg", "AE", PR_FALSE, 0 },
1704 { "abcdefg", "EI", PR_FALSE, 0 },
1705 { "abcdefg", "IO", PR_FALSE, 0 },
1706 { "abcdefg", "BCD", PR_FALSE, 0 },
1707 { "abcdefg", "CBD", PR_FALSE, 0 },
1708 { "abcdefg", "DBC", PR_FALSE, 0 },
1709 { "abcdefg", "GHI", PR_FALSE, 0 },
1710 { "abcdefgabcdefg", "ae", PR_TRUE, 0 },
1711 { "abcdefgabcdefg", "ei", PR_TRUE, 4 },
1712 { "abcdefgabcdefg", "io", PR_FALSE, 0 },
1713 { "abcdefgabcdefg", "bcd", PR_TRUE, 1 },
1714 { "abcdefgabcdefg", "cbd", PR_TRUE, 1 },
1715 { "abcdefgabcdefg", "dbc", PR_TRUE, 1 },
1716 { "abcdefgabcdefg", "ghi", PR_TRUE, 6 },
1717 { "abcdefgabcdefg", "AE", PR_FALSE, 0 },
1718 { "abcdefgabcdefg", "EI", PR_FALSE, 0 },
1719 { "abcdefgabcdefg", "IO", PR_FALSE, 0 },
1720 { "abcdefgabcdefg", "BCD", PR_FALSE, 0 },
1721 { "abcdefgabcdefg", "CBD", PR_FALSE, 0 },
1722 { "abcdefgabcdefg", "DBC", PR_FALSE, 0 },
1723 { "abcdefgabcdefg", "GHI", PR_FALSE, 0 }
1724 };
1725
1726 int i;
1727
1728 printf("Test 019 (PL_strpbrk) ..."); fflush(stdout);
1729
1730 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1731 {
1732 char *rv = PL_strpbrk(array[i].str, array[i].chrs);
1733
1734 if( PR_FALSE == array[i].ret )
1735 {
1736 if( (char *)0 != rv )
1737 {
1738 printf("FAIL %d: %s,%s -> %.32s, not null\n", i,
1739 array[i].str ? array[i].str : "(null)",
1740 array[i].chrs ? array[i].chrs : "(null)",
1741 rv);
1742 return PR_FALSE;
1743 }
1744 }
1745 else
1746 {
1747 if( (char *)0 == rv )
1748 {
1749 printf("FAIL %d: %s,%s -> null, not +%lu\n", i,
1750 array[i].str ? array[i].str : "(null)",
1751 array[i].chrs ? array[i].chrs : "(null)",
1752 array[i].off);
1753 return PR_FALSE;
1754 }
1755
1756 if( &array[i].str[ array[i].off ] != rv )
1757 {
1758 printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i,
1759 array[i].str ? array[i].str : "(null)",
1760 array[i].chrs ? array[i].chrs : "(null)",
1761 rv, array[i].str, array[i].off);
1762 return PR_FALSE;
1763 }
1764 }
1765 }
1766
1767 printf("PASS\n");
1768 return PR_TRUE;
1769 }
1770
1771 /* PL_strprbrk */
1772 PRBool test_020(void)
1773 {
1774 static struct
1775 {
1776 const char *str;
1777 const char *chrs;
1778 PRBool ret;
1779 PRUint32 off;
1780 } array[] =
1781 {
1782 { (const char *)0, (const char *)0, PR_FALSE, 0 },
1783 { (const char *)0, "abc", PR_FALSE, 0 },
1784 { "abc", (const char *)0, PR_FALSE, 0 },
1785 { "abcdefg", "", PR_FALSE, 0 },
1786 { "", "aeiou", PR_FALSE, 0 },
1787 { "abcdefg", "ae", PR_TRUE, 4 },
1788 { "abcdefg", "ei", PR_TRUE, 4 },
1789 { "abcdefg", "io", PR_FALSE, 0 },
1790 { "abcdefg", "bcd", PR_TRUE, 3 },
1791 { "abcdefg", "cbd", PR_TRUE, 3 },
1792 { "abcdefg", "dbc", PR_TRUE, 3 },
1793 { "abcdefg", "ghi", PR_TRUE, 6 },
1794 { "abcdefg", "AE", PR_FALSE, 0 },
1795 { "abcdefg", "EI", PR_FALSE, 0 },
1796 { "abcdefg", "IO", PR_FALSE, 0 },
1797 { "abcdefg", "BCD", PR_FALSE, 0 },
1798 { "abcdefg", "CBD", PR_FALSE, 0 },
1799 { "abcdefg", "DBC", PR_FALSE, 0 },
1800 { "abcdefg", "GHI", PR_FALSE, 0 },
1801 { "abcdefgabcdefg", "ae", PR_TRUE, 11 },
1802 { "abcdefgabcdefg", "ei", PR_TRUE, 11 },
1803 { "abcdefgabcdefg", "io", PR_FALSE, 0 },
1804 { "abcdefgabcdefg", "bcd", PR_TRUE, 10 },
1805 { "abcdefgabcdefg", "cbd", PR_TRUE, 10 },
1806 { "abcdefgabcdefg", "dbc", PR_TRUE, 10 },
1807 { "abcdefgabcdefg", "ghi", PR_TRUE, 13 },
1808 { "abcdefgabcdefg", "AE", PR_FALSE, 0 },
1809 { "abcdefgabcdefg", "EI", PR_FALSE, 0 },
1810 { "abcdefgabcdefg", "IO", PR_FALSE, 0 },
1811 { "abcdefgabcdefg", "BCD", PR_FALSE, 0 },
1812 { "abcdefgabcdefg", "CBD", PR_FALSE, 0 },
1813 { "abcdefgabcdefg", "DBC", PR_FALSE, 0 },
1814 { "abcdefgabcdefg", "GHI", PR_FALSE, 0 }
1815 };
1816
1817 int i;
1818
1819 printf("Test 020 (PL_strprbrk) ..."); fflush(stdout);
1820
1821 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1822 {
1823 char *rv = PL_strprbrk(array[i].str, array[i].chrs);
1824
1825 if( PR_FALSE == array[i].ret )
1826 {
1827 if( (char *)0 != rv )
1828 {
1829 printf("FAIL %d: %s,%s -> %.32s, not null\n", i,
1830 array[i].str ? array[i].str : "(null)",
1831 array[i].chrs ? array[i].chrs : "(null)",
1832 rv);
1833 return PR_FALSE;
1834 }
1835 }
1836 else
1837 {
1838 if( (char *)0 == rv )
1839 {
1840 printf("FAIL %d: %s,%s -> null, not +%lu\n", i,
1841 array[i].str ? array[i].str : "(null)",
1842 array[i].chrs ? array[i].chrs : "(null)",
1843 array[i].off);
1844 return PR_FALSE;
1845 }
1846
1847 if( &array[i].str[ array[i].off ] != rv )
1848 {
1849 printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i,
1850 array[i].str ? array[i].str : "(null)",
1851 array[i].chrs ? array[i].chrs : "(null)",
1852 rv, array[i].str, array[i].off);
1853 return PR_FALSE;
1854 }
1855 }
1856 }
1857
1858 printf("PASS\n");
1859 return PR_TRUE;
1860 }
1861
1862 /* PL_strnpbrk */
1863 PRBool test_021(void)
1864 {
1865 static struct
1866 {
1867 const char *str;
1868 const char *chrs;
1869 PRUint32 max;
1870 PRBool ret;
1871 PRUint32 off;
1872 } array[] =
1873 {
1874 { (const char *)0, (const char *)0, 3, PR_FALSE, 0 },
1875 { (const char *)0, "abc", 3, PR_FALSE, 0 },
1876 { "abc", (const char *)0, 3, PR_FALSE, 0 },
1877 { "abcdefg", "", 3, PR_FALSE, 0 },
1878 { "", "aeiou", 3, PR_FALSE, 0 },
1879 { "abcdefg", "ae", 0, PR_FALSE, 0 },
1880 { "abcdefg", "ae", 1, PR_TRUE, 0 },
1881 { "abcdefg", "ae", 4, PR_TRUE, 0 },
1882 { "abcdefg", "ae", 5, PR_TRUE, 0 },
1883 { "abcdefg", "ae", 6, PR_TRUE, 0 },
1884 { "abcdefg", "ei", 4, PR_FALSE, 0 },
1885 { "abcdefg", "io", 10, PR_FALSE, 0 },
1886 { "abcdefg", "bcd", 2, PR_TRUE, 1 },
1887 { "abcdefg", "cbd", 2, PR_TRUE, 1 },
1888 { "abcdefg", "dbc", 2, PR_TRUE, 1 },
1889 { "abcdefg", "ghi", 6, PR_FALSE, 0 },
1890 { "abcdefg", "ghi", 7, PR_TRUE, 6 },
1891 { "abcdefg", "AE", 9, PR_FALSE, 0 },
1892 { "abcdefg", "EI", 9, PR_FALSE, 0 },
1893 { "abcdefg", "IO", 9, PR_FALSE, 0 },
1894 { "abcdefg", "BCD", 9, PR_FALSE, 0 },
1895 { "abcdefg", "CBD", 9, PR_FALSE, 0 },
1896 { "abcdefg", "DBC", 9, PR_FALSE, 0 },
1897 { "abcdefg", "GHI", 9, PR_FALSE, 0 },
1898 { "abcdefgabcdefg", "ae", 10, PR_TRUE, 0 },
1899 { "abcdefgabcdefg", "ei", 10, PR_TRUE, 4 },
1900 { "abcdefgabcdefg", "io", 10, PR_FALSE, 0 },
1901 { "abcdefgabcdefg", "bcd", 10, PR_TRUE, 1 },
1902 { "abcdefgabcdefg", "cbd", 10, PR_TRUE, 1 },
1903 { "abcdefgabcdefg", "dbc", 10, PR_TRUE, 1 },
1904 { "abcdefgabcdefg", "ghi", 10, PR_TRUE, 6 },
1905 { "abcdefgabcdefg", "AE", 10, PR_FALSE, 0 },
1906 { "abcdefgabcdefg", "EI", 10, PR_FALSE, 0 },
1907 { "abcdefgabcdefg", "IO", 10, PR_FALSE, 0 },
1908 { "abcdefgabcdefg", "BCD", 10, PR_FALSE, 0 },
1909 { "abcdefgabcdefg", "CBD", 10, PR_FALSE, 0 },
1910 { "abcdefgabcdefg", "DBC", 10, PR_FALSE, 0 },
1911 { "abcdefgabcdefg", "GHI", 10, PR_FALSE, 0 }
1912 };
1913
1914 int i;
1915
1916 printf("Test 021 (PL_strnpbrk) ..."); fflush(stdout);
1917
1918 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1919 {
1920 char *rv = PL_strnpbrk(array[i].str, array[i].chrs, array[i].max);
1921
1922 if( PR_FALSE == array[i].ret )
1923 {
1924 if( (char *)0 != rv )
1925 {
1926 printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i,
1927 array[i].str ? array[i].str : "(null)",
1928 array[i].chrs ? array[i].chrs : "(null)",
1929 array[i].max, rv);
1930 return PR_FALSE;
1931 }
1932 }
1933 else
1934 {
1935 if( (char *)0 == rv )
1936 {
1937 printf("FAIL %d: %s,%s/%lu -> null, not +%lu\n", i,
1938 array[i].str ? array[i].str : "(null)",
1939 array[i].chrs ? array[i].chrs : "(null)",
1940 array[i].max, array[i].off);
1941 return PR_FALSE;
1942 }
1943
1944 if( &array[i].str[ array[i].off ] != rv )
1945 {
1946 printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i,
1947 array[i].str ? array[i].str : "(null)",
1948 array[i].chrs ? array[i].chrs : "(null)",
1949 array[i].max, rv, array[i].str, array[i].off);
1950 return PR_FALSE;
1951 }
1952 }
1953 }
1954
1955 printf("PASS\n");
1956 return PR_TRUE;
1957 }
1958
1959 /* PL_strnprbrk */
1960 PRBool test_022(void)
1961 {
1962 static struct
1963 {
1964 const char *str;
1965 const char *chrs;
1966 PRUint32 max;
1967 PRBool ret;
1968 PRUint32 off;
1969 } array[] =
1970 {
1971 { (const char *)0, (const char *)0, 3, PR_FALSE, 0 },
1972 { (const char *)0, "abc", 3, PR_FALSE, 0 },
1973 { "abc", (const char *)0, 3, PR_FALSE, 0 },
1974 { "abcdefg", "", 3, PR_FALSE, 0 },
1975 { "", "aeiou", 3, PR_FALSE, 0 },
1976 { "abcdefg", "ae", 0, PR_FALSE, 0 },
1977 { "abcdefg", "ae", 1, PR_TRUE, 0 },
1978 { "abcdefg", "ae", 4, PR_TRUE, 0 },
1979 { "abcdefg", "ae", 5, PR_TRUE, 4 },
1980 { "abcdefg", "ae", 6, PR_TRUE, 4 },
1981 { "abcdefg", "ei", 4, PR_FALSE, 0 },
1982 { "abcdefg", "io", 10, PR_FALSE, 0 },
1983 { "abcdefg", "bcd", 2, PR_TRUE, 1 },
1984 { "abcdefg", "cbd", 2, PR_TRUE, 1 },
1985 { "abcdefg", "dbc", 2, PR_TRUE, 1 },
1986 { "abcdefg", "bcd", 3, PR_TRUE, 2 },
1987 { "abcdefg", "cbd", 3, PR_TRUE, 2 },
1988 { "abcdefg", "dbc", 3, PR_TRUE, 2 },
1989 { "abcdefg", "bcd", 5, PR_TRUE, 3 },
1990 { "abcdefg", "cbd", 5, PR_TRUE, 3 },
1991 { "abcdefg", "dbc", 5, PR_TRUE, 3 },
1992 { "abcdefg", "bcd", 15, PR_TRUE, 3 },
1993 { "abcdefg", "cbd", 15, PR_TRUE, 3 },
1994 { "abcdefg", "dbc", 15, PR_TRUE, 3 },
1995 { "abcdefg", "ghi", 6, PR_FALSE, 0 },
1996 { "abcdefg", "ghi", 7, PR_TRUE, 6 },
1997 { "abcdefg", "AE", 9, PR_FALSE, 0 },
1998 { "abcdefg", "EI", 9, PR_FALSE, 0 },
1999 { "abcdefg", "IO", 9, PR_FALSE, 0 },
2000 { "abcdefg", "BCD", 9, PR_FALSE, 0 },
2001 { "abcdefg", "CBD", 9, PR_FALSE, 0 },
2002 { "abcdefg", "DBC", 9, PR_FALSE, 0 },
2003 { "abcdefg", "GHI", 9, PR_FALSE, 0 },
2004 { "abcdefgabcdefg", "ae", 10, PR_TRUE, 7 },
2005 { "abcdefgabcdefg", "ei", 10, PR_TRUE, 4 },
2006 { "abcdefgabcdefg", "io", 10, PR_FALSE, 0 },
2007 { "abcdefgabcdefg", "bcd", 10, PR_TRUE, 9 },
2008 { "abcdefgabcdefg", "cbd", 10, PR_TRUE, 9 },
2009 { "abcdefgabcdefg", "dbc", 10, PR_TRUE, 9 },
2010 { "abcdefgabcdefg", "ghi", 10, PR_TRUE, 6 },
2011 { "abcdefgabcdefg", "AE", 10, PR_FALSE, 0 },
2012 { "abcdefgabcdefg", "EI", 10, PR_FALSE, 0 },
2013 { "abcdefgabcdefg", "IO", 10, PR_FALSE, 0 },
2014 { "abcdefgabcdefg", "BCD", 10, PR_FALSE, 0 },
2015 { "abcdefgabcdefg", "CBD", 10, PR_FALSE, 0 },
2016 { "abcdefgabcdefg", "DBC", 10, PR_FALSE, 0 },
2017 { "abcdefgabcdefg", "GHI", 10, PR_FALSE, 0 }
2018 };
2019
2020 int i;
2021
2022 printf("Test 022 (PL_strnprbrk) ..."); fflush(stdout);
2023
2024 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
2025 {
2026 char *rv = PL_strnprbrk(array[i].str, array[i].chrs, array[i].max);
2027
2028 if( PR_FALSE == array[i].ret )
2029 {
2030 if( (char *)0 != rv )
2031 {
2032 printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i,
2033 array[i].str ? array[i].str : "(null)",
2034 array[i].chrs ? array[i].chrs : "(null)",
2035 array[i].max, rv);
2036 return PR_FALSE;
2037 }
2038 }
2039 else
2040 {
2041 if( (char *)0 == rv )
2042 {
2043 printf("FAIL %d: %s,%s/%lu -> null, not +%lu\n", i,
2044 array[i].str ? array[i].str : "(null)",
2045 array[i].chrs ? array[i].chrs : "(null)",
2046 array[i].max, array[i].off);
2047 return PR_FALSE;
2048 }
2049
2050 if( &array[i].str[ array[i].off ] != rv )
2051 {
2052 printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i,
2053 array[i].str ? array[i].str : "(null)",
2054 array[i].chrs ? array[i].chrs : "(null)",
2055 array[i].max, rv, array[i].str, array[i].off);
2056 return PR_FALSE;
2057 }
2058 }
2059 }
2060
2061 printf("PASS\n");
2062 return PR_TRUE;
2063 }
2064
2065 /* PL_strstr */
2066 PRBool test_023(void)
2067 {
2068 static struct
2069 {
2070 const char *str;
2071 const char *sub;
2072 PRBool ret;
2073 PRUint32 off;
2074 } array[] =
2075 {
2076 { (const char *)0, (const char *)0, PR_FALSE, 0 },
2077 { (const char *)0, "blah", PR_FALSE, 0 },
2078 { "blah-de-blah", (const char *)0, PR_FALSE, 0 },
2079 { "blah-de-blah", "blah", PR_TRUE, 0 },
2080 { "", "blah", PR_FALSE, 0 },
2081 { "blah-de-blah", "", PR_FALSE, 0 },
2082 { "abcdefg", "a", PR_TRUE, 0 },
2083 { "abcdefg", "c", PR_TRUE, 2 },
2084 { "abcdefg", "e", PR_TRUE, 4 },
2085 { "abcdefg", "g", PR_TRUE, 6 },
2086 { "abcdefg", "i", PR_FALSE, 0 },
2087 { "abcdefg", "ab", PR_TRUE, 0 },
2088 { "abcdefg", "cd", PR_TRUE, 2 },
2089 { "abcdefg", "ef", PR_TRUE, 4 },
2090 { "abcdefg", "gh", PR_FALSE, 0 },
2091 { "abcdabc", "bc", PR_TRUE, 1 },
2092 { "abcdefg", "abcdefg", PR_TRUE, 0 },
2093 { "abcdefgabcdefg", "a", PR_TRUE, 0 },
2094 { "abcdefgabcdefg", "c", PR_TRUE, 2 },
2095 { "abcdefgabcdefg", "e", PR_TRUE, 4 },
2096 { "abcdefgabcdefg", "g", PR_TRUE, 6 },
2097 { "abcdefgabcdefg", "i", PR_FALSE, 0 },
2098 { "abcdefgabcdefg", "ab", PR_TRUE, 0 },
2099 { "abcdefgabcdefg", "cd", PR_TRUE, 2 },
2100 { "abcdefgabcdefg", "ef", PR_TRUE, 4 },
2101 { "abcdefgabcdefg", "gh", PR_FALSE, 0 },
2102 { "abcdabcabcdabc", "bc", PR_TRUE, 1 },
2103 { "abcdefgabcdefg", "abcdefg", PR_TRUE, 0 },
2104 { "ABCDEFG", "a", PR_FALSE, 0 },
2105 { "ABCDEFG", "c", PR_FALSE, 0 },
2106 { "ABCDEFG", "e", PR_FALSE, 0 },
2107 { "ABCDEFG", "g", PR_FALSE, 0 },
2108 { "ABCDEFG", "i", PR_FALSE, 0 },
2109 { "ABCDEFG", "ab", PR_FALSE, 0 },
2110 { "ABCDEFG", "cd", PR_FALSE, 0 },
2111 { "ABCDEFG", "ef", PR_FALSE, 0 },
2112 { "ABCDEFG", "gh", PR_FALSE, 0 },
2113 { "ABCDABC", "bc", PR_FALSE, 0 },
2114 { "ABCDEFG", "abcdefg", PR_FALSE, 0 },
2115 { "ABCDEFGABCDEFG", "a", PR_FALSE, 0 },
2116 { "ABCDEFGABCDEFG", "c", PR_FALSE, 0 },
2117 { "ABCDEFGABCDEFG", "e", PR_FALSE, 0 },
2118 { "ABCDEFGABCDEFG", "g", PR_FALSE, 0 },
2119 { "ABCDEFGABCDEFG", "i", PR_FALSE, 0 },
2120 { "ABCDEFGABCDEFG", "ab", PR_FALSE, 0 },
2121 { "ABCDEFGABCDEFG", "cd", PR_FALSE, 0 },
2122 { "ABCDEFGABCDEFG", "ef", PR_FALSE, 0 },
2123 { "ABCDEFGABCDEFG", "gh", PR_FALSE, 0 },
2124 { "ABCDABCABCDABC", "bc", PR_FALSE, 0 },
2125 { "ABCDEFGABCDEFG", "abcdefg", PR_FALSE, 0 }
2126 };
2127
2128 int i;
2129
2130 printf("Test 023 (PL_strstr) ..."); fflush(stdout);
2131
2132 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
2133 {
2134 char *rv = PL_strstr(array[i].str, array[i].sub);
2135
2136 if( PR_FALSE == array[i].ret )
2137 {
2138 if( (char *)0 != rv )
2139 {
2140 printf("FAIL %d: %s,%s -> %.32s, not null\n", i,
2141 array[i].str ? array[i].str : "(null)",
2142 array[i].sub ? array[i].sub : "(null)",
2143 rv);
2144 return PR_FALSE;
2145 }
2146 }
2147 else
2148 {
2149 if( (char *)0 == rv )
2150 {
2151 printf("FAIL %d: %s,%s -> null, not 0x%x+%lu\n", i,
2152 array[i].str ? array[i].str : "(null)",
2153 array[i].sub ? array[i].sub : "(null)",
2154 array[i].str, array[i].off);
2155 return PR_FALSE;
2156 }
2157
2158 if( &array[i].str[ array[i].off ] != rv )
2159 {
2160 printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i,
2161 array[i].str ? array[i].str : "(null)",
2162 array[i].sub ? array[i].sub : "(null)",
2163 rv, array[i].str, array[i].off);
2164 return PR_FALSE;
2165 }
2166 }
2167 }
2168
2169 printf("PASS\n");
2170 return PR_TRUE;
2171 }
2172
2173 /* PL_strrstr */
2174 PRBool test_024(void)
2175 {
2176 static struct
2177 {
2178 const char *str;
2179 const char *sub;
2180 PRBool ret;
2181 PRUint32 off;
2182 } array[] =
2183 {
2184 { (const char *)0, (const char *)0, PR_FALSE, 0 },
2185 { (const char *)0, "blah", PR_FALSE, 0 },
2186 { "blah-de-blah", (const char *)0, PR_FALSE, 0 },
2187 { "blah-de-blah", "blah", PR_TRUE, 8 },
2188 { "", "blah", PR_FALSE, 0 },
2189 { "blah-de-blah", "", PR_FALSE, 0 },
2190 { "abcdefg", "a", PR_TRUE, 0 },
2191 { "abcdefg", "c", PR_TRUE, 2 },
2192 { "abcdefg", "e", PR_TRUE, 4 },
2193 { "abcdefg", "g", PR_TRUE, 6 },
2194 { "abcdefg", "i", PR_FALSE, 0 },
2195 { "abcdefg", "ab", PR_TRUE, 0 },
2196 { "abcdefg", "cd", PR_TRUE, 2 },
2197 { "abcdefg", "ef", PR_TRUE, 4 },
2198 { "abcdefg", "gh", PR_FALSE, 0 },
2199 { "abcdabc", "bc", PR_TRUE, 5 },
2200 { "abcdefg", "abcdefg", PR_TRUE, 0 },
2201 { "abcdefgabcdefg", "a", PR_TRUE, 7 },
2202 { "abcdefgabcdefg", "c", PR_TRUE, 9 },
2203 { "abcdefgabcdefg", "e", PR_TRUE, 11 },
2204 { "abcdefgabcdefg", "g", PR_TRUE, 13 },
2205 { "abcdefgabcdefg", "i", PR_FALSE, 0 },
2206 { "abcdefgabcdefg", "ab", PR_TRUE, 7 },
2207 { "abcdefgabcdefg", "cd", PR_TRUE, 9 },
2208 { "abcdefgabcdefg", "ef", PR_TRUE, 11 },
2209 { "abcdefgabcdefg", "gh", PR_FALSE, 0 },
2210 { "abcdabcabcdabc", "bc", PR_TRUE, 12 },
2211 { "abcdefgabcdefg", "abcdefg", PR_TRUE, 7 },
2212 { "ABCDEFG", "a", PR_FALSE, 0 },
2213 { "ABCDEFG", "c", PR_FALSE, 0 },
2214 { "ABCDEFG", "e", PR_FALSE, 0 },
2215 { "ABCDEFG", "g", PR_FALSE, 0 },
2216 { "ABCDEFG", "i", PR_FALSE, 0 },
2217 { "ABCDEFG", "ab", PR_FALSE, 0 },
2218 { "ABCDEFG", "cd", PR_FALSE, 0 },
2219 { "ABCDEFG", "ef", PR_FALSE, 0 },
2220 { "ABCDEFG", "gh", PR_FALSE, 0 },
2221 { "ABCDABC", "bc", PR_FALSE, 0 },
2222 { "ABCDEFG", "abcdefg", PR_FALSE, 0 },
2223 { "ABCDEFGABCDEFG", "a", PR_FALSE, 0 },
2224 { "ABCDEFGABCDEFG", "c", PR_FALSE, 0 },
2225 { "ABCDEFGABCDEFG", "e", PR_FALSE, 0 },
2226 { "ABCDEFGABCDEFG", "g", PR_FALSE, 0 },
2227 { "ABCDEFGABCDEFG", "i", PR_FALSE, 0 },
2228 { "ABCDEFGABCDEFG", "ab", PR_FALSE, 0 },
2229 { "ABCDEFGABCDEFG", "cd", PR_FALSE, 0 },
2230 { "ABCDEFGABCDEFG", "ef", PR_FALSE, 0 },
2231 { "ABCDEFGABCDEFG", "gh", PR_FALSE, 0 },
2232 { "ABCDABCABCDABC", "bc", PR_FALSE, 0 },
2233 { "ABCDEFGABCDEFG", "abcdefg", PR_FALSE, 0 }
2234 };
2235
2236 int i;
2237
2238 printf("Test 024 (PL_strrstr) ..."); fflush(stdout);
2239
2240 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
2241 {
2242 char *rv = PL_strrstr(array[i].str, array[i].sub);
2243
2244 if( PR_FALSE == array[i].ret )
2245 {
2246 if( (char *)0 != rv )
2247 {
2248 printf("FAIL %d: %s,%s -> %.32s, not null\n", i,
2249 array[i].str ? array[i].str : "(null)",
2250 array[i].sub ? array[i].sub : "(null)",
2251 rv);
2252 return PR_FALSE;
2253 }
2254 }
2255 else
2256 {
2257 if( (char *)0 == rv )
2258 {
2259 printf("FAIL %d: %s,%s -> null, not 0x%x+%lu\n", i,
2260 array[i].str ? array[i].str : "(null)",
2261 array[i].sub ? array[i].sub : "(null)",
2262 array[i].str, array[i].off);
2263 return PR_FALSE;
2264 }
2265
2266 if( &array[i].str[ array[i].off ] != rv )
2267 {
2268 printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i,
2269 array[i].str ? array[i].str : "(null)",
2270 array[i].sub ? array[i].sub : "(null)",
2271 rv, array[i].str, array[i].off);
2272 return PR_FALSE;
2273 }
2274 }
2275 }
2276
2277 printf("PASS\n");
2278 return PR_TRUE;
2279 }
2280
2281 /* PL_strnstr */
2282 PRBool test_025(void)
2283 {
2284 static struct
2285 {
2286 const char *str;
2287 const char *sub;
2288 PRUint32 max;
2289 PRBool ret;
2290 PRUint32 off;
2291 } array[] =
2292 {
2293 { (const char *)0, (const char *)0, 12, PR_FALSE, 0 },
2294 { (const char *)0, "blah", 12, PR_FALSE, 0 },
2295 { "blah-de-blah", (const char *)0, 12, PR_FALSE, 0 },
2296 { "blah-de-blah", "blah", 0, PR_FALSE, 0 },
2297 { "blah-de-blah", "blah", 2, PR_FALSE, 0 },
2298 { "blah-de-blah", "blah", 3, PR_FALSE, 0 },
2299 { "blah-de-blah", "blah", 4, PR_TRUE, 0 },
2300 { "blah-de-blah", "blah", 5, PR_TRUE, 0 },
2301 { "blah-de-blah", "blah", 12, PR_TRUE, 0 },
2302 { "", "blah", 12, PR_FALSE, 0 },
2303 { "blah-de-blah", "", 12, PR_FALSE, 0 },
2304 { "abcdefg", "a", 5, PR_TRUE, 0 },
2305 { "abcdefg", "c", 5, PR_TRUE, 2 },
2306 { "abcdefg", "e", 5, PR_TRUE, 4 },
2307 { "abcdefg", "g", 5, PR_FALSE, 0 },
2308 { "abcdefg", "i", 5, PR_FALSE, 0 },
2309 { "abcdefg", "ab", 5, PR_TRUE, 0 },
2310 { "abcdefg", "cd", 5, PR_TRUE, 2 },
2311 { "abcdefg", "ef", 5, PR_FALSE, 0 },
2312 { "abcdefg", "gh", 5, PR_FALSE, 0 },
2313 { "abcdabc", "bc", 5, PR_TRUE, 1 },
2314 { "abcdabc", "bc", 6, PR_TRUE, 1 },
2315 { "abcdabc", "bc", 7, PR_TRUE, 1 },
2316 { "abcdefg", "abcdefg", 6, PR_FALSE, 0 },
2317 { "abcdefg", "abcdefg", 7, PR_TRUE, 0 },
2318 { "abcdefg", "abcdefg", 8, PR_TRUE, 0 },
2319 { "abcdefgabcdefg", "a", 12, PR_TRUE, 0 },
2320 { "abcdefgabcdefg", "c", 12, PR_TRUE, 2 },
2321 { "abcdefgabcdefg", "e", 12, PR_TRUE, 4 },
2322 { "abcdefgabcdefg", "g", 12, PR_TRUE, 6 },
2323 { "abcdefgabcdefg", "i", 12, PR_FALSE, 0 },
2324 { "abcdefgabcdefg", "ab", 12, PR_TRUE, 0 },
2325 { "abcdefgabcdefg", "cd", 12, PR_TRUE, 2 },
2326 { "abcdefgabcdefg", "ef", 12, PR_TRUE, 4 },
2327 { "abcdefgabcdefg", "gh", 12, PR_FALSE, 0 },
2328 { "abcdabcabcdabc", "bc", 5, PR_TRUE, 1 },
2329 { "abcdabcabcdabc", "bc", 6, PR_TRUE, 1 },
2330 { "abcdabcabcdabc", "bc", 7, PR_TRUE, 1 },
2331 { "abcdefgabcdefg", "abcdefg", 6, PR_FALSE, 0 },
2332 { "abcdefgabcdefg", "abcdefg", 7, PR_TRUE, 0 },
2333 { "abcdefgabcdefg", "abcdefg", 8, PR_TRUE, 0 },
2334 { "ABCDEFG", "a", 5, PR_FALSE, 0 },
2335 { "ABCDEFG", "c", 5, PR_FALSE, 0 },
2336 { "ABCDEFG", "e", 5, PR_FALSE, 0 },
2337 { "ABCDEFG", "g", 5, PR_FALSE, 0 },
2338 { "ABCDEFG", "i", 5, PR_FALSE, 0 },
2339 { "ABCDEFG", "ab", 5, PR_FALSE, 0 },
2340 { "ABCDEFG", "cd", 5, PR_FALSE, 0 },
2341 { "ABCDEFG", "ef", 5, PR_FALSE, 0 },
2342 { "ABCDEFG", "gh", 5, PR_FALSE, 0 },
2343 { "ABCDABC", "bc", 5, PR_FALSE, 0 },
2344 { "ABCDABC", "bc", 6, PR_FALSE, 0 },
2345 { "ABCDABC", "bc", 7, PR_FALSE, 0 },
2346 { "ABCDEFG", "abcdefg", 6, PR_FALSE, 0 },
2347 { "ABCDEFG", "abcdefg", 7, PR_FALSE, 0 },
2348 { "ABCDEFG", "abcdefg", 8, PR_FALSE, 0 },
2349 { "ABCDEFGABCDEFG", "a", 12, PR_FALSE, 0 },
2350 { "ABCDEFGABCDEFG", "c", 12, PR_FALSE, 0 },
2351 { "ABCDEFGABCDEFG", "e", 12, PR_FALSE, 0 },
2352 { "ABCDEFGABCDEFG", "g", 12, PR_FALSE, 0 },
2353 { "ABCDEFGABCDEFG", "i", 12, PR_FALSE, 0 },
2354 { "ABCDEFGABCDEFG", "ab", 12, PR_FALSE, 0 },
2355 { "ABCDEFGABCDEFG", "cd", 12, PR_FALSE, 0 },
2356 { "ABCDEFGABCDEFG", "ef", 12, PR_FALSE, 0 },
2357 { "ABCDEFGABCDEFG", "gh", 12, PR_FALSE, 0 },
2358 { "ABCDABCABCDABC", "bc", 5, PR_FALSE, 0 },
2359 { "ABCDABCABCDABC", "bc", 6, PR_FALSE, 0 },
2360 { "ABCDABCABCDABC", "bc", 7, PR_FALSE, },
2361 { "ABCDEFGABCDEFG", "abcdefg", 6, PR_FALSE, 0 },
2362 { "ABCDEFGABCDEFG", "abcdefg", 7, PR_FALSE, 0 },
2363 { "ABCDEFGABCDEFG", "abcdefg", 8, PR_FALSE, 0 }
2364 };
2365
2366 int i;
2367
2368 printf("Test 025 (PL_strnstr) ..."); fflush(stdout);
2369
2370 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
2371 {
2372 char *rv = PL_strnstr(array[i].str, array[i].sub, array[i].max);
2373
2374 if( PR_FALSE == array[i].ret )
2375 {
2376 if( (char *)0 != rv )
2377 {
2378 printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i,
2379 array[i].str ? array[i].str : "(null)",
2380 array[i].sub ? array[i].sub : "(null)",
2381 array[i].max, rv);
2382 return PR_FALSE;
2383 }
2384 }
2385 else
2386 {
2387 if( (char *)0 == rv )
2388 {
2389 printf("FAIL %d: %s,%s/%lu -> null, not 0x%x+%lu\n", i,
2390 array[i].str ? array[i].str : "(null)",
2391 array[i].sub ? array[i].sub : "(null)",
2392 array[i].max, array[i].str, array[i].off);
2393 return PR_FALSE;
2394 }
2395
2396 if( &array[i].str[ array[i].off ] != rv )
2397 {
2398 printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i,
2399 array[i].str ? array[i].str : "(null)",
2400 array[i].sub ? array[i].sub : "(null)",
2401 array[i].max, rv, array[i].str, array[i].off);
2402 return PR_FALSE;
2403 }
2404 }
2405 }
2406
2407 printf("PASS\n");
2408 return PR_TRUE;
2409 }
2410
2411 /* PL_strnrstr */
2412 PRBool test_026(void)
2413 {
2414 static struct
2415 {
2416 const char *str;
2417 const char *sub;
2418 PRUint32 max;
2419 PRBool ret;
2420 PRUint32 off;
2421 } array[] =
2422 {
2423 { (const char *)0, (const char *)0, 12, PR_FALSE, 0 },
2424 { (const char *)0, "blah", 12, PR_FALSE, 0 },
2425 { "blah-de-blah", (const char *)0, 12, PR_FALSE, 0 },
2426 { "blah-de-blah", "blah", 0, PR_FALSE, 0 },
2427 { "blah-de-blah", "blah", 2, PR_FALSE, 0 },
2428 { "blah-de-blah", "blah", 3, PR_FALSE, 0 },
2429 { "blah-de-blah", "blah", 4, PR_TRUE, 0 },
2430 { "blah-de-blah", "blah", 5, PR_TRUE, 0 },
2431 { "blah-de-blah", "blah", 11, PR_TRUE, 0 },
2432 { "blah-de-blah", "blah", 12, PR_TRUE, 8 },
2433 { "blah-de-blah", "blah", 13, PR_TRUE, 8 },
2434 { "", "blah", 12, PR_FALSE, 0 },
2435 { "blah-de-blah", "", 12, PR_FALSE, 0 },
2436 { "abcdefg", "a", 5, PR_TRUE, 0 },
2437 { "abcdefg", "c", 5, PR_TRUE, 2 },
2438 { "abcdefg", "e", 5, PR_TRUE, 4 },
2439 { "abcdefg", "g", 5, PR_FALSE, 0 },
2440 { "abcdefg", "i", 5, PR_FALSE, 0 },
2441 { "abcdefg", "ab", 5, PR_TRUE, 0 },
2442 { "abcdefg", "cd", 5, PR_TRUE, 2 },
2443 { "abcdefg", "ef", 5, PR_FALSE, 0 },
2444 { "abcdefg", "gh", 5, PR_FALSE, 0 },
2445 { "abcdabc", "bc", 5, PR_TRUE, 1 },
2446 { "abcdabc", "bc", 6, PR_TRUE, 1 },
2447 { "abcdabc", "bc", 7, PR_TRUE, 5 },
2448 { "abcdefg", "abcdefg", 6, PR_FALSE, 0 },
2449 { "abcdefg", "abcdefg", 7, PR_TRUE, 0 },
2450 { "abcdefg", "abcdefg", 8, PR_TRUE, 0 },
2451 { "abcdefgabcdefg", "a", 12, PR_TRUE, 7 },
2452 { "abcdefgabcdefg", "c", 12, PR_TRUE, 9 },
2453 { "abcdefgabcdefg", "e", 12, PR_TRUE, 11 },
2454 { "abcdefgabcdefg", "g", 12, PR_TRUE, 6 },
2455 { "abcdefgabcdefg", "i", 12, PR_FALSE, 0 },
2456 { "abcdefgabcdefg", "ab", 12, PR_TRUE, 7 },
2457 { "abcdefgabcdefg", "cd", 12, PR_TRUE, 9 },
2458 { "abcdefgabcdefg", "ef", 12, PR_TRUE, 4 },
2459 { "abcdefgabcdefg", "gh", 12, PR_FALSE, 0 },
2460 { "abcdabcabcdabc", "bc", 12, PR_TRUE, 8 },
2461 { "abcdabcabcdabc", "bc", 13, PR_TRUE, 8 },
2462 { "abcdabcabcdabc", "bc", 14, PR_TRUE, 12 },
2463 { "abcdefgabcdefg", "abcdefg", 13, PR_TRUE, 0 },
2464 { "abcdefgabcdefg", "abcdefg", 14, PR_TRUE, 7 },
2465 { "abcdefgabcdefg", "abcdefg", 15, PR_TRUE, 7 },
2466 { "ABCDEFG", "a", 5, PR_FALSE, 0 },
2467 { "ABCDEFG", "c", 5, PR_FALSE, 0 },
2468 { "ABCDEFG", "e", 5, PR_FALSE, 0 },
2469 { "ABCDEFG", "g", 5, PR_FALSE, 0 },
2470 { "ABCDEFG", "i", 5, PR_FALSE, 0 },
2471 { "ABCDEFG", "ab", 5, PR_FALSE, 0 },
2472 { "ABCDEFG", "cd", 5, PR_FALSE, 0 },
2473 { "ABCDEFG", "ef", 5, PR_FALSE, 0 },
2474 { "ABCDEFG", "gh", 5, PR_FALSE, 0 },
2475 { "ABCDABC", "bc", 5, PR_FALSE, 0 },
2476 { "ABCDABC", "bc", 6, PR_FALSE, 0 },
2477 { "ABCDABC", "bc", 7, PR_FALSE, 0 },
2478 { "ABCDEFG", "abcdefg", 6, PR_FALSE, 0 },
2479 { "ABCDEFG", "abcdefg", 7, PR_FALSE, 0 },
2480 { "ABCDEFG", "abcdefg", 8, PR_FALSE, 0 },
2481 { "ABCDEFGABCDEFG", "a", 12, PR_FALSE, 0 },
2482 { "ABCDEFGABCDEFG", "c", 12, PR_FALSE, 0 },
2483 { "ABCDEFGABCDEFG", "e", 12, PR_FALSE, 0 },
2484 { "ABCDEFGABCDEFG", "g", 12, PR_FALSE, 0 },
2485 { "ABCDEFGABCDEFG", "i", 12, PR_FALSE, 0 },
2486 { "ABCDEFGABCDEFG", "ab", 12, PR_FALSE, 0 },
2487 { "ABCDEFGABCDEFG", "cd", 12, PR_FALSE, 0 },
2488 { "ABCDEFGABCDEFG", "ef", 12, PR_FALSE, 0 },
2489 { "ABCDEFGABCDEFG", "gh", 12, PR_FALSE, 0 },
2490 { "ABCDABCABCDABC", "bc", 12, PR_FALSE, 0 },
2491 { "ABCDABCABCDABC", "bc", 13, PR_FALSE, 0 },
2492 { "ABCDABCABCDABC", "bc", 14, PR_FALSE, 0 },
2493 { "ABCDEFGABCDEFG", "abcdefg", 13, PR_FALSE, 0 },
2494 { "ABCDEFGABCDEFG", "abcdefg", 14, PR_FALSE, 0 },
2495 { "ABCDEFGABCDEFG", "abcdefg", 15, PR_FALSE, 0 }
2496 };
2497
2498 int i;
2499
2500 printf("Test 026 (PL_strnrstr) ..."); fflush(stdout);
2501
2502 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
2503 {
2504 char *rv = PL_strnrstr(array[i].str, array[i].sub, array[i].max);
2505
2506 if( PR_FALSE == array[i].ret )
2507 {
2508 if( (char *)0 != rv )
2509 {
2510 printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i,
2511 array[i].str ? array[i].str : "(null)",
2512 array[i].sub ? array[i].sub : "(null)",
2513 array[i].max, rv);
2514 return PR_FALSE;
2515 }
2516 }
2517 else
2518 {
2519 if( (char *)0 == rv )
2520 {
2521 printf("FAIL %d: %s,%s/%lu -> null, not 0x%x+%lu\n", i,
2522 array[i].str ? array[i].str : "(null)",
2523 array[i].sub ? array[i].sub : "(null)",
2524 array[i].max, array[i].str, array[i].off);
2525 return PR_FALSE;
2526 }
2527
2528 if( &array[i].str[ array[i].off ] != rv )
2529 {
2530 printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i,
2531 array[i].str ? array[i].str : "(null)",
2532 array[i].sub ? array[i].sub : "(null)",
2533 array[i].max, rv, array[i].str, array[i].off);
2534 return PR_FALSE;
2535 }
2536 }
2537 }
2538
2539 printf("PASS\n");
2540 return PR_TRUE;
2541 }
2542
2543 /* PL_strcasestr */
2544 PRBool test_027(void)
2545 {
2546 static struct
2547 {
2548 const char *str;
2549 const char *sub;
2550 PRBool ret;
2551 PRUint32 off;
2552 } array[] =
2553 {
2554 { (const char *)0, (const char *)0, PR_FALSE, 0 },
2555 { (const char *)0, "blah", PR_FALSE, 0 },
2556 { "blah-de-blah", (const char *)0, PR_FALSE, 0 },
2557 { "blah-de-blah", "blah", PR_TRUE, 0 },
2558 { "", "blah", PR_FALSE, 0 },
2559 { "blah-de-blah", "", PR_FALSE, 0 },
2560 { "abcdefg", "a", PR_TRUE, 0 },
2561 { "abcdefg", "c", PR_TRUE, 2 },
2562 { "abcdefg", "e", PR_TRUE, 4 },
2563 { "abcdefg", "g", PR_TRUE, 6 },
2564 { "abcdefg", "i", PR_FALSE, 0 },
2565 { "abcdefg", "ab", PR_TRUE, 0 },
2566 { "abcdefg", "cd", PR_TRUE, 2 },
2567 { "abcdefg", "ef", PR_TRUE, 4 },
2568 { "abcdefg", "gh", PR_FALSE, 0 },
2569 { "abcdabc", "bc", PR_TRUE, 1 },
2570 { "abcdefg", "abcdefg", PR_TRUE, 0 },
2571 { "abcdefgabcdefg", "a", PR_TRUE, 0 },
2572 { "abcdefgabcdefg", "c", PR_TRUE, 2 },
2573 { "abcdefgabcdefg", "e", PR_TRUE, 4 },
2574 { "abcdefgabcdefg", "g", PR_TRUE, 6 },
2575 { "abcdefgabcdefg", "i", PR_FALSE, 0 },
2576 { "abcdefgabcdefg", "ab", PR_TRUE, 0 },
2577 { "abcdefgabcdefg", "cd", PR_TRUE, 2 },
2578 { "abcdefgabcdefg", "ef", PR_TRUE, 4 },
2579 { "abcdefgabcdefg", "gh", PR_FALSE, 0 },
2580 { "abcdabcabcdabc", "bc", PR_TRUE, 1 },
2581 { "abcdefgabcdefg", "abcdefg", PR_TRUE, 0 },
2582 { "ABCDEFG", "a", PR_TRUE, 0 },
2583 { "ABCDEFG", "c", PR_TRUE, 2 },
2584 { "ABCDEFG", "e", PR_TRUE, 4 },
2585 { "ABCDEFG", "g", PR_TRUE, 6 },
2586 { "ABCDEFG", "i", PR_FALSE, 0 },
2587 { "ABCDEFG", "ab", PR_TRUE, 0 },
2588 { "ABCDEFG", "cd", PR_TRUE, 2 },
2589 { "ABCDEFG", "ef", PR_TRUE, 4 },
2590 { "ABCDEFG", "gh", PR_FALSE, 0 },
2591 { "ABCDABC", "bc", PR_TRUE, 1 },
2592 { "ABCDEFG", "abcdefg", PR_TRUE, 0 },
2593 { "ABCDEFGABCDEFG", "a", PR_TRUE, 0 },
2594 { "ABCDEFGABCDEFG", "c", PR_TRUE, 2 },
2595 { "ABCDEFGABCDEFG", "e", PR_TRUE, 4 },
2596 { "ABCDEFGABCDEFG", "g", PR_TRUE, 6 },
2597 { "ABCDEFGABCDEFG", "i", PR_FALSE, 0 },
2598 { "ABCDEFGABCDEFG", "ab", PR_TRUE, 0 },
2599 { "ABCDEFGABCDEFG", "cd", PR_TRUE, 2 },
2600 { "ABCDEFGABCDEFG", "ef", PR_TRUE, 4 },
2601 { "ABCDEFGABCDEFG", "gh", PR_FALSE, 0 },
2602 { "ABCDABCABCDABC", "bc", PR_TRUE, 1 },
2603 { "ABCDEFGABCDEFG", "abcdefg", PR_TRUE, 0 }
2604 };
2605
2606 int i;
2607
2608 printf("Test 027 (PL_strcasestr) ..."); fflush(stdout);
2609
2610 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
2611 {
2612 char *rv = PL_strcasestr(array[i].str, array[i].sub);
2613
2614 if( PR_FALSE == array[i].ret )
2615 {
2616 if( (char *)0 != rv )
2617 {
2618 printf("FAIL %d: %s,%s -> %.32s, not null\n", i,
2619 array[i].str ? array[i].str : "(null)",
2620 array[i].sub ? array[i].sub : "(null)",
2621 rv);
2622 return PR_FALSE;
2623 }
2624 }
2625 else
2626 {
2627 if( (char *)0 == rv )
2628 {
2629 printf("FAIL %d: %s,%s -> null, not 0x%x+%lu\n", i,
2630 array[i].str ? array[i].str : "(null)",
2631 array[i].sub ? array[i].sub : "(null)",
2632 array[i].str, array[i].off);
2633 return PR_FALSE;
2634 }
2635
2636 if( &array[i].str[ array[i].off ] != rv )
2637 {
2638 printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i,
2639 array[i].str ? array[i].str : "(null)",
2640 array[i].sub ? array[i].sub : "(null)",
2641 rv, array[i].str, array[i].off);
2642 return PR_FALSE;
2643 }
2644 }
2645 }
2646
2647 printf("PASS\n");
2648 return PR_TRUE;
2649 }
2650
2651 /* PL_strcaserstr */
2652 PRBool test_028(void)
2653 {
2654 static struct
2655 {
2656 const char *str;
2657 const char *sub;
2658 PRBool ret;
2659 PRUint32 off;
2660 } array[] =
2661 {
2662 { (const char *)0, (const char *)0, PR_FALSE, 0 },
2663 { (const char *)0, "blah", PR_FALSE, 0 },
2664 { "blah-de-blah", (const char *)0, PR_FALSE, 0 },
2665 { "blah-de-blah", "blah", PR_TRUE, 8 },
2666 { "", "blah", PR_FALSE, 0 },
2667 { "blah-de-blah", "", PR_FALSE, 0 },
2668 { "abcdefg", "a", PR_TRUE, 0 },
2669 { "abcdefg", "c", PR_TRUE, 2 },
2670 { "abcdefg", "e", PR_TRUE, 4 },
2671 { "abcdefg", "g", PR_TRUE, 6 },
2672 { "abcdefg", "i", PR_FALSE, 0 },
2673 { "abcdefg", "ab", PR_TRUE, 0 },
2674 { "abcdefg", "cd", PR_TRUE, 2 },
2675 { "abcdefg", "ef", PR_TRUE, 4 },
2676 { "abcdefg", "gh", PR_FALSE, 0 },
2677 { "abcdabc", "bc", PR_TRUE, 5 },
2678 { "abcdefg", "abcdefg", PR_TRUE, 0 },
2679 { "abcdefgabcdefg", "a", PR_TRUE, 7 },
2680 { "abcdefgabcdefg", "c", PR_TRUE, 9 },
2681 { "abcdefgabcdefg", "e", PR_TRUE, 11 },
2682 { "abcdefgabcdefg", "g", PR_TRUE, 13 },
2683 { "abcdefgabcdefg", "i", PR_FALSE, 0 },
2684 { "abcdefgabcdefg", "ab", PR_TRUE, 7 },
2685 { "abcdefgabcdefg", "cd", PR_TRUE, 9 },
2686 { "abcdefgabcdefg", "ef", PR_TRUE, 11 },
2687 { "abcdefgabcdefg", "gh", PR_FALSE, 0 },
2688 { "abcdabcabcdabc", "bc", PR_TRUE, 12 },
2689 { "abcdefgabcdefg", "abcdefg", PR_TRUE, 7 },
2690 { "ABCDEFG", "a", PR_TRUE, 0 },
2691 { "ABCDEFG", "c", PR_TRUE, 2 },
2692 { "ABCDEFG", "e", PR_TRUE, 4 },
2693 { "ABCDEFG", "g", PR_TRUE, 6 },
2694 { "ABCDEFG", "i", PR_FALSE, 0 },
2695 { "ABCDEFG", "ab", PR_TRUE, 0 },
2696 { "ABCDEFG", "cd", PR_TRUE, 2 },
2697 { "ABCDEFG", "ef", PR_TRUE, 4 },
2698 { "ABCDEFG", "gh", PR_FALSE, 0 },
2699 { "ABCDABC", "bc", PR_TRUE, 5 },
2700 { "ABCDEFG", "abcdefg", PR_TRUE, 0 },
2701 { "ABCDEFGABCDEFG", "a", PR_TRUE, 7 },
2702 { "ABCDEFGABCDEFG", "c", PR_TRUE, 9 },
2703 { "ABCDEFGABCDEFG", "e", PR_TRUE, 11 },
2704 { "ABCDEFGABCDEFG", "g", PR_TRUE, 13 },
2705 { "ABCDEFGABCDEFG", "i", PR_FALSE, 0 },
2706 { "ABCDEFGABCDEFG", "ab", PR_TRUE, 7 },
2707 { "ABCDEFGABCDEFG", "cd", PR_TRUE, 9 },
2708 { "ABCDEFGABCDEFG", "ef", PR_TRUE, 11 },
2709 { "ABCDEFGABCDEFG", "gh", PR_FALSE, 0 },
2710 { "ABCDABCABCDABC", "bc", PR_TRUE, 12 },
2711 { "ABCDEFGABCDEFG", "abcdefg", PR_TRUE, 7 }
2712 };
2713
2714 int i;
2715
2716 printf("Test 028 (PL_strcaserstr) ..."); fflush(stdout);
2717
2718 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
2719 {
2720 char *rv = PL_strcaserstr(array[i].str, array[i].sub);
2721
2722 if( PR_FALSE == array[i].ret )
2723 {
2724 if( (char *)0 != rv )
2725 {
2726 printf("FAIL %d: %s,%s -> %.32s, not null\n", i,
2727 array[i].str ? array[i].str : "(null)",
2728 array[i].sub ? array[i].sub : "(null)",
2729 rv);
2730 return PR_FALSE;
2731 }
2732 }
2733 else
2734 {
2735 if( (char *)0 == rv )
2736 {
2737 printf("FAIL %d: %s,%s -> null, not 0x%x+%lu\n", i,
2738 array[i].str ? array[i].str : "(null)",
2739 array[i].sub ? array[i].sub : "(null)",
2740 array[i].str, array[i].off);
2741 return PR_FALSE;
2742 }
2743
2744 if( &array[i].str[ array[i].off ] != rv )
2745 {
2746 printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i,
2747 array[i].str ? array[i].str : "(null)",
2748 array[i].sub ? array[i].sub : "(null)",
2749 rv, array[i].str, array[i].off);
2750 return PR_FALSE;
2751 }
2752 }
2753 }
2754
2755 printf("PASS\n");
2756 return PR_TRUE;
2757 }
2758
2759 /* PL_strncasestr */
2760 PRBool test_029(void)
2761 {
2762 static struct
2763 {
2764 const char *str;
2765 const char *sub;
2766 PRUint32 max;
2767 PRBool ret;
2768 PRUint32 off;
2769 } array[] =
2770 {
2771 { (const char *)0, (const char *)0, 12, PR_FALSE, 0 },
2772 { (const char *)0, "blah", 12, PR_FALSE, 0 },
2773 { "blah-de-blah", (const char *)0, 12, PR_FALSE, 0 },
2774 { "blah-de-blah", "blah", 0, PR_FALSE, 0 },
2775 { "blah-de-blah", "blah", 2, PR_FALSE, 0 },
2776 { "blah-de-blah", "blah", 3, PR_FALSE, 0 },
2777 { "blah-de-blah", "blah", 4, PR_TRUE, 0 },
2778 { "blah-de-blah", "blah", 5, PR_TRUE, 0 },
2779 { "blah-de-blah", "blah", 12, PR_TRUE, 0 },
2780 { "", "blah", 12, PR_FALSE, 0 },
2781 { "blah-de-blah", "", 12, PR_FALSE, 0 },
2782 { "abcdefg", "a", 5, PR_TRUE, 0 },
2783 { "abcdefg", "c", 5, PR_TRUE, 2 },
2784 { "abcdefg", "e", 5, PR_TRUE, 4 },
2785 { "abcdefg", "g", 5, PR_FALSE, 0 },
2786 { "abcdefg", "i", 5, PR_FALSE, 0 },
2787 { "abcdefg", "ab", 5, PR_TRUE, 0 },
2788 { "abcdefg", "cd", 5, PR_TRUE, 2 },
2789 { "abcdefg", "ef", 5, PR_FALSE, 0 },
2790 { "abcdefg", "gh", 5, PR_FALSE, 0 },
2791 { "abcdabc", "bc", 5, PR_TRUE, 1 },
2792 { "abcdabc", "bc", 6, PR_TRUE, 1 },
2793 { "abcdabc", "bc", 7, PR_TRUE, 1 },
2794 { "abcdefg", "abcdefg", 6, PR_FALSE, 0 },
2795 { "abcdefg", "abcdefg", 7, PR_TRUE, 0 },
2796 { "abcdefg", "abcdefg", 8, PR_TRUE, 0 },
2797 { "abcdefgabcdefg", "a", 12, PR_TRUE, 0 },
2798 { "abcdefgabcdefg", "c", 12, PR_TRUE, 2 },
2799 { "abcdefgabcdefg", "e", 12, PR_TRUE, 4 },
2800 { "abcdefgabcdefg", "g", 12, PR_TRUE, 6 },
2801 { "abcdefgabcdefg", "i", 12, PR_FALSE, 0 },
2802 { "abcdefgabcdefg", "ab", 12, PR_TRUE, 0 },
2803 { "abcdefgabcdefg", "cd", 12, PR_TRUE, 2 },
2804 { "abcdefgabcdefg", "ef", 12, PR_TRUE, 4 },
2805 { "abcdefgabcdefg", "gh", 12, PR_FALSE, 0 },
2806 { "abcdabcabcdabc", "bc", 5, PR_TRUE, 1 },
2807 { "abcdabcabcdabc", "bc", 6, PR_TRUE, 1 },
2808 { "abcdabcabcdabc", "bc", 7, PR_TRUE, 1 },
2809 { "abcdefgabcdefg", "abcdefg", 6, PR_FALSE, 0 },
2810 { "abcdefgabcdefg", "abcdefg", 7, PR_TRUE, 0 },
2811 { "abcdefgabcdefg", "abcdefg", 8, PR_TRUE, 0 },
2812 { "ABCDEFG", "a", 5, PR_TRUE, 0 },
2813 { "ABCDEFG", "c", 5, PR_TRUE, 2 },
2814 { "ABCDEFG", "e", 5, PR_TRUE, 4 },
2815 { "ABCDEFG", "g", 5, PR_FALSE, 0 },
2816 { "ABCDEFG", "i", 5, PR_FALSE, 0 },
2817 { "ABCDEFG", "ab", 5, PR_TRUE, 0 },
2818 { "ABCDEFG", "cd", 5, PR_TRUE, 2 },
2819 { "ABCDEFG", "ef", 5, PR_FALSE, 0 },
2820 { "ABCDEFG", "gh", 5, PR_FALSE, 0 },
2821 { "ABCDABC", "bc", 5, PR_TRUE, 1 },
2822 { "ABCDABC", "bc", 6, PR_TRUE, 1 },
2823 { "ABCDABC", "bc", 7, PR_TRUE, 1 },
2824 { "ABCDEFG", "abcdefg", 6, PR_FALSE, 0 },
2825 { "ABCDEFG", "abcdefg", 7, PR_TRUE, 0 },
2826 { "ABCDEFG", "abcdefg", 8, PR_TRUE, 0 },
2827 { "ABCDEFGABCDEFG", "a", 12, PR_TRUE, 0 },
2828 { "ABCDEFGABCDEFG", "c", 12, PR_TRUE, 2 },
2829 { "ABCDEFGABCDEFG", "e", 12, PR_TRUE, 4 },
2830 { "ABCDEFGABCDEFG", "g", 12, PR_TRUE, 6 },
2831 { "ABCDEFGABCDEFG", "i", 12, PR_FALSE, 0 },
2832 { "ABCDEFGABCDEFG", "ab", 12, PR_TRUE, 0 },
2833 { "ABCDEFGABCDEFG", "cd", 12, PR_TRUE, 2 },
2834 { "ABCDEFGABCDEFG", "ef", 12, PR_TRUE, 4 },
2835 { "ABCDEFGABCDEFG", "gh", 12, PR_FALSE, 0 },
2836 { "ABCDABCABCDABC", "bc", 5, PR_TRUE, 1 },
2837 { "ABCDABCABCDABC", "bc", 6, PR_TRUE, 1 },
2838 { "ABCDABCABCDABC", "bc", 7, PR_TRUE, 1 },
2839 { "ABCDEFGABCDEFG", "abcdefg", 6, PR_FALSE, 0 },
2840 { "ABCDEFGABCDEFG", "abcdefg", 7, PR_TRUE, 0 },
2841 { "ABCDEFGABCDEFG", "abcdefg", 8, PR_TRUE, 0 }
2842 };
2843
2844 int i;
2845
2846 printf("Test 029 (PL_strncasestr) ..."); fflush(stdout);
2847
2848 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
2849 {
2850 char *rv = PL_strncasestr(array[i].str, array[i].sub, array[i].max);
2851
2852 if( PR_FALSE == array[i].ret )
2853 {
2854 if( (char *)0 != rv )
2855 {
2856 printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i,
2857 array[i].str ? array[i].str : "(null)",
2858 array[i].sub ? array[i].sub : "(null)",
2859 array[i].max, rv);
2860 return PR_FALSE;
2861 }
2862 }
2863 else
2864 {
2865 if( (char *)0 == rv )
2866 {
2867 printf("FAIL %d: %s,%s/%lu -> null, not 0x%x+%lu\n", i,
2868 array[i].str ? array[i].str : "(null)",
2869 array[i].sub ? array[i].sub : "(null)",
2870 array[i].max, array[i].str, array[i].off);
2871 return PR_FALSE;
2872 }
2873
2874 if( &array[i].str[ array[i].off ] != rv )
2875 {
2876 printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i,
2877 array[i].str ? array[i].str : "(null)",
2878 array[i].sub ? array[i].sub : "(null)",
2879 array[i].max, rv, array[i].str, array[i].off);
2880 return PR_FALSE;
2881 }
2882 }
2883 }
2884
2885 printf("PASS\n");
2886 return PR_TRUE;
2887 }
2888
2889 /* PL_strncaserstr */
2890 PRBool test_030(void)
2891 {
2892 static struct
2893 {
2894 const char *str;
2895 const char *sub;
2896 PRUint32 max;
2897 PRBool ret;
2898 PRUint32 off;
2899 } array[] =
2900 {
2901 { (const char *)0, (const char *)0, 12, PR_FALSE, 0 },
2902 { (const char *)0, "blah", 12, PR_FALSE, 0 },
2903 { "blah-de-blah", (const char *)0, 12, PR_FALSE, 0 },
2904 { "blah-de-blah", "blah", 0, PR_FALSE, 0 },
2905 { "blah-de-blah", "blah", 2, PR_FALSE, 0 },
2906 { "blah-de-blah", "blah", 3, PR_FALSE, 0 },
2907 { "blah-de-blah", "blah", 4, PR_TRUE, 0 },
2908 { "blah-de-blah", "blah", 5, PR_TRUE, 0 },
2909 { "blah-de-blah", "blah", 11, PR_TRUE, 0 },
2910 { "blah-de-blah", "blah", 12, PR_TRUE, 8 },
2911 { "blah-de-blah", "blah", 13, PR_TRUE, 8 },
2912 { "", "blah", 12, PR_FALSE, 0 },
2913 { "blah-de-blah", "", 12, PR_FALSE, 0 },
2914 { "abcdefg", "a", 5, PR_TRUE, 0 },
2915 { "abcdefg", "c", 5, PR_TRUE, 2 },
2916 { "abcdefg", "e", 5, PR_TRUE, 4 },
2917 { "abcdefg", "g", 5, PR_FALSE, 0 },
2918 { "abcdefg", "i", 5, PR_FALSE, 0 },
2919 { "abcdefg", "ab", 5, PR_TRUE, 0 },
2920 { "abcdefg", "cd", 5, PR_TRUE, 2 },
2921 { "abcdefg", "ef", 5, PR_FALSE, 0 },
2922 { "abcdefg", "gh", 5, PR_FALSE, 0 },
2923 { "abcdabc", "bc", 5, PR_TRUE, 1 },
2924 { "abcdabc", "bc", 6, PR_TRUE, 1 },
2925 { "abcdabc", "bc", 7, PR_TRUE, 5 },
2926 { "abcdefg", "abcdefg", 6, PR_FALSE, 0 },
2927 { "abcdefg", "abcdefg", 7, PR_TRUE, 0 },
2928 { "abcdefg", "abcdefg", 8, PR_TRUE, 0 },
2929 { "abcdefgabcdefg", "a", 12, PR_TRUE, 7 },
2930 { "abcdefgabcdefg", "c", 12, PR_TRUE, 9 },
2931 { "abcdefgabcdefg", "e", 12, PR_TRUE, 11 },
2932 { "abcdefgabcdefg", "g", 12, PR_TRUE, 6 },
2933 { "abcdefgabcdefg", "i", 12, PR_FALSE, 0 },
2934 { "abcdefgabcdefg", "ab", 12, PR_TRUE, 7 },
2935 { "abcdefgabcdefg", "cd", 12, PR_TRUE, 9 },
2936 { "abcdefgabcdefg", "ef", 12, PR_TRUE, 4 },
2937 { "abcdefgabcdefg", "gh", 12, PR_FALSE, 0 },
2938 { "abcdabcabcdabc", "bc", 12, PR_TRUE, 8 },
2939 { "abcdabcabcdabc", "bc", 13, PR_TRUE, 8 },
2940 { "abcdabcabcdabc", "bc", 14, PR_TRUE, 12 },
2941 { "abcdefgabcdefg", "abcdefg", 13, PR_TRUE, 0 },
2942 { "abcdefgabcdefg", "abcdefg", 14, PR_TRUE, 7 },
2943 { "abcdefgabcdefg", "abcdefg", 15, PR_TRUE, 7 },
2944 { "ABCDEFG", "a", 5, PR_TRUE, 0 },
2945 { "ABCDEFG", "c", 5, PR_TRUE, 2 },
2946 { "ABCDEFG", "e", 5, PR_TRUE, 4 },
2947 { "ABCDEFG", "g", 5, PR_FALSE, 0 },
2948 { "ABCDEFG", "i", 5, PR_FALSE, 0 },
2949 { "ABCDEFG", "ab", 5, PR_TRUE, 0 },
2950 { "ABCDEFG", "cd", 5, PR_TRUE, 2 },
2951 { "ABCDEFG", "ef", 5, PR_FALSE, 0 },
2952 { "ABCDEFG", "gh", 5, PR_FALSE, 0 },
2953 { "ABCDABC", "bc", 5, PR_TRUE, 1 },
2954 { "ABCDABC", "bc", 6, PR_TRUE, 1 },
2955 { "ABCDABC", "bc", 7, PR_TRUE, 5 },
2956 { "ABCDEFG", "abcdefg", 6, PR_FALSE, 0 },
2957 { "ABCDEFG", "abcdefg", 7, PR_TRUE, 0 },
2958 { "ABCDEFG", "abcdefg", 8, PR_TRUE, 0 },
2959 { "ABCDEFGABCDEFG", "a", 12, PR_TRUE, 7 },
2960 { "ABCDEFGABCDEFG", "c", 12, PR_TRUE, 9 },
2961 { "ABCDEFGABCDEFG", "e", 12, PR_TRUE, 11 },
2962 { "ABCDEFGABCDEFG", "g", 12, PR_TRUE, 6 },
2963 { "ABCDEFGABCDEFG", "i", 12, PR_FALSE, 0 },
2964 { "ABCDEFGABCDEFG", "ab", 12, PR_TRUE, 7 },
2965 { "ABCDEFGABCDEFG", "cd", 12, PR_TRUE, 9 },
2966 { "ABCDEFGABCDEFG", "ef", 12, PR_TRUE, 4 },
2967 { "ABCDEFGABCDEFG", "gh", 12, PR_FALSE, 0 },
2968 { "ABCDABCABCDABC", "bc", 12, PR_TRUE, 8 },
2969 { "ABCDABCABCDABC", "bc", 13, PR_TRUE, 8 },
2970 { "ABCDABCABCDABC", "bc", 14, PR_TRUE, 12 },
2971 { "ABCDEFGABCDEFG", "abcdefg", 13, PR_TRUE, 0 },
2972 { "ABCDEFGABCDEFG", "abcdefg", 14, PR_TRUE, 7 },
2973 { "ABCDEFGABCDEFG", "abcdefg", 15, PR_TRUE, 7 }
2974 };
2975
2976 int i;
2977
2978 printf("Test 030 (PL_strncaserstr)..."); fflush(stdout);
2979
2980 for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
2981 {
2982 char *rv = PL_strncaserstr(array[i].str, array[i].sub, array[i].max);
2983
2984 if( PR_FALSE == array[i].ret )
2985 {
2986 if( (char *)0 != rv )
2987 {
2988 printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i,
2989 array[i].str ? array[i].str : "(null)",
2990 array[i].sub ? array[i].sub : "(null)",
2991 array[i].max, rv);
2992 return PR_FALSE;
2993 }
2994 }
2995 else
2996 {
2997 if( (char *)0 == rv )
2998 {
2999 printf("FAIL %d: %s,%s/%lu -> null, not 0x%x+%lu\n", i,
3000 array[i].str ? array[i].str : "(null)",
3001 array[i].sub ? array[i].sub : "(null)",
3002 array[i].max, array[i].str, array[i].off);
3003 return PR_FALSE;
3004 }
3005
3006 if( &array[i].str[ array[i].off ] != rv )
3007 {
3008 printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i,
3009 array[i].str ? array[i].str : "(null)",
3010 array[i].sub ? array[i].sub : "(null)",
3011 array[i].max, rv, array[i].str, array[i].off);
3012 return PR_FALSE;
3013 }
3014 }
3015 }
3016
3017 printf("PASS\n");
3018 return PR_TRUE;
3019 }
3020
3021 /* PL_strtok_r */
3022 PRBool test_031(void)
3023 {
3024 static const char *tokens[] = {
3025 "wtc", "relyea", "nelsonb", "jpierre", "nicolson",
3026 "ian.mcgreer", "kirk.erickson", "sonja.mirtitsch", "mhein"
3027 };
3028
3029 static const char *seps[] = {
3030 ", ", ",", " ", "\t", ",,,", " ,", " ", " \t\t", ","
3031 };
3032
3033 static const char s2[] = ", \t";
3034
3035 char string[ 1024 ];
3036 char *s1;
3037 char *token;
3038 char *lasts;
3039 unsigned int i;
3040
3041 printf("Test 031 (PL_strtok_r) ..."); fflush(stdout);
3042
3043 /* Build the string. */
3044 string[0] = '\0';
3045 for( i = 0; i < sizeof(tokens)/sizeof(tokens[0]); i++ )
3046 {
3047 PL_strcat(string, tokens[i]);
3048 PL_strcat(string, seps[i]);
3049 }
3050
3051 /* Scan the string for tokens. */
3052 i = 0;
3053 s1 = string;
3054 while( (token = PL_strtok_r(s1, s2, &lasts)) != NULL)
3055 {
3056 if( PL_strcmp(token, tokens[i]) != 0 )
3057 {
3058 printf("FAIL wrong token scanned\n");
3059 return PR_FALSE;
3060 }
3061 i++;
3062 s1 = NULL;
3063 }
3064 if( i != sizeof(tokens)/sizeof(tokens[0]) )
3065 {
3066 printf("FAIL wrong number of tokens scanned\n");
3067 return PR_FALSE;
3068 }
3069
3070 printf("PASS\n");
3071 return PR_TRUE;
3072 }
3073
3074 int
3075 main
3076 (
3077 int argc,
3078 char *argv[]
3079 )
3080 {
3081 printf("Testing the Portable Library string functions:\n");
3082
3083 if( 1
3084 && test_001()
3085 && test_001()
3086 && test_002()
3087 && test_003()
3088 && test_004()
3089 && test_005()
3090 && test_006()
3091 && test_007()
3092 && test_008()
3093 && test_009()
3094 && test_010()
3095 && test_011()
3096 && test_012()
3097 && test_013()
3098 && test_014()
3099 && test_015()
3100 && test_016()
3101 && test_017()
3102 && test_018()
3103 && test_019()
3104 && test_020()
3105 && test_021()
3106 && test_022()
3107 && test_023()
3108 && test_024()
3109 && test_025()
3110 && test_026()
3111 && test_027()
3112 && test_028()
3113 && test_029()
3114 && test_030()
3115 && test_031()
3116 )
3117 {
3118 printf("Suite passed.\n");
3119 return 0;
3120 }
3121 else
3122 {
3123 printf("Suite failed.\n");
3124 return 1;
3125 }
3126
3127 /*NOTREACHED*/
3128 }