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