/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #include "plstr.h" #include "nspr.h" #include /* PL_strlen */ PRBool test_001(void) { static struct { const char* str; PRUint32 len; } array[] = {{(const char*)0, 0}, {"", 0}, {"a", 1}, {"abcdefg", 7}, {"abcdefg\0hijk", 7}}; int i; printf("Test 001 (PL_strlen) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { if (PL_strlen(array[i].str) != array[i].len) { printf("FAIL (%d: %s->%d, %d)\n", i, array[i].str ? array[i].str : "(null)", PL_strlen(array[i].str), array[i].len); return PR_FALSE; } } printf("PASS\n"); return PR_TRUE; } /* PL_strnlen */ PRBool test_002(void) { static struct { const char* str; PRUint32 max; PRUint32 len; } array[] = { {(const char*)0, 0, 0}, {(const char*)0, 12, 0}, {"", 0, 0}, {"", 12, 0}, {"a", 0, 0}, {"a", 1, 1}, {"a", 12, 1}, {"abcdefg", 0, 0}, {"abcdefg", 1, 1}, {"abcdefg", 7, 7}, {"abcdefg", 12, 7}, {"abcdefg\0hijk", 0, 0}, {"abcdefg\0hijk", 1, 1}, {"abcdefg\0hijk", 7, 7}, {"abcdefg\0hijk", 12, 7}, }; int i; printf("Test 002 (PL_strnlen) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { if (PL_strnlen(array[i].str, array[i].max) != array[i].len) { printf("FAIL (%d: %s,%d->%d, %d)\n", i, array[i].str ? array[i].str : "(null)", array[i].max, PL_strnlen(array[i].str, array[i].max), array[i].len); return PR_FALSE; } } printf("PASS\n"); return PR_TRUE; } /* PL_strcpy */ PRBool test_003(void) { static char buffer[1024]; static struct { const char* str; char* dest; char* rv; PRBool comp; } array[] = {{(const char*)0, (char*)0, (char*)0, PR_FALSE}, {(const char*)0, buffer, (char*)0, PR_FALSE}, {"", (char*)0, (char*)0, PR_FALSE}, {"", buffer, buffer, PR_TRUE}, {"a", (char*)0, (char*)0, PR_FALSE}, {"a", buffer, buffer, PR_TRUE}, {"abcdefg", (char*)0, (char*)0, PR_FALSE}, {"abcdefg", buffer, buffer, PR_TRUE}, {"wxyz\0abcdefg", (char*)0, (char*)0, PR_FALSE}, {"wxyz\0abcdefg", buffer, buffer, PR_TRUE}}; int i; printf("Test 003 (PL_strcpy) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv; const char* a = array[i].str; const char* b = (const char*)array[i].dest; rv = PL_strcpy(array[i].dest, array[i].str); if (array[i].rv != rv) { printf("FAIL %d: (0x%x, %s)->0x%x\n", i, array[i].dest, array[i].str ? array[i].str : "(null)", rv); return PR_FALSE; } if (array[i].comp) { while (1) { if (*a != *b) { printf("FAIL %d: %s->%.32s\n", i, array[i].str ? array[i].str : "(null)", array[i].dest ? array[i].dest : "(null)"); return PR_FALSE; } if ((char)0 == *a) { break; } a++; b++; } } } printf("PASS\n"); return PR_TRUE; } /* PL_strncpy */ PRBool test_004(void) { static char buffer[1024]; static struct { const char* str; PRUint32 len; char* dest; char* rv; PRBool comp; const char* result; PRBool nulled; } array[] = { {(const char*)0, 0, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {(const char*)0, 0, buffer, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {(const char*)0, 1, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {(const char*)0, 7, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {(const char*)0, 1, buffer, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {(const char*)0, 7, buffer, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"", 0, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"", 0, buffer, buffer, PR_FALSE, (const char*)0, PR_FALSE}, {"", 1, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"", 7, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"", 1, buffer, buffer, PR_TRUE, "", PR_TRUE}, {"", 7, buffer, buffer, PR_TRUE, "", PR_TRUE}, {"a", 0, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"a", 0, buffer, buffer, PR_FALSE, (const char*)0, PR_FALSE}, {"a", 1, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"a", 7, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"b", 1, buffer, buffer, PR_TRUE, "b", PR_FALSE}, {"c", 7, buffer, buffer, PR_TRUE, "c", PR_TRUE}, {"de", 0, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"de", 0, buffer, buffer, PR_FALSE, (const char*)0, PR_FALSE}, {"de", 1, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"de", 7, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"fg", 1, buffer, buffer, PR_TRUE, "f", PR_FALSE}, {"hi", 7, buffer, buffer, PR_TRUE, "hi", PR_TRUE}, {"jklmnopq", 0, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"jklmnopq", 0, buffer, buffer, PR_FALSE, (const char*)0, PR_FALSE}, {"jklmnopq", 1, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"jklmnopq", 7, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"rstuvwxy", 1, buffer, buffer, PR_TRUE, "r", PR_FALSE}, {"zABCDEFG", 7, buffer, buffer, PR_TRUE, "zABCDEF", PR_FALSE}, {"a\0XXX", 0, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"a\0XXX", 0, buffer, buffer, PR_FALSE, (const char*)0, PR_FALSE}, {"a\0XXX", 1, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"a\0XXX", 7, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"b\0XXX", 1, buffer, buffer, PR_TRUE, "b", PR_FALSE}, {"c\0XXX", 7, buffer, buffer, PR_TRUE, "c", PR_TRUE}, {"de\0XXX", 0, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"de\0XXX", 0, buffer, buffer, PR_FALSE, (const char*)0, PR_FALSE}, {"de\0XXX", 1, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"de\0XXX", 7, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"fg\0XXX", 1, buffer, buffer, PR_TRUE, "f", PR_FALSE}, {"hi\0XXX", 7, buffer, buffer, PR_TRUE, "hi", PR_TRUE}, {"jklmnopq\0XXX", 0, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"jklmnopq\0XXX", 0, buffer, buffer, PR_FALSE, (const char*)0, PR_FALSE}, {"jklmnopq\0XXX", 1, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"jklmnopq\0XXX", 7, (char*)0, (char*)0, PR_FALSE, (const char*)0, PR_FALSE}, {"rstuvwxy\0XXX", 1, buffer, buffer, PR_TRUE, "r", PR_FALSE}, {"zABCDEFG\0XXX", 7, buffer, buffer, PR_TRUE, "zABCDEF", PR_FALSE}, }; int i; printf("Test 004 (PL_strncpy) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv; int j; for (j = 0; j < sizeof(buffer); j++) { buffer[j] = '-'; } rv = PL_strncpy(array[i].dest, array[i].str, array[i].len); if (array[i].rv != rv) { printf("FAIL %d: (0x%x, %s, %lu)->0x%x\n", i, array[i].dest, array[i].str ? array[i].str : "(null)", array[i].len, rv); return PR_FALSE; } if (array[i].comp) { const char* a = array[i].result; const char* b = array[i].dest; while (*a) { if (*a != *b) { printf("FAIL %d: %s != %.32s\n", i, array[i].result, array[i].dest); return PR_FALSE; } a++; b++; } if (array[i].nulled) { if (*b != '\0') { printf("FAIL %d: not terminated\n", i); return PR_FALSE; } } else { if (*b != '-') { printf("FAIL %d: overstepped\n", i); return PR_FALSE; } } } } printf("PASS\n"); return PR_TRUE; } /* PL_strncpyz */ PRBool test_005(void) { static char buffer[1024]; static struct { const char* str; PRUint32 len; char* dest; char* rv; PRBool comp; const char* result; } array[] = { {(const char*)0, 0, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {(const char*)0, 0, buffer, (char*)0, PR_FALSE, (const char*)0}, {(const char*)0, 1, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {(const char*)0, 7, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {(const char*)0, 1, buffer, (char*)0, PR_FALSE, (const char*)0}, {(const char*)0, 7, buffer, (char*)0, PR_FALSE, (const char*)0}, {"", 0, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"", 0, buffer, (char*)0, PR_FALSE, (const char*)0}, {"", 1, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"", 7, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"", 1, buffer, buffer, PR_TRUE, ""}, {"", 7, buffer, buffer, PR_TRUE, ""}, {"a", 0, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"a", 0, buffer, (char*)0, PR_FALSE, (const char*)0}, {"a", 1, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"a", 7, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"b", 1, buffer, buffer, PR_TRUE, ""}, {"c", 7, buffer, buffer, PR_TRUE, "c"}, {"de", 0, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"de", 0, buffer, (char*)0, PR_FALSE, (const char*)0}, {"de", 1, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"de", 7, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"fg", 1, buffer, buffer, PR_TRUE, ""}, {"hi", 7, buffer, buffer, PR_TRUE, "hi"}, {"jklmnopq", 0, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"jklmnopq", 0, buffer, (char*)0, PR_FALSE, (const char*)0}, {"jklmnopq", 1, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"jklmnopq", 7, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"rstuvwxy", 1, buffer, buffer, PR_TRUE, ""}, {"zABCDEFG", 7, buffer, buffer, PR_TRUE, "zABCDE"}, {"a\0XXX", 0, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"a\0XXX", 0, buffer, (char*)0, PR_FALSE, (const char*)0}, {"a\0XXX", 1, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"a\0XXX", 7, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"b\0XXX", 1, buffer, buffer, PR_TRUE, ""}, {"c\0XXX", 7, buffer, buffer, PR_TRUE, "c"}, {"de\0XXX", 0, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"de\0XXX", 0, buffer, (char*)0, PR_FALSE, (const char*)0}, {"de\0XXX", 1, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"de\0XXX", 7, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"fg\0XXX", 1, buffer, buffer, PR_TRUE, ""}, {"hi\0XXX", 7, buffer, buffer, PR_TRUE, "hi"}, {"jklmnopq\0XXX", 0, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"jklmnopq\0XXX", 0, buffer, (char*)0, PR_FALSE, (const char*)0}, {"jklmnopq\0XXX", 1, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"jklmnopq\0XXX", 7, (char*)0, (char*)0, PR_FALSE, (const char*)0}, {"rstuvwxy\0XXX", 1, buffer, buffer, PR_TRUE, ""}, {"zABCDEFG\0XXX", 7, buffer, buffer, PR_TRUE, "zABCDE"}, }; int i; printf("Test 005 (PL_strncpyz) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv; int j; for (j = 0; j < sizeof(buffer); j++) { buffer[j] = '-'; } rv = PL_strncpyz(array[i].dest, array[i].str, array[i].len); if (array[i].rv != rv) { printf("FAIL %d: (0x%x, %s, %lu)->0x%x\n", i, array[i].dest, array[i].str ? array[i].str : "(null)", array[i].len, rv); return PR_FALSE; } if (array[i].comp) { const char* a = array[i].result; const char* b = array[i].dest; while (1) { if (*a != *b) { printf("FAIL %d: %s != %.32s\n", i, array[i].result, array[i].dest); return PR_FALSE; } if ((char)0 == *a) { break; } a++; b++; } } } printf("PASS\n"); return PR_TRUE; } /* PL_strdup */ PRBool test_006(void) { static const char* array[] = {(const char*)0, "", "a", "abcdefg"}; int i; printf("Test 006 (PL_strdup) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv = PL_strdup(array[i]); if ((char*)0 == rv) { printf("FAIL %d: 0x%x -> 0\n", i, array[i]); return PR_FALSE; } if ((const char*)0 == array[i]) { if ((char)0 != *rv) { printf("FAIL %d: (const char *)0 -> %.32s\n", i, rv); return PR_FALSE; } } else { const char* a = array[i]; const char* b = (const char*)rv; while (1) { if (*a != *b) { printf("FAIL %d: %s != %.32s\n", i, array[i], rv); return PR_FALSE; } if ((char)0 == *a) { break; } a++; b++; } } PL_strfree(rv); } printf("PASS\n"); return PR_TRUE; } /* PL_strndup */ PRBool test_007(void) { static struct { const char* str; PRUint32 len; const char* result; } array[] = {{(const char*)0, 0, ""}, {(const char*)0, 1, ""}, {(const char*)0, 7, ""}, {"", 0, ""}, {"", 1, ""}, {"", 7, ""}, {"a", 0, ""}, {"a", 1, "a"}, {"a", 7, "a"}, {"ab", 0, ""}, {"ab", 1, "a"}, {"ab", 7, "ab"}, {"abcdefg", 0, ""}, {"abcdefg", 1, "a"}, {"abcdefg", 7, "abcdefg"}, {"abcdefghijk", 0, ""}, {"abcdefghijk", 1, "a"}, {"abcdefghijk", 7, "abcdefg"}, {"abcdef\0ghijk", 0, ""}, {"abcdef\0ghijk", 1, "a"}, {"abcdef\0ghijk", 7, "abcdef"}}; int i; printf("Test 007 (PL_strndup) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv = PL_strndup(array[i].str, array[i].len); const char* a; const char* b; if ((char*)0 == rv) { printf("FAIL %d: %s,%lu -> 0\n", i, array[i].str ? array[i].str : "(null)", array[i].len); return PR_FALSE; } a = array[i].result; b = (const char*)rv; while (1) { if (*a != *b) { printf("FAIL %d: %s != %.32s\n", i, array[i].result, rv); return PR_FALSE; } if ((char)0 == *a) { break; } a++; b++; } free(rv); } printf("PASS\n"); return PR_TRUE; } /* PL_strcat */ PRBool test_008(void) { static struct { const char* first; const char* second; const char* result; } array[] = {{(const char*)0, (const char*)0, (const char*)0}, {(const char*)0, "xyz", (const char*)0}, {"", (const char*)0, ""}, {"", "", ""}, {"ab", "", "ab"}, {"cd", "ef", "cdef"}, {"gh\0X", "", "gh"}, {"ij\0X", "kl", "ijkl"}, {"mn\0X", "op\0X", "mnop"}, {"qr", "st\0X", "qrst"}, {"uv\0X", "wx\0X", "uvwx"}}; int i; printf("Test 008 (PL_strcat) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char buffer[1024]; int j; char* rv; for (j = 0; j < sizeof(buffer); j++) { buffer[j] = '-'; } if ((const char*)0 != array[i].first) { (void)PL_strcpy(buffer, array[i].first); } rv = PL_strcat(((const char*)0 == array[i].first) ? (char*)0 : buffer, array[i].second); if ((const char*)0 == array[i].result) { if ((char*)0 != rv) { printf("FAIL %d: %s+%s -> %.32s, not zero\n", i, array[i].first ? array[i].first : "(null)", array[i].second ? array[i].second : "(null)", rv); return PR_FALSE; } } else { if ((char*)0 == rv) { printf("FAIL %d: %s+%s -> null, not %s\n", i, array[i].first ? array[i].first : "(null)", array[i].second ? array[i].second : "(null)", array[i].result); return PR_FALSE; } else { const char* a = array[i].result; const char* b = (const char*)rv; while (1) { if (*a != *b) { printf("FAIL %d: %s+%s -> %.32s, not %s\n", i, array[i].first ? array[i].first : "(null)", array[i].second ? array[i].second : "(null)", rv, array[i].result); return PR_FALSE; } if ((char)0 == *a) { break; } a++; b++; } } } } printf("PASS\n"); return PR_TRUE; } /* PL_strncat */ PRBool test_009(void) { static struct { const char* first; const char* second; PRUint32 length; PRBool nulled; const char* result; } array[] = {{(const char*)0, (const char*)0, 0, PR_FALSE, (const char*)0}, {(const char*)0, (const char*)0, 1, PR_FALSE, (const char*)0}, {(const char*)0, (const char*)0, 7, PR_FALSE, (const char*)0}, {(const char*)0, "", 0, PR_FALSE, (const char*)0}, {(const char*)0, "", 1, PR_FALSE, (const char*)0}, {(const char*)0, "", 7, PR_FALSE, (const char*)0}, {(const char*)0, "stuff", 0, PR_FALSE, (const char*)0}, {(const char*)0, "stuff", 1, PR_FALSE, (const char*)0}, {(const char*)0, "stuff", 7, PR_FALSE, (const char*)0}, {"", (const char*)0, 0, PR_TRUE, ""}, {"", (const char*)0, 1, PR_TRUE, ""}, {"", (const char*)0, 7, PR_TRUE, ""}, {"", "", 0, PR_TRUE, ""}, {"", "", 1, PR_TRUE, ""}, {"", "", 7, PR_TRUE, ""}, {"", "abcdefgh", 0, PR_TRUE, ""}, {"", "abcdefgh", 1, PR_FALSE, "a"}, {"", "abcdefgh", 7, PR_FALSE, "abcdefg"}, {"xyz", (const char*)0, 0, PR_TRUE, "xyz"}, {"xyz", (const char*)0, 1, PR_TRUE, "xyz"}, {"xyz", (const char*)0, 7, PR_TRUE, "xyz"}, {"xyz", "", 0, PR_TRUE, "xyz"}, {"xyz", "", 1, PR_TRUE, "xyz"}, {"xyz", "", 7, PR_TRUE, "xyz"}, {"xyz", "abcdefgh", 0, PR_TRUE, "xyz"}, {"xyz", "abcdefgh", 1, PR_FALSE, "xyza"}, {"xyz", "abcdefgh", 7, PR_FALSE, "xyzabcdefg"}}; int i; printf("Test 009 (PL_strncat) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char buffer[1024]; int j; char* rv; for (j = 0; j < sizeof(buffer); j++) { buffer[j] = '-'; } if ((const char*)0 != array[i].first) { (void)PL_strcpy(buffer, array[i].first); } rv = PL_strncat(((const char*)0 == array[i].first) ? (char*)0 : buffer, array[i].second, array[i].length); if ((const char*)0 == array[i].result) { if ((char*)0 != rv) { printf("FAIL %d: %s+%s/%lu -> %.32s, not zero\n", i, array[i].first ? array[i].first : "(null)", array[i].second ? array[i].second : "(null)", array[i].length, rv); return PR_FALSE; } } else { if ((char*)0 == rv) { printf("FAIL %d: %s+%s/%lu -> null, not %s\n", i, array[i].first ? array[i].first : "(null)", array[i].second ? array[i].second : "(null)", array[i].length, array[i].result); return PR_FALSE; } else { const char* a = array[i].result; const char* b = (const char*)rv; while (*a) { if (*a != *b) { printf("FAIL %d: %s+%s/%lu -> %.32s, not %s\n", i, array[i].first ? array[i].first : "(null)", array[i].second ? array[i].second : "(null)", array[i].length, rv, array[i].result); return PR_FALSE; } a++; b++; } if (array[i].nulled) { if ((char)0 != *b) { printf("FAIL %d: %s+%s/%lu -> not nulled\n", i, array[i].first ? array[i].first : "(null)", array[i].second ? array[i].second : "(null)", array[i].length); return PR_FALSE; } } else { if ((char)0 == *b) { printf("FAIL %d: %s+%s/%lu -> overrun\n", i, array[i].first ? array[i].first : "(null)", array[i].second ? array[i].second : "(null)", array[i].length); return PR_FALSE; } } } } } printf("PASS\n"); return PR_TRUE; } /* PL_strcatn */ PRBool test_010(void) { static struct { const char* first; const char* second; PRUint32 length; const char* result; } array[] = {{(const char*)0, (const char*)0, 0, (const char*)0}, {(const char*)0, (const char*)0, 1, (const char*)0}, {(const char*)0, (const char*)0, 7, (const char*)0}, {(const char*)0, "", 0, (const char*)0}, {(const char*)0, "", 1, (const char*)0}, {(const char*)0, "", 7, (const char*)0}, {(const char*)0, "stuff", 0, (const char*)0}, {(const char*)0, "stuff", 1, (const char*)0}, {(const char*)0, "stuff", 7, (const char*)0}, {"", (const char*)0, 0, ""}, {"", (const char*)0, 1, ""}, {"", (const char*)0, 7, ""}, {"", "", 0, ""}, {"", "", 1, ""}, {"", "", 7, ""}, {"", "abcdefgh", 0, ""}, {"", "abcdefgh", 1, ""}, {"", "abcdefgh", 7, "abcdef"}, {"xyz", (const char*)0, 0, "xyz"}, {"xyz", (const char*)0, 1, "xyz"}, {"xyz", (const char*)0, 7, "xyz"}, {"xyz", "", 0, "xyz"}, {"xyz", "", 1, "xyz"}, {"xyz", "", 7, "xyz"}, {"xyz", "abcdefgh", 0, "xyz"}, {"xyz", "abcdefgh", 1, "xyz"}, {"xyz", "abcdefgh", 7, "xyzabc"}}; int i; printf("Test 010 (PL_strcatn) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char buffer[1024]; int j; char* rv; for (j = 0; j < sizeof(buffer); j++) { buffer[j] = '-'; } if ((const char*)0 != array[i].first) { (void)PL_strcpy(buffer, array[i].first); } rv = PL_strcatn(((const char*)0 == array[i].first) ? (char*)0 : buffer, array[i].length, array[i].second); if ((const char*)0 == array[i].result) { if ((char*)0 != rv) { printf("FAIL %d: %s+%s/%lu -> %.32s, not zero\n", i, array[i].first ? array[i].first : "(null)", array[i].second ? array[i].second : "(null)", array[i].length, rv); return PR_FALSE; } } else { if ((char*)0 == rv) { printf("FAIL %d: %s+%s/%lu -> null, not %s\n", i, array[i].first ? array[i].first : "(null)", array[i].second ? array[i].second : "(null)", array[i].length, array[i].result); return PR_FALSE; } else { const char* a = array[i].result; const char* b = (const char*)rv; while (1) { if (*a != *b) { printf("FAIL %d: %s+%s/%lu -> %.32s, not %s\n", i, array[i].first ? array[i].first : "(null)", array[i].second ? array[i].second : "(null)", array[i].length, rv, array[i].result); return PR_FALSE; } if ((char)0 == *a) { break; } a++; b++; } } } } printf("PASS\n"); return PR_TRUE; } /* PL_strcmp */ PRBool test_011(void) { static struct { const char* one; const char* two; PRIntn sign; } array[] = {{(const char*)0, (const char*)0, 0}, {(const char*)0, "word", -1}, {"word", (const char*)0, 1}, {"word", "word", 0}, {"aZYXVUT", "bZYXVUT", -1}, {"aZYXVUT", "bAAAAAA", -1}, {"a", "aa", -1}, {"a", "a", 0}, {"a", "A", 1}, {"aaaaa", "baaaa", -1}, {"aaaaa", "abaaa", -1}, {"aaaaa", "aabaa", -1}, {"aaaaa", "aaaba", -1}, {"aaaaa", "aaaab", -1}, {"bZYXVUT", "aZYXVUT", 1}, {"bAAAAAA", "aZYXVUT", 1}, {"aa", "a", 1}, {"A", "a", -1}, {"baaaa", "aaaaa", 1}, {"abaaa", "aaaaa", 1}, {"aabaa", "aaaaa", 1}, {"aaaba", "aaaaa", 1}, {"aaaab", "aaaaa", 1}, {"word", "Word", 1}, {"word", "wOrd", 1}, {"word", "woRd", 1}, {"word", "worD", 1}, {"WORD", "wORD", -1}, {"WORD", "WoRD", -1}, {"WORD", "WOrD", -1}, {"WORD", "WORd", -1}}; int i; printf("Test 011 (PL_strcmp) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { PRIntn rv = PL_strcmp(array[i].one, array[i].two); switch (array[i].sign) { case -1: if (rv < 0) { continue; } break; case 1: if (rv > 0) { continue; } break; case 0: if (0 == rv) { continue; } break; default: PR_NOT_REACHED("static data inconsistancy"); break; } printf("FAIL %d: %s-%s -> %d, not %d\n", i, array[i].one ? array[i].one : "(null)", array[i].two ? array[i].two : "(null)", rv, array[i].sign); return PR_FALSE; } printf("PASS\n"); return PR_TRUE; } /* PL_strncmp */ PRBool test_012(void) { static struct { const char* one; const char* two; PRUint32 max; PRIntn sign; } array[] = {{(const char*)0, (const char*)0, 0, 0}, {(const char*)0, (const char*)0, 1, 0}, {(const char*)0, (const char*)0, 4, 0}, {(const char*)0, "word", 0, -1}, {(const char*)0, "word", 1, -1}, {(const char*)0, "word", 4, -1}, {"word", (const char*)0, 0, 1}, {"word", (const char*)0, 1, 1}, {"word", (const char*)0, 4, 1}, {"word", "word", 0, 0}, {"word", "word", 1, 0}, {"word", "word", 3, 0}, {"word", "word", 5, 0}, {"aZYXVUT", "bZYXVUT", 0, 0}, {"aZYXVUT", "bZYXVUT", 1, -1}, {"aZYXVUT", "bZYXVUT", 4, -1}, {"aZYXVUT", "bZYXVUT", 9, -1}, {"aZYXVUT", "bAAAAAA", 0, 0}, {"aZYXVUT", "bAAAAAA", 1, -1}, {"aZYXVUT", "bAAAAAA", 4, -1}, {"aZYXVUT", "bAAAAAA", 5, -1}, {"a", "aa", 0, 0}, {"a", "aa", 1, 0}, {"a", "aa", 4, -1}, {"a", "a", 0, 0}, {"a", "a", 1, 0}, {"a", "a", 4, 0}, {"a", "A", 0, 0}, {"a", "A", 1, 1}, {"a", "A", 4, 1}, {"aaaaa", "baaaa", 0, 0}, {"aaaaa", "baaaa", 1, -1}, {"aaaaa", "baaaa", 4, -1}, {"aaaaa", "abaaa", 0, 0}, {"aaaaa", "abaaa", 1, 0}, {"aaaaa", "abaaa", 4, -1}, {"aaaaa", "aabaa", 0, 0}, {"aaaaa", "aabaa", 1, 0}, {"aaaaa", "aabaa", 4, -1}, {"aaaaa", "aaaba", 0, 0}, {"aaaaa", "aaaba", 1, 0}, {"aaaaa", "aaaba", 4, -1}, {"aaaaa", "aaaab", 0, 0}, {"aaaaa", "aaaab", 1, 0}, {"aaaaa", "aaaab", 4, 0}, {"bZYXVUT", "aZYXVUT", 0, 0}, {"bZYXVUT", "aZYXVUT", 1, 1}, {"bZYXVUT", "aZYXVUT", 4, 1}, {"bAAAAAA", "aZYXVUT", 0, 0}, {"bAAAAAA", "aZYXVUT", 1, 1}, {"bAAAAAA", "aZYXVUT", 4, 1}, {"aa", "a", 0, 0}, {"aa", "a", 1, 0}, {"aa", "a", 4, 1}, {"A", "a", 0, 0}, {"A", "a", 1, -1}, {"A", "a", 4, -1}, {"baaaa", "aaaaa", 0, 0}, {"baaaa", "aaaaa", 1, 1}, {"baaaa", "aaaaa", 4, 1}, {"abaaa", "aaaaa", 0, 0}, {"abaaa", "aaaaa", 1, 0}, {"abaaa", "aaaaa", 4, 1}, {"aabaa", "aaaaa", 0, 0}, {"aabaa", "aaaaa", 1, 0}, {"aabaa", "aaaaa", 4, 1}, {"aaaba", "aaaaa", 0, 0}, {"aaaba", "aaaaa", 1, 0}, {"aaaba", "aaaaa", 4, 1}, {"aaaab", "aaaaa", 0, 0}, {"aaaab", "aaaaa", 1, 0}, {"aaaab", "aaaaa", 4, 0}, {"word", "Word", 0, 0}, {"word", "Word", 1, 1}, {"word", "Word", 3, 1}, {"word", "wOrd", 0, 0}, {"word", "wOrd", 1, 0}, {"word", "wOrd", 3, 1}, {"word", "woRd", 0, 0}, {"word", "woRd", 1, 0}, {"word", "woRd", 3, 1}, {"word", "worD", 0, 0}, {"word", "worD", 1, 0}, {"word", "worD", 3, 0}, {"WORD", "wORD", 0, 0}, {"WORD", "wORD", 1, -1}, {"WORD", "wORD", 3, -1}, {"WORD", "WoRD", 0, 0}, {"WORD", "WoRD", 1, 0}, {"WORD", "WoRD", 3, -1}, {"WORD", "WOrD", 0, 0}, {"WORD", "WOrD", 1, 0}, {"WORD", "WOrD", 3, -1}, {"WORD", "WORd", 0, 0}, {"WORD", "WORd", 1, 0}, {"WORD", "WORd", 3, 0} }; int i; printf("Test 012 (PL_strncmp) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { PRIntn rv = PL_strncmp(array[i].one, array[i].two, array[i].max); switch (array[i].sign) { case -1: if (rv < 0) { continue; } break; case 1: if (rv > 0) { continue; } break; case 0: if (0 == rv) { continue; } break; default: PR_NOT_REACHED("static data inconsistancy"); break; } printf("FAIL %d: %s-%s/%ld -> %d, not %d\n", i, array[i].one ? array[i].one : "(null)", array[i].two ? array[i].two : "(null)", array[i].max, rv, array[i].sign); return PR_FALSE; } printf("PASS\n"); return PR_TRUE; } /* PL_strcasecmp */ PRBool test_013(void) { static struct { const char* one; const char* two; PRIntn sign; } array[] = {{(const char*)0, (const char*)0, 0}, {(const char*)0, "word", -1}, {"word", (const char*)0, 1}, {"word", "word", 0}, {"aZYXVUT", "bZYXVUT", -1}, {"aZYXVUT", "bAAAAAA", -1}, {"a", "aa", -1}, {"a", "a", 0}, {"a", "A", 0}, {"aaaaa", "baaaa", -1}, {"aaaaa", "abaaa", -1}, {"aaaaa", "aabaa", -1}, {"aaaaa", "aaaba", -1}, {"aaaaa", "aaaab", -1}, {"bZYXVUT", "aZYXVUT", 1}, {"bAAAAAA", "aZYXVUT", 1}, {"aa", "a", 1}, {"A", "a", 0}, {"baaaa", "aaaaa", 1}, {"abaaa", "aaaaa", 1}, {"aabaa", "aaaaa", 1}, {"aaaba", "aaaaa", 1}, {"aaaab", "aaaaa", 1}, {"word", "Word", 0}, {"word", "wOrd", 0}, {"word", "woRd", 0}, {"word", "worD", 0}, {"WORD", "wORD", 0}, {"WORD", "WoRD", 0}, {"WORD", "WOrD", 0}, {"WORD", "WORd", 0}}; int i; printf("Test 013 (PL_strcasecmp) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { PRIntn rv = PL_strcasecmp(array[i].one, array[i].two); switch (array[i].sign) { case -1: if (rv < 0) { continue; } break; case 1: if (rv > 0) { continue; } break; case 0: if (0 == rv) { continue; } break; default: PR_NOT_REACHED("static data inconsistancy"); break; } printf("FAIL %d: %s-%s -> %d, not %d\n", i, array[i].one ? array[i].one : "(null)", array[i].two ? array[i].two : "(null)", rv, array[i].sign); return PR_FALSE; } printf("PASS\n"); return PR_TRUE; } /* PL_strncasecmp */ PRBool test_014(void) { static struct { const char* one; const char* two; PRUint32 max; PRIntn sign; } array[] = {{(const char*)0, (const char*)0, 0, 0}, {(const char*)0, (const char*)0, 1, 0}, {(const char*)0, (const char*)0, 4, 0}, {(const char*)0, "word", 0, -1}, {(const char*)0, "word", 1, -1}, {(const char*)0, "word", 4, -1}, {"word", (const char*)0, 0, 1}, {"word", (const char*)0, 1, 1}, {"word", (const char*)0, 4, 1}, {"word", "word", 0, 0}, {"word", "word", 1, 0}, {"word", "word", 3, 0}, {"word", "word", 5, 0}, {"aZYXVUT", "bZYXVUT", 0, 0}, {"aZYXVUT", "bZYXVUT", 1, -1}, {"aZYXVUT", "bZYXVUT", 4, -1}, {"aZYXVUT", "bZYXVUT", 9, -1}, {"aZYXVUT", "bAAAAAA", 0, 0}, {"aZYXVUT", "bAAAAAA", 1, -1}, {"aZYXVUT", "bAAAAAA", 4, -1}, {"aZYXVUT", "bAAAAAA", 5, -1}, {"a", "aa", 0, 0}, {"a", "aa", 1, 0}, {"a", "aa", 4, -1}, {"a", "a", 0, 0}, {"a", "a", 1, 0}, {"a", "a", 4, 0}, {"a", "A", 0, 0}, {"a", "A", 1, 0}, {"a", "A", 4, 0}, {"aaaaa", "baaaa", 0, 0}, {"aaaaa", "baaaa", 1, -1}, {"aaaaa", "baaaa", 4, -1}, {"aaaaa", "abaaa", 0, 0}, {"aaaaa", "abaaa", 1, 0}, {"aaaaa", "abaaa", 4, -1}, {"aaaaa", "aabaa", 0, 0}, {"aaaaa", "aabaa", 1, 0}, {"aaaaa", "aabaa", 4, -1}, {"aaaaa", "aaaba", 0, 0}, {"aaaaa", "aaaba", 1, 0}, {"aaaaa", "aaaba", 4, -1}, {"aaaaa", "aaaab", 0, 0}, {"aaaaa", "aaaab", 1, 0}, {"aaaaa", "aaaab", 4, 0}, {"bZYXVUT", "aZYXVUT", 0, 0}, {"bZYXVUT", "aZYXVUT", 1, 1}, {"bZYXVUT", "aZYXVUT", 4, 1}, {"bAAAAAA", "aZYXVUT", 0, 0}, {"bAAAAAA", "aZYXVUT", 1, 1}, {"bAAAAAA", "aZYXVUT", 4, 1}, {"aa", "a", 0, 0}, {"aa", "a", 1, 0}, {"aa", "a", 4, 1}, {"A", "a", 0, 0}, {"A", "a", 1, 0}, {"A", "a", 4, 0}, {"baaaa", "aaaaa", 0, 0}, {"baaaa", "aaaaa", 1, 1}, {"baaaa", "aaaaa", 4, 1}, {"abaaa", "aaaaa", 0, 0}, {"abaaa", "aaaaa", 1, 0}, {"abaaa", "aaaaa", 4, 1}, {"aabaa", "aaaaa", 0, 0}, {"aabaa", "aaaaa", 1, 0}, {"aabaa", "aaaaa", 4, 1}, {"aaaba", "aaaaa", 0, 0}, {"aaaba", "aaaaa", 1, 0}, {"aaaba", "aaaaa", 4, 1}, {"aaaab", "aaaaa", 0, 0}, {"aaaab", "aaaaa", 1, 0}, {"aaaab", "aaaaa", 4, 0}, {"word", "Word", 0, 0}, {"word", "Word", 1, 0}, {"word", "Word", 3, 0}, {"word", "wOrd", 0, 0}, {"word", "wOrd", 1, 0}, {"word", "wOrd", 3, 0}, {"word", "woRd", 0, 0}, {"word", "woRd", 1, 0}, {"word", "woRd", 3, 0}, {"word", "worD", 0, 0}, {"word", "worD", 1, 0}, {"word", "worD", 3, 0}, {"WORD", "wORD", 0, 0}, {"WORD", "wORD", 1, 0}, {"WORD", "wORD", 3, 0}, {"WORD", "WoRD", 0, 0}, {"WORD", "WoRD", 1, 0}, {"WORD", "WoRD", 3, 0}, {"WORD", "WOrD", 0, 0}, {"WORD", "WOrD", 1, 0}, {"WORD", "WOrD", 3, 0}, {"WORD", "WORd", 0, 0}, {"WORD", "WORd", 1, 0}, {"WORD", "WORd", 3, 0}}; int i; printf("Test 014 (PL_strncasecmp) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { PRIntn rv = PL_strncasecmp(array[i].one, array[i].two, array[i].max); switch (array[i].sign) { case -1: if (rv < 0) { continue; } break; case 1: if (rv > 0) { continue; } break; case 0: if (0 == rv) { continue; } break; default: PR_NOT_REACHED("static data inconsistancy"); break; } printf("FAIL %d: %s-%s/%ld -> %d, not %d\n", i, array[i].one ? array[i].one : "(null)", array[i].two ? array[i].two : "(null)", array[i].max, rv, array[i].sign); return PR_FALSE; } printf("PASS\n"); return PR_TRUE; } /* PL_strchr */ PRBool test_015(void) { static struct { const char* str; char chr; PRBool ret; PRUint32 off; } array[] = {{(const char*)0, 'a', PR_FALSE, 0}, {(const char*)0, '\0', PR_FALSE, 0}, {"abcdefg", 'a', PR_TRUE, 0}, {"abcdefg", 'b', PR_TRUE, 1}, {"abcdefg", 'c', PR_TRUE, 2}, {"abcdefg", 'd', PR_TRUE, 3}, {"abcdefg", 'e', PR_TRUE, 4}, {"abcdefg", 'f', PR_TRUE, 5}, {"abcdefg", 'g', PR_TRUE, 6}, {"abcdefg", 'h', PR_FALSE, 0}, {"abcdefg", '\0', PR_TRUE, 7}, {"abcdefg", 'A', PR_FALSE, 0}, {"abcdefg", 'B', PR_FALSE, 0}, {"abcdefg", 'C', PR_FALSE, 0}, {"abcdefg", 'D', PR_FALSE, 0}, {"abcdefg", 'E', PR_FALSE, 0}, {"abcdefg", 'F', PR_FALSE, 0}, {"abcdefg", 'G', PR_FALSE, 0}, {"abcdefg", 'H', PR_FALSE, 0}, {"abcdefgabcdefg", 'a', PR_TRUE, 0}, {"abcdefgabcdefg", 'b', PR_TRUE, 1}, {"abcdefgabcdefg", 'c', PR_TRUE, 2}, {"abcdefgabcdefg", 'd', PR_TRUE, 3}, {"abcdefgabcdefg", 'e', PR_TRUE, 4}, {"abcdefgabcdefg", 'f', PR_TRUE, 5}, {"abcdefgabcdefg", 'g', PR_TRUE, 6}, {"abcdefgabcdefg", 'h', PR_FALSE, 0}, {"abcdefgabcdefg", '\0', PR_TRUE, 14}}; int i; printf("Test 015 (PL_strchr) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv = PL_strchr(array[i].str, array[i].chr); if (PR_FALSE == array[i].ret) { if ((char*)0 != rv) { printf("FAIL %d: %s,%c -> %.32s, not zero\n", i, array[i].str, array[i].chr, rv); return PR_FALSE; } } else { if ((char*)0 == rv) { printf("FAIL %d: %s,%c -> null, not +%lu\n", i, array[i].str, array[i].chr, array[i].off); return PR_FALSE; } if (&array[i].str[array[i].off] != rv) { printf("FAIL %d: %s,%c -> 0x%x, not 0x%x+%lu\n", i, array[i].str, array[i].chr, rv, array[i].str, array[i].off); return PR_FALSE; } } } printf("PASS\n"); return PR_TRUE; } /* PL_strrchr */ PRBool test_016(void) { static struct { const char* str; char chr; PRBool ret; PRUint32 off; } array[] = {{(const char*)0, 'a', PR_FALSE, 0}, {(const char*)0, '\0', PR_FALSE, 0}, {"abcdefg", 'a', PR_TRUE, 0}, {"abcdefg", 'b', PR_TRUE, 1}, {"abcdefg", 'c', PR_TRUE, 2}, {"abcdefg", 'd', PR_TRUE, 3}, {"abcdefg", 'e', PR_TRUE, 4}, {"abcdefg", 'f', PR_TRUE, 5}, {"abcdefg", 'g', PR_TRUE, 6}, {"abcdefg", 'h', PR_FALSE, 0}, {"abcdefg", '\0', PR_TRUE, 7}, {"abcdefg", 'A', PR_FALSE, 0}, {"abcdefg", 'B', PR_FALSE, 0}, {"abcdefg", 'C', PR_FALSE, 0}, {"abcdefg", 'D', PR_FALSE, 0}, {"abcdefg", 'E', PR_FALSE, 0}, {"abcdefg", 'F', PR_FALSE, 0}, {"abcdefg", 'G', PR_FALSE, 0}, {"abcdefg", 'H', PR_FALSE, 0}, {"abcdefgabcdefg", 'a', PR_TRUE, 7}, {"abcdefgabcdefg", 'b', PR_TRUE, 8}, {"abcdefgabcdefg", 'c', PR_TRUE, 9}, {"abcdefgabcdefg", 'd', PR_TRUE, 10}, {"abcdefgabcdefg", 'e', PR_TRUE, 11}, {"abcdefgabcdefg", 'f', PR_TRUE, 12}, {"abcdefgabcdefg", 'g', PR_TRUE, 13}, {"abcdefgabcdefg", 'h', PR_FALSE, 0}, {"abcdefgabcdefg", '\0', PR_TRUE, 14}}; int i; printf("Test 016 (PL_strrchr) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv = PL_strrchr(array[i].str, array[i].chr); if (PR_FALSE == array[i].ret) { if ((char*)0 != rv) { printf("FAIL %d: %s,%c -> %.32s, not zero\n", i, array[i].str, array[i].chr, rv); return PR_FALSE; } } else { if ((char*)0 == rv) { printf("FAIL %d: %s,%c -> null, not +%lu\n", i, array[i].str, array[i].chr, array[i].off); return PR_FALSE; } if (&array[i].str[array[i].off] != rv) { printf("FAIL %d: %s,%c -> 0x%x, not 0x%x+%lu\n", i, array[i].str, array[i].chr, rv, array[i].str, array[i].off); return PR_FALSE; } } } printf("PASS\n"); return PR_TRUE; } /* PL_strnchr */ PRBool test_017(void) { static struct { const char* str; char chr; PRUint32 max; PRBool ret; PRUint32 off; } array[] = {{(const char*)0, 'a', 2, PR_FALSE, 0}, {(const char*)0, '\0', 2, PR_FALSE, 0}, {"abcdefg", 'a', 5, PR_TRUE, 0}, {"abcdefg", 'b', 5, PR_TRUE, 1}, {"abcdefg", 'c', 5, PR_TRUE, 2}, {"abcdefg", 'd', 5, PR_TRUE, 3}, {"abcdefg", 'e', 5, PR_TRUE, 4}, {"abcdefg", 'f', 5, PR_FALSE, 0}, {"abcdefg", 'g', 5, PR_FALSE, 0}, {"abcdefg", 'h', 5, PR_FALSE, 0}, {"abcdefg", '\0', 5, PR_FALSE, 0}, {"abcdefg", '\0', 15, PR_TRUE, 7}, {"abcdefg", 'A', 5, PR_FALSE, 0}, {"abcdefg", 'B', 5, PR_FALSE, 0}, {"abcdefg", 'C', 5, PR_FALSE, 0}, {"abcdefg", 'D', 5, PR_FALSE, 0}, {"abcdefg", 'E', 5, PR_FALSE, 0}, {"abcdefg", 'F', 5, PR_FALSE, 0}, {"abcdefg", 'G', 5, PR_FALSE, 0}, {"abcdefg", 'H', 5, PR_FALSE, 0}, {"abcdefgabcdefg", 'a', 10, PR_TRUE, 0}, {"abcdefgabcdefg", 'b', 10, PR_TRUE, 1}, {"abcdefgabcdefg", 'c', 10, PR_TRUE, 2}, {"abcdefgabcdefg", 'd', 10, PR_TRUE, 3}, {"abcdefgabcdefg", 'e', 10, PR_TRUE, 4}, {"abcdefgabcdefg", 'f', 10, PR_TRUE, 5}, {"abcdefgabcdefg", 'g', 10, PR_TRUE, 6}, {"abcdefgabcdefg", 'h', 10, PR_FALSE, 0}, {"abcdefgabcdefg", '\0', 10, PR_FALSE, 0}, {"abcdefgabcdefg", '\0', 14, PR_FALSE, 0}, {"abcdefgabcdefg", '\0', 15, PR_TRUE, 14}}; int i; printf("Test 017 (PL_strnchr) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv = PL_strnchr(array[i].str, array[i].chr, array[i].max); if (PR_FALSE == array[i].ret) { if ((char*)0 != rv) { printf("FAIL %d: %s,%c/%lu -> %.32s, not zero\n", i, array[i].str, array[i].chr, array[i].max, rv); return PR_FALSE; } } else { if ((char*)0 == rv) { printf("FAIL %d: %s,%c/%lu -> null, not +%lu\n", i, array[i].str, array[i].chr, array[i].max, array[i].off); return PR_FALSE; } if (&array[i].str[array[i].off] != rv) { printf("FAIL %d: %s,%c/%lu -> 0x%x, not 0x%x+%lu\n", i, array[i].str, array[i].chr, array[i].max, rv, array[i].str, array[i].off); return PR_FALSE; } } } printf("PASS\n"); return PR_TRUE; } /* PL_strnrchr */ PRBool test_018(void) { static struct { const char* str; char chr; PRUint32 max; PRBool ret; PRUint32 off; } array[] = {{(const char*)0, 'a', 2, PR_FALSE, 0}, {(const char*)0, '\0', 2, PR_FALSE, 0}, {"abcdefg", 'a', 5, PR_TRUE, 0}, {"abcdefg", 'b', 5, PR_TRUE, 1}, {"abcdefg", 'c', 5, PR_TRUE, 2}, {"abcdefg", 'd', 5, PR_TRUE, 3}, {"abcdefg", 'e', 5, PR_TRUE, 4}, {"abcdefg", 'f', 5, PR_FALSE, 0}, {"abcdefg", 'g', 5, PR_FALSE, 0}, {"abcdefg", 'h', 5, PR_FALSE, 0}, {"abcdefg", '\0', 5, PR_FALSE, 0}, {"abcdefg", '\0', 15, PR_TRUE, 7}, {"abcdefg", 'A', 5, PR_FALSE, 0}, {"abcdefg", 'B', 5, PR_FALSE, 0}, {"abcdefg", 'C', 5, PR_FALSE, 0}, {"abcdefg", 'D', 5, PR_FALSE, 0}, {"abcdefg", 'E', 5, PR_FALSE, 0}, {"abcdefg", 'F', 5, PR_FALSE, 0}, {"abcdefg", 'G', 5, PR_FALSE, 0}, {"abcdefg", 'H', 5, PR_FALSE, 0}, {"abcdefgabcdefg", 'a', 10, PR_TRUE, 7}, {"abcdefgabcdefg", 'b', 10, PR_TRUE, 8}, {"abcdefgabcdefg", 'c', 10, PR_TRUE, 9}, {"abcdefgabcdefg", 'd', 10, PR_TRUE, 3}, {"abcdefgabcdefg", 'e', 10, PR_TRUE, 4}, {"abcdefgabcdefg", 'f', 10, PR_TRUE, 5}, {"abcdefgabcdefg", 'g', 10, PR_TRUE, 6}, {"abcdefgabcdefg", 'h', 10, PR_FALSE, 0}, {"abcdefgabcdefg", '\0', 10, PR_FALSE, 0}, {"abcdefgabcdefg", '\0', 14, PR_FALSE, 0}, {"abcdefgabcdefg", '\0', 15, PR_TRUE, 14}}; int i; printf("Test 018 (PL_strnrchr) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv = PL_strnrchr(array[i].str, array[i].chr, array[i].max); if (PR_FALSE == array[i].ret) { if ((char*)0 != rv) { printf("FAIL %d: %s,%c/%lu -> %.32s, not zero\n", i, array[i].str, array[i].chr, array[i].max, rv); return PR_FALSE; } } else { if ((char*)0 == rv) { printf("FAIL %d: %s,%c/%lu -> null, not +%lu\n", i, array[i].str, array[i].chr, array[i].max, array[i].off); return PR_FALSE; } if (&array[i].str[array[i].off] != rv) { printf("FAIL %d: %s,%c/%lu -> 0x%x, not 0x%x+%lu\n", i, array[i].str, array[i].chr, array[i].max, rv, array[i].str, array[i].off); return PR_FALSE; } } } printf("PASS\n"); return PR_TRUE; } /* PL_strpbrk */ PRBool test_019(void) { static struct { const char* str; const char* chrs; PRBool ret; PRUint32 off; } array[] = {{(const char*)0, (const char*)0, PR_FALSE, 0}, {(const char*)0, "abc", PR_FALSE, 0}, {"abc", (const char*)0, PR_FALSE, 0}, {"abcdefg", "", PR_FALSE, 0}, {"", "aeiou", PR_FALSE, 0}, {"abcdefg", "ae", PR_TRUE, 0}, {"abcdefg", "ei", PR_TRUE, 4}, {"abcdefg", "io", PR_FALSE, 0}, {"abcdefg", "bcd", PR_TRUE, 1}, {"abcdefg", "cbd", PR_TRUE, 1}, {"abcdefg", "dbc", PR_TRUE, 1}, {"abcdefg", "ghi", PR_TRUE, 6}, {"abcdefg", "AE", PR_FALSE, 0}, {"abcdefg", "EI", PR_FALSE, 0}, {"abcdefg", "IO", PR_FALSE, 0}, {"abcdefg", "BCD", PR_FALSE, 0}, {"abcdefg", "CBD", PR_FALSE, 0}, {"abcdefg", "DBC", PR_FALSE, 0}, {"abcdefg", "GHI", PR_FALSE, 0}, {"abcdefgabcdefg", "ae", PR_TRUE, 0}, {"abcdefgabcdefg", "ei", PR_TRUE, 4}, {"abcdefgabcdefg", "io", PR_FALSE, 0}, {"abcdefgabcdefg", "bcd", PR_TRUE, 1}, {"abcdefgabcdefg", "cbd", PR_TRUE, 1}, {"abcdefgabcdefg", "dbc", PR_TRUE, 1}, {"abcdefgabcdefg", "ghi", PR_TRUE, 6}, {"abcdefgabcdefg", "AE", PR_FALSE, 0}, {"abcdefgabcdefg", "EI", PR_FALSE, 0}, {"abcdefgabcdefg", "IO", PR_FALSE, 0}, {"abcdefgabcdefg", "BCD", PR_FALSE, 0}, {"abcdefgabcdefg", "CBD", PR_FALSE, 0}, {"abcdefgabcdefg", "DBC", PR_FALSE, 0}, {"abcdefgabcdefg", "GHI", PR_FALSE, 0}}; int i; printf("Test 019 (PL_strpbrk) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv = PL_strpbrk(array[i].str, array[i].chrs); if (PR_FALSE == array[i].ret) { if ((char*)0 != rv) { printf("FAIL %d: %s,%s -> %.32s, not null\n", i, array[i].str ? array[i].str : "(null)", array[i].chrs ? array[i].chrs : "(null)", rv); return PR_FALSE; } } else { if ((char*)0 == rv) { printf("FAIL %d: %s,%s -> null, not +%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].chrs ? array[i].chrs : "(null)", array[i].off); return PR_FALSE; } if (&array[i].str[array[i].off] != rv) { printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].chrs ? array[i].chrs : "(null)", rv, array[i].str, array[i].off); return PR_FALSE; } } } printf("PASS\n"); return PR_TRUE; } /* PL_strprbrk */ PRBool test_020(void) { static struct { const char* str; const char* chrs; PRBool ret; PRUint32 off; } array[] = {{(const char*)0, (const char*)0, PR_FALSE, 0}, {(const char*)0, "abc", PR_FALSE, 0}, {"abc", (const char*)0, PR_FALSE, 0}, {"abcdefg", "", PR_FALSE, 0}, {"", "aeiou", PR_FALSE, 0}, {"abcdefg", "ae", PR_TRUE, 4}, {"abcdefg", "ei", PR_TRUE, 4}, {"abcdefg", "io", PR_FALSE, 0}, {"abcdefg", "bcd", PR_TRUE, 3}, {"abcdefg", "cbd", PR_TRUE, 3}, {"abcdefg", "dbc", PR_TRUE, 3}, {"abcdefg", "ghi", PR_TRUE, 6}, {"abcdefg", "AE", PR_FALSE, 0}, {"abcdefg", "EI", PR_FALSE, 0}, {"abcdefg", "IO", PR_FALSE, 0}, {"abcdefg", "BCD", PR_FALSE, 0}, {"abcdefg", "CBD", PR_FALSE, 0}, {"abcdefg", "DBC", PR_FALSE, 0}, {"abcdefg", "GHI", PR_FALSE, 0}, {"abcdefgabcdefg", "ae", PR_TRUE, 11}, {"abcdefgabcdefg", "ei", PR_TRUE, 11}, {"abcdefgabcdefg", "io", PR_FALSE, 0}, {"abcdefgabcdefg", "bcd", PR_TRUE, 10}, {"abcdefgabcdefg", "cbd", PR_TRUE, 10}, {"abcdefgabcdefg", "dbc", PR_TRUE, 10}, {"abcdefgabcdefg", "ghi", PR_TRUE, 13}, {"abcdefgabcdefg", "AE", PR_FALSE, 0}, {"abcdefgabcdefg", "EI", PR_FALSE, 0}, {"abcdefgabcdefg", "IO", PR_FALSE, 0}, {"abcdefgabcdefg", "BCD", PR_FALSE, 0}, {"abcdefgabcdefg", "CBD", PR_FALSE, 0}, {"abcdefgabcdefg", "DBC", PR_FALSE, 0}, {"abcdefgabcdefg", "GHI", PR_FALSE, 0}}; int i; printf("Test 020 (PL_strprbrk) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv = PL_strprbrk(array[i].str, array[i].chrs); if (PR_FALSE == array[i].ret) { if ((char*)0 != rv) { printf("FAIL %d: %s,%s -> %.32s, not null\n", i, array[i].str ? array[i].str : "(null)", array[i].chrs ? array[i].chrs : "(null)", rv); return PR_FALSE; } } else { if ((char*)0 == rv) { printf("FAIL %d: %s,%s -> null, not +%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].chrs ? array[i].chrs : "(null)", array[i].off); return PR_FALSE; } if (&array[i].str[array[i].off] != rv) { printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].chrs ? array[i].chrs : "(null)", rv, array[i].str, array[i].off); return PR_FALSE; } } } printf("PASS\n"); return PR_TRUE; } /* PL_strnpbrk */ PRBool test_021(void) { static struct { const char* str; const char* chrs; PRUint32 max; PRBool ret; PRUint32 off; } array[] = {{(const char*)0, (const char*)0, 3, PR_FALSE, 0}, {(const char*)0, "abc", 3, PR_FALSE, 0}, {"abc", (const char*)0, 3, PR_FALSE, 0}, {"abcdefg", "", 3, PR_FALSE, 0}, {"", "aeiou", 3, PR_FALSE, 0}, {"abcdefg", "ae", 0, PR_FALSE, 0}, {"abcdefg", "ae", 1, PR_TRUE, 0}, {"abcdefg", "ae", 4, PR_TRUE, 0}, {"abcdefg", "ae", 5, PR_TRUE, 0}, {"abcdefg", "ae", 6, PR_TRUE, 0}, {"abcdefg", "ei", 4, PR_FALSE, 0}, {"abcdefg", "io", 10, PR_FALSE, 0}, {"abcdefg", "bcd", 2, PR_TRUE, 1}, {"abcdefg", "cbd", 2, PR_TRUE, 1}, {"abcdefg", "dbc", 2, PR_TRUE, 1}, {"abcdefg", "ghi", 6, PR_FALSE, 0}, {"abcdefg", "ghi", 7, PR_TRUE, 6}, {"abcdefg", "AE", 9, PR_FALSE, 0}, {"abcdefg", "EI", 9, PR_FALSE, 0}, {"abcdefg", "IO", 9, PR_FALSE, 0}, {"abcdefg", "BCD", 9, PR_FALSE, 0}, {"abcdefg", "CBD", 9, PR_FALSE, 0}, {"abcdefg", "DBC", 9, PR_FALSE, 0}, {"abcdefg", "GHI", 9, PR_FALSE, 0}, {"abcdefgabcdefg", "ae", 10, PR_TRUE, 0}, {"abcdefgabcdefg", "ei", 10, PR_TRUE, 4}, {"abcdefgabcdefg", "io", 10, PR_FALSE, 0}, {"abcdefgabcdefg", "bcd", 10, PR_TRUE, 1}, {"abcdefgabcdefg", "cbd", 10, PR_TRUE, 1}, {"abcdefgabcdefg", "dbc", 10, PR_TRUE, 1}, {"abcdefgabcdefg", "ghi", 10, PR_TRUE, 6}, {"abcdefgabcdefg", "AE", 10, PR_FALSE, 0}, {"abcdefgabcdefg", "EI", 10, PR_FALSE, 0}, {"abcdefgabcdefg", "IO", 10, PR_FALSE, 0}, {"abcdefgabcdefg", "BCD", 10, PR_FALSE, 0}, {"abcdefgabcdefg", "CBD", 10, PR_FALSE, 0}, {"abcdefgabcdefg", "DBC", 10, PR_FALSE, 0}, {"abcdefgabcdefg", "GHI", 10, PR_FALSE, 0}}; int i; printf("Test 021 (PL_strnpbrk) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv = PL_strnpbrk(array[i].str, array[i].chrs, array[i].max); if (PR_FALSE == array[i].ret) { if ((char*)0 != rv) { printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i, array[i].str ? array[i].str : "(null)", array[i].chrs ? array[i].chrs : "(null)", array[i].max, rv); return PR_FALSE; } } else { if ((char*)0 == rv) { printf("FAIL %d: %s,%s/%lu -> null, not +%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].chrs ? array[i].chrs : "(null)", array[i].max, array[i].off); return PR_FALSE; } if (&array[i].str[array[i].off] != rv) { printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].chrs ? array[i].chrs : "(null)", array[i].max, rv, array[i].str, array[i].off); return PR_FALSE; } } } printf("PASS\n"); return PR_TRUE; } /* PL_strnprbrk */ PRBool test_022(void) { static struct { const char* str; const char* chrs; PRUint32 max; PRBool ret; PRUint32 off; } array[] = {{(const char*)0, (const char*)0, 3, PR_FALSE, 0}, {(const char*)0, "abc", 3, PR_FALSE, 0}, {"abc", (const char*)0, 3, PR_FALSE, 0}, {"abcdefg", "", 3, PR_FALSE, 0}, {"", "aeiou", 3, PR_FALSE, 0}, {"abcdefg", "ae", 0, PR_FALSE, 0}, {"abcdefg", "ae", 1, PR_TRUE, 0}, {"abcdefg", "ae", 4, PR_TRUE, 0}, {"abcdefg", "ae", 5, PR_TRUE, 4}, {"abcdefg", "ae", 6, PR_TRUE, 4}, {"abcdefg", "ei", 4, PR_FALSE, 0}, {"abcdefg", "io", 10, PR_FALSE, 0}, {"abcdefg", "bcd", 2, PR_TRUE, 1}, {"abcdefg", "cbd", 2, PR_TRUE, 1}, {"abcdefg", "dbc", 2, PR_TRUE, 1}, {"abcdefg", "bcd", 3, PR_TRUE, 2}, {"abcdefg", "cbd", 3, PR_TRUE, 2}, {"abcdefg", "dbc", 3, PR_TRUE, 2}, {"abcdefg", "bcd", 5, PR_TRUE, 3}, {"abcdefg", "cbd", 5, PR_TRUE, 3}, {"abcdefg", "dbc", 5, PR_TRUE, 3}, {"abcdefg", "bcd", 15, PR_TRUE, 3}, {"abcdefg", "cbd", 15, PR_TRUE, 3}, {"abcdefg", "dbc", 15, PR_TRUE, 3}, {"abcdefg", "ghi", 6, PR_FALSE, 0}, {"abcdefg", "ghi", 7, PR_TRUE, 6}, {"abcdefg", "AE", 9, PR_FALSE, 0}, {"abcdefg", "EI", 9, PR_FALSE, 0}, {"abcdefg", "IO", 9, PR_FALSE, 0}, {"abcdefg", "BCD", 9, PR_FALSE, 0}, {"abcdefg", "CBD", 9, PR_FALSE, 0}, {"abcdefg", "DBC", 9, PR_FALSE, 0}, {"abcdefg", "GHI", 9, PR_FALSE, 0}, {"abcdefgabcdefg", "ae", 10, PR_TRUE, 7}, {"abcdefgabcdefg", "ei", 10, PR_TRUE, 4}, {"abcdefgabcdefg", "io", 10, PR_FALSE, 0}, {"abcdefgabcdefg", "bcd", 10, PR_TRUE, 9}, {"abcdefgabcdefg", "cbd", 10, PR_TRUE, 9}, {"abcdefgabcdefg", "dbc", 10, PR_TRUE, 9}, {"abcdefgabcdefg", "ghi", 10, PR_TRUE, 6}, {"abcdefgabcdefg", "AE", 10, PR_FALSE, 0}, {"abcdefgabcdefg", "EI", 10, PR_FALSE, 0}, {"abcdefgabcdefg", "IO", 10, PR_FALSE, 0}, {"abcdefgabcdefg", "BCD", 10, PR_FALSE, 0}, {"abcdefgabcdefg", "CBD", 10, PR_FALSE, 0}, {"abcdefgabcdefg", "DBC", 10, PR_FALSE, 0}, {"abcdefgabcdefg", "GHI", 10, PR_FALSE, 0}}; int i; printf("Test 022 (PL_strnprbrk) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv = PL_strnprbrk(array[i].str, array[i].chrs, array[i].max); if (PR_FALSE == array[i].ret) { if ((char*)0 != rv) { printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i, array[i].str ? array[i].str : "(null)", array[i].chrs ? array[i].chrs : "(null)", array[i].max, rv); return PR_FALSE; } } else { if ((char*)0 == rv) { printf("FAIL %d: %s,%s/%lu -> null, not +%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].chrs ? array[i].chrs : "(null)", array[i].max, array[i].off); return PR_FALSE; } if (&array[i].str[array[i].off] != rv) { printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].chrs ? array[i].chrs : "(null)", array[i].max, rv, array[i].str, array[i].off); return PR_FALSE; } } } printf("PASS\n"); return PR_TRUE; } /* PL_strstr */ PRBool test_023(void) { static struct { const char* str; const char* sub; PRBool ret; PRUint32 off; } array[] = {{(const char*)0, (const char*)0, PR_FALSE, 0}, {(const char*)0, "blah", PR_FALSE, 0}, {"blah-de-blah", (const char*)0, PR_FALSE, 0}, {"blah-de-blah", "blah", PR_TRUE, 0}, {"", "blah", PR_FALSE, 0}, {"blah-de-blah", "", PR_FALSE, 0}, {"abcdefg", "a", PR_TRUE, 0}, {"abcdefg", "c", PR_TRUE, 2}, {"abcdefg", "e", PR_TRUE, 4}, {"abcdefg", "g", PR_TRUE, 6}, {"abcdefg", "i", PR_FALSE, 0}, {"abcdefg", "ab", PR_TRUE, 0}, {"abcdefg", "cd", PR_TRUE, 2}, {"abcdefg", "ef", PR_TRUE, 4}, {"abcdefg", "gh", PR_FALSE, 0}, {"abcdabc", "bc", PR_TRUE, 1}, {"abcdefg", "abcdefg", PR_TRUE, 0}, {"abcdefgabcdefg", "a", PR_TRUE, 0}, {"abcdefgabcdefg", "c", PR_TRUE, 2}, {"abcdefgabcdefg", "e", PR_TRUE, 4}, {"abcdefgabcdefg", "g", PR_TRUE, 6}, {"abcdefgabcdefg", "i", PR_FALSE, 0}, {"abcdefgabcdefg", "ab", PR_TRUE, 0}, {"abcdefgabcdefg", "cd", PR_TRUE, 2}, {"abcdefgabcdefg", "ef", PR_TRUE, 4}, {"abcdefgabcdefg", "gh", PR_FALSE, 0}, {"abcdabcabcdabc", "bc", PR_TRUE, 1}, {"abcdefgabcdefg", "abcdefg", PR_TRUE, 0}, {"ABCDEFG", "a", PR_FALSE, 0}, {"ABCDEFG", "c", PR_FALSE, 0}, {"ABCDEFG", "e", PR_FALSE, 0}, {"ABCDEFG", "g", PR_FALSE, 0}, {"ABCDEFG", "i", PR_FALSE, 0}, {"ABCDEFG", "ab", PR_FALSE, 0}, {"ABCDEFG", "cd", PR_FALSE, 0}, {"ABCDEFG", "ef", PR_FALSE, 0}, {"ABCDEFG", "gh", PR_FALSE, 0}, {"ABCDABC", "bc", PR_FALSE, 0}, {"ABCDEFG", "abcdefg", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "a", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "c", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "e", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "g", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "i", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "ab", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "cd", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "ef", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "gh", PR_FALSE, 0}, {"ABCDABCABCDABC", "bc", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "abcdefg", PR_FALSE, 0}}; int i; printf("Test 023 (PL_strstr) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv = PL_strstr(array[i].str, array[i].sub); if (PR_FALSE == array[i].ret) { if ((char*)0 != rv) { printf("FAIL %d: %s,%s -> %.32s, not null\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", rv); return PR_FALSE; } } else { if ((char*)0 == rv) { printf("FAIL %d: %s,%s -> null, not 0x%x+%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", array[i].str, array[i].off); return PR_FALSE; } if (&array[i].str[array[i].off] != rv) { printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", rv, array[i].str, array[i].off); return PR_FALSE; } } } printf("PASS\n"); return PR_TRUE; } /* PL_strrstr */ PRBool test_024(void) { static struct { const char* str; const char* sub; PRBool ret; PRUint32 off; } array[] = {{(const char*)0, (const char*)0, PR_FALSE, 0}, {(const char*)0, "blah", PR_FALSE, 0}, {"blah-de-blah", (const char*)0, PR_FALSE, 0}, {"blah-de-blah", "blah", PR_TRUE, 8}, {"", "blah", PR_FALSE, 0}, {"blah-de-blah", "", PR_FALSE, 0}, {"abcdefg", "a", PR_TRUE, 0}, {"abcdefg", "c", PR_TRUE, 2}, {"abcdefg", "e", PR_TRUE, 4}, {"abcdefg", "g", PR_TRUE, 6}, {"abcdefg", "i", PR_FALSE, 0}, {"abcdefg", "ab", PR_TRUE, 0}, {"abcdefg", "cd", PR_TRUE, 2}, {"abcdefg", "ef", PR_TRUE, 4}, {"abcdefg", "gh", PR_FALSE, 0}, {"abcdabc", "bc", PR_TRUE, 5}, {"abcdefg", "abcdefg", PR_TRUE, 0}, {"abcdefgabcdefg", "a", PR_TRUE, 7}, {"abcdefgabcdefg", "c", PR_TRUE, 9}, {"abcdefgabcdefg", "e", PR_TRUE, 11}, {"abcdefgabcdefg", "g", PR_TRUE, 13}, {"abcdefgabcdefg", "i", PR_FALSE, 0}, {"abcdefgabcdefg", "ab", PR_TRUE, 7}, {"abcdefgabcdefg", "cd", PR_TRUE, 9}, {"abcdefgabcdefg", "ef", PR_TRUE, 11}, {"abcdefgabcdefg", "gh", PR_FALSE, 0}, {"abcdabcabcdabc", "bc", PR_TRUE, 12}, {"abcdefgabcdefg", "abcdefg", PR_TRUE, 7}, {"ABCDEFG", "a", PR_FALSE, 0}, {"ABCDEFG", "c", PR_FALSE, 0}, {"ABCDEFG", "e", PR_FALSE, 0}, {"ABCDEFG", "g", PR_FALSE, 0}, {"ABCDEFG", "i", PR_FALSE, 0}, {"ABCDEFG", "ab", PR_FALSE, 0}, {"ABCDEFG", "cd", PR_FALSE, 0}, {"ABCDEFG", "ef", PR_FALSE, 0}, {"ABCDEFG", "gh", PR_FALSE, 0}, {"ABCDABC", "bc", PR_FALSE, 0}, {"ABCDEFG", "abcdefg", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "a", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "c", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "e", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "g", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "i", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "ab", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "cd", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "ef", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "gh", PR_FALSE, 0}, {"ABCDABCABCDABC", "bc", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "abcdefg", PR_FALSE, 0}}; int i; printf("Test 024 (PL_strrstr) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv = PL_strrstr(array[i].str, array[i].sub); if (PR_FALSE == array[i].ret) { if ((char*)0 != rv) { printf("FAIL %d: %s,%s -> %.32s, not null\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", rv); return PR_FALSE; } } else { if ((char*)0 == rv) { printf("FAIL %d: %s,%s -> null, not 0x%x+%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", array[i].str, array[i].off); return PR_FALSE; } if (&array[i].str[array[i].off] != rv) { printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", rv, array[i].str, array[i].off); return PR_FALSE; } } } printf("PASS\n"); return PR_TRUE; } /* PL_strnstr */ PRBool test_025(void) { static struct { const char* str; const char* sub; PRUint32 max; PRBool ret; PRUint32 off; } array[] = {{(const char*)0, (const char*)0, 12, PR_FALSE, 0}, {(const char*)0, "blah", 12, PR_FALSE, 0}, {"blah-de-blah", (const char*)0, 12, PR_FALSE, 0}, {"blah-de-blah", "blah", 0, PR_FALSE, 0}, {"blah-de-blah", "blah", 2, PR_FALSE, 0}, {"blah-de-blah", "blah", 3, PR_FALSE, 0}, {"blah-de-blah", "blah", 4, PR_TRUE, 0}, {"blah-de-blah", "blah", 5, PR_TRUE, 0}, {"blah-de-blah", "blah", 12, PR_TRUE, 0}, {"", "blah", 12, PR_FALSE, 0}, {"blah-de-blah", "", 12, PR_FALSE, 0}, {"abcdefg", "a", 5, PR_TRUE, 0}, {"abcdefg", "c", 5, PR_TRUE, 2}, {"abcdefg", "e", 5, PR_TRUE, 4}, {"abcdefg", "g", 5, PR_FALSE, 0}, {"abcdefg", "i", 5, PR_FALSE, 0}, {"abcdefg", "ab", 5, PR_TRUE, 0}, {"abcdefg", "cd", 5, PR_TRUE, 2}, {"abcdefg", "ef", 5, PR_FALSE, 0}, {"abcdefg", "gh", 5, PR_FALSE, 0}, {"abcdabc", "bc", 5, PR_TRUE, 1}, {"abcdabc", "bc", 6, PR_TRUE, 1}, {"abcdabc", "bc", 7, PR_TRUE, 1}, {"abcdefg", "abcdefg", 6, PR_FALSE, 0}, {"abcdefg", "abcdefg", 7, PR_TRUE, 0}, {"abcdefg", "abcdefg", 8, PR_TRUE, 0}, {"abcdefgabcdefg", "a", 12, PR_TRUE, 0}, {"abcdefgabcdefg", "c", 12, PR_TRUE, 2}, {"abcdefgabcdefg", "e", 12, PR_TRUE, 4}, {"abcdefgabcdefg", "g", 12, PR_TRUE, 6}, {"abcdefgabcdefg", "i", 12, PR_FALSE, 0}, {"abcdefgabcdefg", "ab", 12, PR_TRUE, 0}, {"abcdefgabcdefg", "cd", 12, PR_TRUE, 2}, {"abcdefgabcdefg", "ef", 12, PR_TRUE, 4}, {"abcdefgabcdefg", "gh", 12, PR_FALSE, 0}, {"abcdabcabcdabc", "bc", 5, PR_TRUE, 1}, {"abcdabcabcdabc", "bc", 6, PR_TRUE, 1}, {"abcdabcabcdabc", "bc", 7, PR_TRUE, 1}, {"abcdefgabcdefg", "abcdefg", 6, PR_FALSE, 0}, {"abcdefgabcdefg", "abcdefg", 7, PR_TRUE, 0}, {"abcdefgabcdefg", "abcdefg", 8, PR_TRUE, 0}, {"ABCDEFG", "a", 5, PR_FALSE, 0}, {"ABCDEFG", "c", 5, PR_FALSE, 0}, {"ABCDEFG", "e", 5, PR_FALSE, 0}, {"ABCDEFG", "g", 5, PR_FALSE, 0}, {"ABCDEFG", "i", 5, PR_FALSE, 0}, {"ABCDEFG", "ab", 5, PR_FALSE, 0}, {"ABCDEFG", "cd", 5, PR_FALSE, 0}, {"ABCDEFG", "ef", 5, PR_FALSE, 0}, {"ABCDEFG", "gh", 5, PR_FALSE, 0}, {"ABCDABC", "bc", 5, PR_FALSE, 0}, {"ABCDABC", "bc", 6, PR_FALSE, 0}, {"ABCDABC", "bc", 7, PR_FALSE, 0}, {"ABCDEFG", "abcdefg", 6, PR_FALSE, 0}, {"ABCDEFG", "abcdefg", 7, PR_FALSE, 0}, {"ABCDEFG", "abcdefg", 8, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "a", 12, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "c", 12, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "e", 12, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "g", 12, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "i", 12, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "ab", 12, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "cd", 12, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "ef", 12, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "gh", 12, PR_FALSE, 0}, {"ABCDABCABCDABC", "bc", 5, PR_FALSE, 0}, {"ABCDABCABCDABC", "bc", 6, PR_FALSE, 0}, { "ABCDABCABCDABC", "bc", 7, PR_FALSE, }, {"ABCDEFGABCDEFG", "abcdefg", 6, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "abcdefg", 7, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "abcdefg", 8, PR_FALSE, 0}}; int i; printf("Test 025 (PL_strnstr) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv = PL_strnstr(array[i].str, array[i].sub, array[i].max); if (PR_FALSE == array[i].ret) { if ((char*)0 != rv) { printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", array[i].max, rv); return PR_FALSE; } } else { if ((char*)0 == rv) { printf("FAIL %d: %s,%s/%lu -> null, not 0x%x+%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", array[i].max, array[i].str, array[i].off); return PR_FALSE; } if (&array[i].str[array[i].off] != rv) { printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", array[i].max, rv, array[i].str, array[i].off); return PR_FALSE; } } } printf("PASS\n"); return PR_TRUE; } /* PL_strnrstr */ PRBool test_026(void) { static struct { const char* str; const char* sub; PRUint32 max; PRBool ret; PRUint32 off; } array[] = {{(const char*)0, (const char*)0, 12, PR_FALSE, 0}, {(const char*)0, "blah", 12, PR_FALSE, 0}, {"blah-de-blah", (const char*)0, 12, PR_FALSE, 0}, {"blah-de-blah", "blah", 0, PR_FALSE, 0}, {"blah-de-blah", "blah", 2, PR_FALSE, 0}, {"blah-de-blah", "blah", 3, PR_FALSE, 0}, {"blah-de-blah", "blah", 4, PR_TRUE, 0}, {"blah-de-blah", "blah", 5, PR_TRUE, 0}, {"blah-de-blah", "blah", 11, PR_TRUE, 0}, {"blah-de-blah", "blah", 12, PR_TRUE, 8}, {"blah-de-blah", "blah", 13, PR_TRUE, 8}, {"", "blah", 12, PR_FALSE, 0}, {"blah-de-blah", "", 12, PR_FALSE, 0}, {"abcdefg", "a", 5, PR_TRUE, 0}, {"abcdefg", "c", 5, PR_TRUE, 2}, {"abcdefg", "e", 5, PR_TRUE, 4}, {"abcdefg", "g", 5, PR_FALSE, 0}, {"abcdefg", "i", 5, PR_FALSE, 0}, {"abcdefg", "ab", 5, PR_TRUE, 0}, {"abcdefg", "cd", 5, PR_TRUE, 2}, {"abcdefg", "ef", 5, PR_FALSE, 0}, {"abcdefg", "gh", 5, PR_FALSE, 0}, {"abcdabc", "bc", 5, PR_TRUE, 1}, {"abcdabc", "bc", 6, PR_TRUE, 1}, {"abcdabc", "bc", 7, PR_TRUE, 5}, {"abcdefg", "abcdefg", 6, PR_FALSE, 0}, {"abcdefg", "abcdefg", 7, PR_TRUE, 0}, {"abcdefg", "abcdefg", 8, PR_TRUE, 0}, {"abcdefgabcdefg", "a", 12, PR_TRUE, 7}, {"abcdefgabcdefg", "c", 12, PR_TRUE, 9}, {"abcdefgabcdefg", "e", 12, PR_TRUE, 11}, {"abcdefgabcdefg", "g", 12, PR_TRUE, 6}, {"abcdefgabcdefg", "i", 12, PR_FALSE, 0}, {"abcdefgabcdefg", "ab", 12, PR_TRUE, 7}, {"abcdefgabcdefg", "cd", 12, PR_TRUE, 9}, {"abcdefgabcdefg", "ef", 12, PR_TRUE, 4}, {"abcdefgabcdefg", "gh", 12, PR_FALSE, 0}, {"abcdabcabcdabc", "bc", 12, PR_TRUE, 8}, {"abcdabcabcdabc", "bc", 13, PR_TRUE, 8}, {"abcdabcabcdabc", "bc", 14, PR_TRUE, 12}, {"abcdefgabcdefg", "abcdefg", 13, PR_TRUE, 0}, {"abcdefgabcdefg", "abcdefg", 14, PR_TRUE, 7}, {"abcdefgabcdefg", "abcdefg", 15, PR_TRUE, 7}, {"ABCDEFG", "a", 5, PR_FALSE, 0}, {"ABCDEFG", "c", 5, PR_FALSE, 0}, {"ABCDEFG", "e", 5, PR_FALSE, 0}, {"ABCDEFG", "g", 5, PR_FALSE, 0}, {"ABCDEFG", "i", 5, PR_FALSE, 0}, {"ABCDEFG", "ab", 5, PR_FALSE, 0}, {"ABCDEFG", "cd", 5, PR_FALSE, 0}, {"ABCDEFG", "ef", 5, PR_FALSE, 0}, {"ABCDEFG", "gh", 5, PR_FALSE, 0}, {"ABCDABC", "bc", 5, PR_FALSE, 0}, {"ABCDABC", "bc", 6, PR_FALSE, 0}, {"ABCDABC", "bc", 7, PR_FALSE, 0}, {"ABCDEFG", "abcdefg", 6, PR_FALSE, 0}, {"ABCDEFG", "abcdefg", 7, PR_FALSE, 0}, {"ABCDEFG", "abcdefg", 8, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "a", 12, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "c", 12, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "e", 12, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "g", 12, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "i", 12, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "ab", 12, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "cd", 12, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "ef", 12, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "gh", 12, PR_FALSE, 0}, {"ABCDABCABCDABC", "bc", 12, PR_FALSE, 0}, {"ABCDABCABCDABC", "bc", 13, PR_FALSE, 0}, {"ABCDABCABCDABC", "bc", 14, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "abcdefg", 13, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "abcdefg", 14, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "abcdefg", 15, PR_FALSE, 0}}; int i; printf("Test 026 (PL_strnrstr) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv = PL_strnrstr(array[i].str, array[i].sub, array[i].max); if (PR_FALSE == array[i].ret) { if ((char*)0 != rv) { printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", array[i].max, rv); return PR_FALSE; } } else { if ((char*)0 == rv) { printf("FAIL %d: %s,%s/%lu -> null, not 0x%x+%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", array[i].max, array[i].str, array[i].off); return PR_FALSE; } if (&array[i].str[array[i].off] != rv) { printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", array[i].max, rv, array[i].str, array[i].off); return PR_FALSE; } } } printf("PASS\n"); return PR_TRUE; } /* PL_strcasestr */ PRBool test_027(void) { static struct { const char* str; const char* sub; PRBool ret; PRUint32 off; } array[] = {{(const char*)0, (const char*)0, PR_FALSE, 0}, {(const char*)0, "blah", PR_FALSE, 0}, {"blah-de-blah", (const char*)0, PR_FALSE, 0}, {"blah-de-blah", "blah", PR_TRUE, 0}, {"", "blah", PR_FALSE, 0}, {"blah-de-blah", "", PR_FALSE, 0}, {"abcdefg", "a", PR_TRUE, 0}, {"abcdefg", "c", PR_TRUE, 2}, {"abcdefg", "e", PR_TRUE, 4}, {"abcdefg", "g", PR_TRUE, 6}, {"abcdefg", "i", PR_FALSE, 0}, {"abcdefg", "ab", PR_TRUE, 0}, {"abcdefg", "cd", PR_TRUE, 2}, {"abcdefg", "ef", PR_TRUE, 4}, {"abcdefg", "gh", PR_FALSE, 0}, {"abcdabc", "bc", PR_TRUE, 1}, {"abcdefg", "abcdefg", PR_TRUE, 0}, {"abcdefgabcdefg", "a", PR_TRUE, 0}, {"abcdefgabcdefg", "c", PR_TRUE, 2}, {"abcdefgabcdefg", "e", PR_TRUE, 4}, {"abcdefgabcdefg", "g", PR_TRUE, 6}, {"abcdefgabcdefg", "i", PR_FALSE, 0}, {"abcdefgabcdefg", "ab", PR_TRUE, 0}, {"abcdefgabcdefg", "cd", PR_TRUE, 2}, {"abcdefgabcdefg", "ef", PR_TRUE, 4}, {"abcdefgabcdefg", "gh", PR_FALSE, 0}, {"abcdabcabcdabc", "bc", PR_TRUE, 1}, {"abcdefgabcdefg", "abcdefg", PR_TRUE, 0}, {"ABCDEFG", "a", PR_TRUE, 0}, {"ABCDEFG", "c", PR_TRUE, 2}, {"ABCDEFG", "e", PR_TRUE, 4}, {"ABCDEFG", "g", PR_TRUE, 6}, {"ABCDEFG", "i", PR_FALSE, 0}, {"ABCDEFG", "ab", PR_TRUE, 0}, {"ABCDEFG", "cd", PR_TRUE, 2}, {"ABCDEFG", "ef", PR_TRUE, 4}, {"ABCDEFG", "gh", PR_FALSE, 0}, {"ABCDABC", "bc", PR_TRUE, 1}, {"ABCDEFG", "abcdefg", PR_TRUE, 0}, {"ABCDEFGABCDEFG", "a", PR_TRUE, 0}, {"ABCDEFGABCDEFG", "c", PR_TRUE, 2}, {"ABCDEFGABCDEFG", "e", PR_TRUE, 4}, {"ABCDEFGABCDEFG", "g", PR_TRUE, 6}, {"ABCDEFGABCDEFG", "i", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "ab", PR_TRUE, 0}, {"ABCDEFGABCDEFG", "cd", PR_TRUE, 2}, {"ABCDEFGABCDEFG", "ef", PR_TRUE, 4}, {"ABCDEFGABCDEFG", "gh", PR_FALSE, 0}, {"ABCDABCABCDABC", "bc", PR_TRUE, 1}, {"ABCDEFGABCDEFG", "abcdefg", PR_TRUE, 0}}; int i; printf("Test 027 (PL_strcasestr) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv = PL_strcasestr(array[i].str, array[i].sub); if (PR_FALSE == array[i].ret) { if ((char*)0 != rv) { printf("FAIL %d: %s,%s -> %.32s, not null\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", rv); return PR_FALSE; } } else { if ((char*)0 == rv) { printf("FAIL %d: %s,%s -> null, not 0x%x+%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", array[i].str, array[i].off); return PR_FALSE; } if (&array[i].str[array[i].off] != rv) { printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", rv, array[i].str, array[i].off); return PR_FALSE; } } } printf("PASS\n"); return PR_TRUE; } /* PL_strcaserstr */ PRBool test_028(void) { static struct { const char* str; const char* sub; PRBool ret; PRUint32 off; } array[] = {{(const char*)0, (const char*)0, PR_FALSE, 0}, {(const char*)0, "blah", PR_FALSE, 0}, {"blah-de-blah", (const char*)0, PR_FALSE, 0}, {"blah-de-blah", "blah", PR_TRUE, 8}, {"", "blah", PR_FALSE, 0}, {"blah-de-blah", "", PR_FALSE, 0}, {"abcdefg", "a", PR_TRUE, 0}, {"abcdefg", "c", PR_TRUE, 2}, {"abcdefg", "e", PR_TRUE, 4}, {"abcdefg", "g", PR_TRUE, 6}, {"abcdefg", "i", PR_FALSE, 0}, {"abcdefg", "ab", PR_TRUE, 0}, {"abcdefg", "cd", PR_TRUE, 2}, {"abcdefg", "ef", PR_TRUE, 4}, {"abcdefg", "gh", PR_FALSE, 0}, {"abcdabc", "bc", PR_TRUE, 5}, {"abcdefg", "abcdefg", PR_TRUE, 0}, {"abcdefgabcdefg", "a", PR_TRUE, 7}, {"abcdefgabcdefg", "c", PR_TRUE, 9}, {"abcdefgabcdefg", "e", PR_TRUE, 11}, {"abcdefgabcdefg", "g", PR_TRUE, 13}, {"abcdefgabcdefg", "i", PR_FALSE, 0}, {"abcdefgabcdefg", "ab", PR_TRUE, 7}, {"abcdefgabcdefg", "cd", PR_TRUE, 9}, {"abcdefgabcdefg", "ef", PR_TRUE, 11}, {"abcdefgabcdefg", "gh", PR_FALSE, 0}, {"abcdabcabcdabc", "bc", PR_TRUE, 12}, {"abcdefgabcdefg", "abcdefg", PR_TRUE, 7}, {"ABCDEFG", "a", PR_TRUE, 0}, {"ABCDEFG", "c", PR_TRUE, 2}, {"ABCDEFG", "e", PR_TRUE, 4}, {"ABCDEFG", "g", PR_TRUE, 6}, {"ABCDEFG", "i", PR_FALSE, 0}, {"ABCDEFG", "ab", PR_TRUE, 0}, {"ABCDEFG", "cd", PR_TRUE, 2}, {"ABCDEFG", "ef", PR_TRUE, 4}, {"ABCDEFG", "gh", PR_FALSE, 0}, {"ABCDABC", "bc", PR_TRUE, 5}, {"ABCDEFG", "abcdefg", PR_TRUE, 0}, {"ABCDEFGABCDEFG", "a", PR_TRUE, 7}, {"ABCDEFGABCDEFG", "c", PR_TRUE, 9}, {"ABCDEFGABCDEFG", "e", PR_TRUE, 11}, {"ABCDEFGABCDEFG", "g", PR_TRUE, 13}, {"ABCDEFGABCDEFG", "i", PR_FALSE, 0}, {"ABCDEFGABCDEFG", "ab", PR_TRUE, 7}, {"ABCDEFGABCDEFG", "cd", PR_TRUE, 9}, {"ABCDEFGABCDEFG", "ef", PR_TRUE, 11}, {"ABCDEFGABCDEFG", "gh", PR_FALSE, 0}, {"ABCDABCABCDABC", "bc", PR_TRUE, 12}, {"ABCDEFGABCDEFG", "abcdefg", PR_TRUE, 7}}; int i; printf("Test 028 (PL_strcaserstr) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv = PL_strcaserstr(array[i].str, array[i].sub); if (PR_FALSE == array[i].ret) { if ((char*)0 != rv) { printf("FAIL %d: %s,%s -> %.32s, not null\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", rv); return PR_FALSE; } } else { if ((char*)0 == rv) { printf("FAIL %d: %s,%s -> null, not 0x%x+%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", array[i].str, array[i].off); return PR_FALSE; } if (&array[i].str[array[i].off] != rv) { printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", rv, array[i].str, array[i].off); return PR_FALSE; } } } printf("PASS\n"); return PR_TRUE; } /* PL_strncasestr */ PRBool test_029(void) { static struct { const char* str; const char* sub; PRUint32 max; PRBool ret; PRUint32 off; } array[] = {{(const char*)0, (const char*)0, 12, PR_FALSE, 0}, {(const char*)0, "blah", 12, PR_FALSE, 0}, {"blah-de-blah", (const char*)0, 12, PR_FALSE, 0}, {"blah-de-blah", "blah", 0, PR_FALSE, 0}, {"blah-de-blah", "blah", 2, PR_FALSE, 0}, {"blah-de-blah", "blah", 3, PR_FALSE, 0}, {"blah-de-blah", "blah", 4, PR_TRUE, 0}, {"blah-de-blah", "blah", 5, PR_TRUE, 0}, {"blah-de-blah", "blah", 12, PR_TRUE, 0}, {"", "blah", 12, PR_FALSE, 0}, {"blah-de-blah", "", 12, PR_FALSE, 0}, {"abcdefg", "a", 5, PR_TRUE, 0}, {"abcdefg", "c", 5, PR_TRUE, 2}, {"abcdefg", "e", 5, PR_TRUE, 4}, {"abcdefg", "g", 5, PR_FALSE, 0}, {"abcdefg", "i", 5, PR_FALSE, 0}, {"abcdefg", "ab", 5, PR_TRUE, 0}, {"abcdefg", "cd", 5, PR_TRUE, 2}, {"abcdefg", "ef", 5, PR_FALSE, 0}, {"abcdefg", "gh", 5, PR_FALSE, 0}, {"abcdabc", "bc", 5, PR_TRUE, 1}, {"abcdabc", "bc", 6, PR_TRUE, 1}, {"abcdabc", "bc", 7, PR_TRUE, 1}, {"abcdefg", "abcdefg", 6, PR_FALSE, 0}, {"abcdefg", "abcdefg", 7, PR_TRUE, 0}, {"abcdefg", "abcdefg", 8, PR_TRUE, 0}, {"abcdefgabcdefg", "a", 12, PR_TRUE, 0}, {"abcdefgabcdefg", "c", 12, PR_TRUE, 2}, {"abcdefgabcdefg", "e", 12, PR_TRUE, 4}, {"abcdefgabcdefg", "g", 12, PR_TRUE, 6}, {"abcdefgabcdefg", "i", 12, PR_FALSE, 0}, {"abcdefgabcdefg", "ab", 12, PR_TRUE, 0}, {"abcdefgabcdefg", "cd", 12, PR_TRUE, 2}, {"abcdefgabcdefg", "ef", 12, PR_TRUE, 4}, {"abcdefgabcdefg", "gh", 12, PR_FALSE, 0}, {"abcdabcabcdabc", "bc", 5, PR_TRUE, 1}, {"abcdabcabcdabc", "bc", 6, PR_TRUE, 1}, {"abcdabcabcdabc", "bc", 7, PR_TRUE, 1}, {"abcdefgabcdefg", "abcdefg", 6, PR_FALSE, 0}, {"abcdefgabcdefg", "abcdefg", 7, PR_TRUE, 0}, {"abcdefgabcdefg", "abcdefg", 8, PR_TRUE, 0}, {"ABCDEFG", "a", 5, PR_TRUE, 0}, {"ABCDEFG", "c", 5, PR_TRUE, 2}, {"ABCDEFG", "e", 5, PR_TRUE, 4}, {"ABCDEFG", "g", 5, PR_FALSE, 0}, {"ABCDEFG", "i", 5, PR_FALSE, 0}, {"ABCDEFG", "ab", 5, PR_TRUE, 0}, {"ABCDEFG", "cd", 5, PR_TRUE, 2}, {"ABCDEFG", "ef", 5, PR_FALSE, 0}, {"ABCDEFG", "gh", 5, PR_FALSE, 0}, {"ABCDABC", "bc", 5, PR_TRUE, 1}, {"ABCDABC", "bc", 6, PR_TRUE, 1}, {"ABCDABC", "bc", 7, PR_TRUE, 1}, {"ABCDEFG", "abcdefg", 6, PR_FALSE, 0}, {"ABCDEFG", "abcdefg", 7, PR_TRUE, 0}, {"ABCDEFG", "abcdefg", 8, PR_TRUE, 0}, {"ABCDEFGABCDEFG", "a", 12, PR_TRUE, 0}, {"ABCDEFGABCDEFG", "c", 12, PR_TRUE, 2}, {"ABCDEFGABCDEFG", "e", 12, PR_TRUE, 4}, {"ABCDEFGABCDEFG", "g", 12, PR_TRUE, 6}, {"ABCDEFGABCDEFG", "i", 12, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "ab", 12, PR_TRUE, 0}, {"ABCDEFGABCDEFG", "cd", 12, PR_TRUE, 2}, {"ABCDEFGABCDEFG", "ef", 12, PR_TRUE, 4}, {"ABCDEFGABCDEFG", "gh", 12, PR_FALSE, 0}, {"ABCDABCABCDABC", "bc", 5, PR_TRUE, 1}, {"ABCDABCABCDABC", "bc", 6, PR_TRUE, 1}, {"ABCDABCABCDABC", "bc", 7, PR_TRUE, 1}, {"ABCDEFGABCDEFG", "abcdefg", 6, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "abcdefg", 7, PR_TRUE, 0}, {"ABCDEFGABCDEFG", "abcdefg", 8, PR_TRUE, 0}}; int i; printf("Test 029 (PL_strncasestr) ..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv = PL_strncasestr(array[i].str, array[i].sub, array[i].max); if (PR_FALSE == array[i].ret) { if ((char*)0 != rv) { printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", array[i].max, rv); return PR_FALSE; } } else { if ((char*)0 == rv) { printf("FAIL %d: %s,%s/%lu -> null, not 0x%x+%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", array[i].max, array[i].str, array[i].off); return PR_FALSE; } if (&array[i].str[array[i].off] != rv) { printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", array[i].max, rv, array[i].str, array[i].off); return PR_FALSE; } } } printf("PASS\n"); return PR_TRUE; } /* PL_strncaserstr */ PRBool test_030(void) { static struct { const char* str; const char* sub; PRUint32 max; PRBool ret; PRUint32 off; } array[] = {{(const char*)0, (const char*)0, 12, PR_FALSE, 0}, {(const char*)0, "blah", 12, PR_FALSE, 0}, {"blah-de-blah", (const char*)0, 12, PR_FALSE, 0}, {"blah-de-blah", "blah", 0, PR_FALSE, 0}, {"blah-de-blah", "blah", 2, PR_FALSE, 0}, {"blah-de-blah", "blah", 3, PR_FALSE, 0}, {"blah-de-blah", "blah", 4, PR_TRUE, 0}, {"blah-de-blah", "blah", 5, PR_TRUE, 0}, {"blah-de-blah", "blah", 11, PR_TRUE, 0}, {"blah-de-blah", "blah", 12, PR_TRUE, 8}, {"blah-de-blah", "blah", 13, PR_TRUE, 8}, {"", "blah", 12, PR_FALSE, 0}, {"blah-de-blah", "", 12, PR_FALSE, 0}, {"abcdefg", "a", 5, PR_TRUE, 0}, {"abcdefg", "c", 5, PR_TRUE, 2}, {"abcdefg", "e", 5, PR_TRUE, 4}, {"abcdefg", "g", 5, PR_FALSE, 0}, {"abcdefg", "i", 5, PR_FALSE, 0}, {"abcdefg", "ab", 5, PR_TRUE, 0}, {"abcdefg", "cd", 5, PR_TRUE, 2}, {"abcdefg", "ef", 5, PR_FALSE, 0}, {"abcdefg", "gh", 5, PR_FALSE, 0}, {"abcdabc", "bc", 5, PR_TRUE, 1}, {"abcdabc", "bc", 6, PR_TRUE, 1}, {"abcdabc", "bc", 7, PR_TRUE, 5}, {"abcdefg", "abcdefg", 6, PR_FALSE, 0}, {"abcdefg", "abcdefg", 7, PR_TRUE, 0}, {"abcdefg", "abcdefg", 8, PR_TRUE, 0}, {"abcdefgabcdefg", "a", 12, PR_TRUE, 7}, {"abcdefgabcdefg", "c", 12, PR_TRUE, 9}, {"abcdefgabcdefg", "e", 12, PR_TRUE, 11}, {"abcdefgabcdefg", "g", 12, PR_TRUE, 6}, {"abcdefgabcdefg", "i", 12, PR_FALSE, 0}, {"abcdefgabcdefg", "ab", 12, PR_TRUE, 7}, {"abcdefgabcdefg", "cd", 12, PR_TRUE, 9}, {"abcdefgabcdefg", "ef", 12, PR_TRUE, 4}, {"abcdefgabcdefg", "gh", 12, PR_FALSE, 0}, {"abcdabcabcdabc", "bc", 12, PR_TRUE, 8}, {"abcdabcabcdabc", "bc", 13, PR_TRUE, 8}, {"abcdabcabcdabc", "bc", 14, PR_TRUE, 12}, {"abcdefgabcdefg", "abcdefg", 13, PR_TRUE, 0}, {"abcdefgabcdefg", "abcdefg", 14, PR_TRUE, 7}, {"abcdefgabcdefg", "abcdefg", 15, PR_TRUE, 7}, {"ABCDEFG", "a", 5, PR_TRUE, 0}, {"ABCDEFG", "c", 5, PR_TRUE, 2}, {"ABCDEFG", "e", 5, PR_TRUE, 4}, {"ABCDEFG", "g", 5, PR_FALSE, 0}, {"ABCDEFG", "i", 5, PR_FALSE, 0}, {"ABCDEFG", "ab", 5, PR_TRUE, 0}, {"ABCDEFG", "cd", 5, PR_TRUE, 2}, {"ABCDEFG", "ef", 5, PR_FALSE, 0}, {"ABCDEFG", "gh", 5, PR_FALSE, 0}, {"ABCDABC", "bc", 5, PR_TRUE, 1}, {"ABCDABC", "bc", 6, PR_TRUE, 1}, {"ABCDABC", "bc", 7, PR_TRUE, 5}, {"ABCDEFG", "abcdefg", 6, PR_FALSE, 0}, {"ABCDEFG", "abcdefg", 7, PR_TRUE, 0}, {"ABCDEFG", "abcdefg", 8, PR_TRUE, 0}, {"ABCDEFGABCDEFG", "a", 12, PR_TRUE, 7}, {"ABCDEFGABCDEFG", "c", 12, PR_TRUE, 9}, {"ABCDEFGABCDEFG", "e", 12, PR_TRUE, 11}, {"ABCDEFGABCDEFG", "g", 12, PR_TRUE, 6}, {"ABCDEFGABCDEFG", "i", 12, PR_FALSE, 0}, {"ABCDEFGABCDEFG", "ab", 12, PR_TRUE, 7}, {"ABCDEFGABCDEFG", "cd", 12, PR_TRUE, 9}, {"ABCDEFGABCDEFG", "ef", 12, PR_TRUE, 4}, {"ABCDEFGABCDEFG", "gh", 12, PR_FALSE, 0}, {"ABCDABCABCDABC", "bc", 12, PR_TRUE, 8}, {"ABCDABCABCDABC", "bc", 13, PR_TRUE, 8}, {"ABCDABCABCDABC", "bc", 14, PR_TRUE, 12}, {"ABCDEFGABCDEFG", "abcdefg", 13, PR_TRUE, 0}, {"ABCDEFGABCDEFG", "abcdefg", 14, PR_TRUE, 7}, {"ABCDEFGABCDEFG", "abcdefg", 15, PR_TRUE, 7}}; int i; printf("Test 030 (PL_strncaserstr)..."); fflush(stdout); for (i = 0; i < sizeof(array) / sizeof(array[0]); i++) { char* rv = PL_strncaserstr(array[i].str, array[i].sub, array[i].max); if (PR_FALSE == array[i].ret) { if ((char*)0 != rv) { printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", array[i].max, rv); return PR_FALSE; } } else { if ((char*)0 == rv) { printf("FAIL %d: %s,%s/%lu -> null, not 0x%x+%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", array[i].max, array[i].str, array[i].off); return PR_FALSE; } if (&array[i].str[array[i].off] != rv) { printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i, array[i].str ? array[i].str : "(null)", array[i].sub ? array[i].sub : "(null)", array[i].max, rv, array[i].str, array[i].off); return PR_FALSE; } } } printf("PASS\n"); return PR_TRUE; } /* PL_strtok_r */ PRBool test_031(void) { static const char* tokens[] = { "wtc", "relyea", "nelsonb", "jpierre", "nicolson", "ian.mcgreer", "kirk.erickson", "sonja.mirtitsch", "mhein"}; static const char* seps[] = {", ", ",", " ", "\t", ",,,", " ,", " ", " \t\t", ","}; static const char s2[] = ", \t"; char string[1024]; char* s1; char* token; char* lasts; unsigned int i; printf("Test 031 (PL_strtok_r) ..."); fflush(stdout); /* Build the string. */ string[0] = '\0'; for (i = 0; i < sizeof(tokens) / sizeof(tokens[0]); i++) { PL_strcat(string, tokens[i]); PL_strcat(string, seps[i]); } /* Scan the string for tokens. */ i = 0; s1 = string; while ((token = PL_strtok_r(s1, s2, &lasts)) != NULL) { if (PL_strcmp(token, tokens[i]) != 0) { printf("FAIL wrong token scanned\n"); return PR_FALSE; } i++; s1 = NULL; } if (i != sizeof(tokens) / sizeof(tokens[0])) { printf("FAIL wrong number of tokens scanned\n"); return PR_FALSE; } printf("PASS\n"); return PR_TRUE; } int main(int argc, char* argv[]) { printf("Testing the Portable Library string functions:\n"); if (1 && test_001() && test_001() && test_002() && test_003() && test_004() && test_005() && test_006() && test_007() && test_008() && test_009() && test_010() && test_011() && test_012() && test_013() && test_014() && test_015() && test_016() && test_017() && test_018() && test_019() && test_020() && test_021() && test_022() && test_023() && test_024() && test_025() && test_026() && test_027() && test_028() && test_029() && test_030() && test_031()) { printf("Suite passed.\n"); return 0; } else { printf("Suite failed.\n"); return 1; } /*NOTREACHED*/ }