The Tor Browser / file comparison

comparison: nsprpub/lib/tests/string.c

nsprpub/lib/tests/string.c

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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial