string.c revision 677833bc953b6cb418c701facbdcf4aa18d6c44e
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is the Netscape Portable Runtime (NSPR).
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998-2000
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "plstr.h"
#include "nspr.h"
#include <stdio.h>
/* PL_strlen */
{
static struct
{
const char *str;
} array[] =
{
{ (const char *)0, 0 },
{ "", 0 },
{ "a", 1 },
{ "abcdefg", 7 },
{ "abcdefg\0hijk", 7 }
};
int i;
{
{
printf("FAIL (%d: %s->%d, %d)\n", i,
return PR_FALSE;
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strnlen */
{
static struct
{
const char *str;
} 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("FAIL (%d: %s,%d->%d, %d)\n", i,
return PR_FALSE;
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strcpy */
{
static char buffer[ 1024 ];
static struct
{
const char *str;
char *dest;
char *rv;
} array[] =
{
{ (const char *)0, (char *)0, (char *)0, PR_FALSE },
{ "", (char *)0, (char *)0, PR_FALSE },
{ "a", (char *)0, (char *)0, PR_FALSE },
{ "abcdefg", (char *)0, (char *)0, PR_FALSE },
{ "wxyz\0abcdefg", (char *)0, (char *)0, PR_FALSE },
};
int i;
{
char *rv;
{
return PR_FALSE;
}
{
while( 1 )
{
if( *a != *b )
{
printf("FAIL %d: %s->%.32s\n", i,
return PR_FALSE;
}
if( (char)0 == *a ) break;
a++;
b++;
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strncpy */
{
static char buffer[ 1024 ];
static struct
{
const char *str;
char *dest;
char *rv;
const char *result;
} array[] =
{
};
int i;
{
char *rv;
int j;
for( j = 0; j < sizeof(buffer); j++ )
buffer[j] = '-';
{
return PR_FALSE;
}
{
while( *a )
{
if( *a != *b )
{
printf("FAIL %d: %s != %.32s\n", i,
return PR_FALSE;
}
a++;
b++;
}
{
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 */
{
static char buffer[ 1024 ];
static struct
{
const char *str;
char *dest;
char *rv;
const char *result;
} array[] =
{
{ (const char *)0, 0, (char *)0, (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 },
{ "", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
{ "a", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
{ "de", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
{ "jklmnopq", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
{ "a\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
{ "de\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
{ "jklmnopq\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
};
int i;
{
char *rv;
int j;
for( j = 0; j < sizeof(buffer); j++ )
buffer[j] = '-';
{
return PR_FALSE;
}
{
while( 1 )
{
if( *a != *b )
{
printf("FAIL %d: %s != %.32s\n", i,
return PR_FALSE;
}
if( (char)0 == *a ) break;
a++;
b++;
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strdup */
{
static const char *array[] =
{
(const char *)0,
"",
"a",
"abcdefg"
};
int i;
{
if( (char *)0 == rv )
{
return PR_FALSE;
}
if( (const char *)0 == array[i] )
{
if( (char)0 != *rv )
{
return PR_FALSE;
}
}
else
{
const char *a = array[i];
const char *b = (const char *)rv;
while( 1 )
{
if( *a != *b )
{
return PR_FALSE;
}
if( (char)0 == *a ) break;
a++;
b++;
}
}
PL_strfree(rv);
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strndup */
{
static struct
{
const char *str;
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;
{
const char *a;
const char *b;
if( (char *)0 == rv )
{
printf("FAIL %d: %s,%lu -> 0\n", i,
return PR_FALSE;
}
b = (const char *)rv;
while( 1 )
{
if( *a != *b )
{
return PR_FALSE;
}
if( (char)0 == *a ) break;
a++;
b++;
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strcat */
{
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;
{
char buffer[ 1024 ];
int j;
char *rv;
for( j = 0; j < sizeof(buffer); j++ )
buffer[j] = '-';
{
if( (char *)0 != rv )
{
printf("FAIL %d: %s+%s -> %.32s, not zero\n", i,
rv);
return PR_FALSE;
}
}
else
{
if( (char *)0 == rv )
{
printf("FAIL %d: %s+%s -> null, not %s\n", i,
return PR_FALSE;
}
else
{
const char *b = (const char *)rv;
while( 1 )
{
if( *a != *b )
{
printf("FAIL %d: %s+%s -> %.32s, not %s\n", i,
return PR_FALSE;
}
if( (char)0 == *a ) break;
a++;
b++;
}
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strncat */
{
static struct
{
const char *first;
const char *second;
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, "stuff", 0, PR_FALSE, (const char *)0 },
};
int i;
{
char buffer[ 1024 ];
int j;
char *rv;
for( j = 0; j < sizeof(buffer); j++ )
buffer[j] = '-';
{
if( (char *)0 != rv )
{
printf("FAIL %d: %s+%s/%lu -> %.32s, not zero\n", i,
return PR_FALSE;
}
}
else
{
if( (char *)0 == rv )
{
printf("FAIL %d: %s+%s/%lu -> null, not %s\n", i,
return PR_FALSE;
}
else
{
const char *b = (const char *)rv;
while( *a )
{
if( *a != *b )
{
printf("FAIL %d: %s+%s/%lu -> %.32s, not %s\n", i,
return PR_FALSE;
}
a++;
b++;
}
{
if( (char)0 != *b )
{
printf("FAIL %d: %s+%s/%lu -> not nulled\n", i,
return PR_FALSE;
}
}
else
{
if( (char)0 == *b )
{
printf("FAIL %d: %s+%s/%lu -> overrun\n", i,
return PR_FALSE;
}
}
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strcatn */
{
static struct
{
const char *first;
const char *second;
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;
{
char buffer[ 1024 ];
int j;
char *rv;
for( j = 0; j < sizeof(buffer); j++ )
buffer[j] = '-';
{
if( (char *)0 != rv )
{
printf("FAIL %d: %s+%s/%lu -> %.32s, not zero\n", i,
return PR_FALSE;
}
}
else
{
if( (char *)0 == rv )
{
printf("FAIL %d: %s+%s/%lu -> null, not %s\n", i,
return PR_FALSE;
}
else
{
const char *b = (const char *)rv;
while( 1 )
{
if( *a != *b )
{
printf("FAIL %d: %s+%s/%lu -> %.32s, not %s\n", i,
return PR_FALSE;
}
if( (char)0 == *a ) break;
a++;
b++;
}
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strcmp */
{
static struct
{
const char *one;
const char *two;
} 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;
{
{
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,
return PR_FALSE;
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strncmp */
{
static struct
{
const char *one;
const char *two;
} 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;
{
{
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,
return PR_FALSE;
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strcasecmp */
{
static struct
{
const char *one;
const char *two;
} 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;
{
{
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,
return PR_FALSE;
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strncasecmp */
{
static struct
{
const char *one;
const char *two;
} 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;
{
{
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,
return PR_FALSE;
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strchr */
{
static struct
{
const char *str;
char chr;
} array[] =
{
{ (const char *)0, 'a', PR_FALSE, 0 },
{ (const char *)0, '\0', PR_FALSE, 0 },
};
int i;
{
{
if( (char *)0 != rv )
{
return PR_FALSE;
}
}
else
{
if( (char *)0 == rv )
{
return PR_FALSE;
}
{
return PR_FALSE;
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strrchr */
{
static struct
{
const char *str;
char chr;
} array[] =
{
{ (const char *)0, 'a', PR_FALSE, 0 },
{ (const char *)0, '\0', PR_FALSE, 0 },
};
int i;
{
{
if( (char *)0 != rv )
{
return PR_FALSE;
}
}
else
{
if( (char *)0 == rv )
{
return PR_FALSE;
}
{
return PR_FALSE;
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strnchr */
{
static struct
{
const char *str;
char chr;
} array[] =
{
};
int i;
{
{
if( (char *)0 != rv )
{
return PR_FALSE;
}
}
else
{
if( (char *)0 == rv )
{
return PR_FALSE;
}
{
return PR_FALSE;
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strnrchr */
{
static struct
{
const char *str;
char chr;
} array[] =
{
};
int i;
{
{
if( (char *)0 != rv )
{
return PR_FALSE;
}
}
else
{
if( (char *)0 == rv )
{
return PR_FALSE;
}
{
return PR_FALSE;
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strpbrk */
{
static struct
{
const char *str;
const char *chrs;
} array[] =
{
{ (const char *)0, (const char *)0, PR_FALSE, 0 },
{ (const char *)0, "abc", PR_FALSE, 0 },
{ "abc", (const char *)0, PR_FALSE, 0 },
};
int i;
{
{
if( (char *)0 != rv )
{
printf("FAIL %d: %s,%s -> %.32s, not null\n", i,
rv);
return PR_FALSE;
}
}
else
{
if( (char *)0 == rv )
{
printf("FAIL %d: %s,%s -> null, not +%lu\n", i,
return PR_FALSE;
}
{
printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i,
return PR_FALSE;
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strprbrk */
{
static struct
{
const char *str;
const char *chrs;
} array[] =
{
{ (const char *)0, (const char *)0, PR_FALSE, 0 },
{ (const char *)0, "abc", PR_FALSE, 0 },
{ "abc", (const char *)0, PR_FALSE, 0 },
};
int i;
{
{
if( (char *)0 != rv )
{
printf("FAIL %d: %s,%s -> %.32s, not null\n", i,
rv);
return PR_FALSE;
}
}
else
{
if( (char *)0 == rv )
{
printf("FAIL %d: %s,%s -> null, not +%lu\n", i,
return PR_FALSE;
}
{
printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i,
return PR_FALSE;
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strnpbrk */
{
static struct
{
const char *str;
const char *chrs;
} array[] =
{
{ (const char *)0, (const char *)0, 3, PR_FALSE, 0 },
};
int i;
{
{
if( (char *)0 != rv )
{
printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i,
return PR_FALSE;
}
}
else
{
if( (char *)0 == rv )
{
printf("FAIL %d: %s,%s/%lu -> null, not +%lu\n", i,
return PR_FALSE;
}
{
printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i,
return PR_FALSE;
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strnprbrk */
{
static struct
{
const char *str;
const char *chrs;
} array[] =
{
{ (const char *)0, (const char *)0, 3, PR_FALSE, 0 },
};
int i;
{
{
if( (char *)0 != rv )
{
printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i,
return PR_FALSE;
}
}
else
{
if( (char *)0 == rv )
{
printf("FAIL %d: %s,%s/%lu -> null, not +%lu\n", i,
return PR_FALSE;
}
{
printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i,
return PR_FALSE;
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strstr */
{
static struct
{
const char *str;
const char *sub;
} 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 },
};
int i;
{
{
if( (char *)0 != rv )
{
printf("FAIL %d: %s,%s -> %.32s, not null\n", i,
rv);
return PR_FALSE;
}
}
else
{
if( (char *)0 == rv )
{
printf("FAIL %d: %s,%s -> null, not 0x%x+%lu\n", i,
return PR_FALSE;
}
{
printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i,
return PR_FALSE;
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strrstr */
{
static struct
{
const char *str;
const char *sub;
} 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 },
};
int i;
{
{
if( (char *)0 != rv )
{
printf("FAIL %d: %s,%s -> %.32s, not null\n", i,
rv);
return PR_FALSE;
}
}
else
{
if( (char *)0 == rv )
{
printf("FAIL %d: %s,%s -> null, not 0x%x+%lu\n", i,
return PR_FALSE;
}
{
printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i,
return PR_FALSE;
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strnstr */
{
static struct
{
const char *str;
const char *sub;
} array[] =
{
{ (const char *)0, (const char *)0, 12, PR_FALSE, 0 },
};
int i;
{
{
if( (char *)0 != rv )
{
printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i,
return PR_FALSE;
}
}
else
{
if( (char *)0 == rv )
{
printf("FAIL %d: %s,%s/%lu -> null, not 0x%x+%lu\n", i,
return PR_FALSE;
}
{
printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i,
return PR_FALSE;
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strnrstr */
{
static struct
{
const char *str;
const char *sub;
} array[] =
{
{ (const char *)0, (const char *)0, 12, PR_FALSE, 0 },
};
int i;
{
{
if( (char *)0 != rv )
{
printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i,
return PR_FALSE;
}
}
else
{
if( (char *)0 == rv )
{
printf("FAIL %d: %s,%s/%lu -> null, not 0x%x+%lu\n", i,
return PR_FALSE;
}
{
printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i,
return PR_FALSE;
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strcasestr */
{
static struct
{
const char *str;
const char *sub;
} 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 },
};
int i;
{
{
if( (char *)0 != rv )
{
printf("FAIL %d: %s,%s -> %.32s, not null\n", i,
rv);
return PR_FALSE;
}
}
else
{
if( (char *)0 == rv )
{
printf("FAIL %d: %s,%s -> null, not 0x%x+%lu\n", i,
return PR_FALSE;
}
{
printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i,
return PR_FALSE;
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strcaserstr */
{
static struct
{
const char *str;
const char *sub;
} 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 },
};
int i;
{
{
if( (char *)0 != rv )
{
printf("FAIL %d: %s,%s -> %.32s, not null\n", i,
rv);
return PR_FALSE;
}
}
else
{
if( (char *)0 == rv )
{
printf("FAIL %d: %s,%s -> null, not 0x%x+%lu\n", i,
return PR_FALSE;
}
{
printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i,
return PR_FALSE;
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strncasestr */
{
static struct
{
const char *str;
const char *sub;
} array[] =
{
{ (const char *)0, (const char *)0, 12, PR_FALSE, 0 },
};
int i;
{
{
if( (char *)0 != rv )
{
printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i,
return PR_FALSE;
}
}
else
{
if( (char *)0 == rv )
{
printf("FAIL %d: %s,%s/%lu -> null, not 0x%x+%lu\n", i,
return PR_FALSE;
}
{
printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i,
return PR_FALSE;
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strncaserstr */
{
static struct
{
const char *str;
const char *sub;
} array[] =
{
{ (const char *)0, (const char *)0, 12, PR_FALSE, 0 },
};
int i;
{
{
if( (char *)0 != rv )
{
printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i,
return PR_FALSE;
}
}
else
{
if( (char *)0 == rv )
{
printf("FAIL %d: %s,%s/%lu -> null, not 0x%x+%lu\n", i,
return PR_FALSE;
}
{
printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i,
return PR_FALSE;
}
}
}
printf("PASS\n");
return PR_TRUE;
}
/* PL_strtok_r */
{
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;
/* Build the string. */
string[0] = '\0';
{
}
/* Scan the string for tokens. */
i = 0;
{
{
printf("FAIL wrong token scanned\n");
return PR_FALSE;
}
i++;
}
{
printf("FAIL wrong number of tokens scanned\n");
return PR_FALSE;
}
printf("PASS\n");
return PR_TRUE;
}
int
(
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*/
}