1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/nsprpub/lib/tests/string.c Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,3084 @@
1.4 +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
1.5 +/* This Source Code Form is subject to the terms of the Mozilla Public
1.6 + * License, v. 2.0. If a copy of the MPL was not distributed with this
1.7 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
1.8 +
1.9 +#include "plstr.h"
1.10 +#include "nspr.h"
1.11 +
1.12 +#include <stdio.h>
1.13 +
1.14 +/* PL_strlen */
1.15 +PRBool test_001(void)
1.16 +{
1.17 + static struct
1.18 + {
1.19 + const char *str;
1.20 + PRUint32 len;
1.21 + } array[] =
1.22 + {
1.23 + { (const char *)0, 0 },
1.24 + { "", 0 },
1.25 + { "a", 1 },
1.26 + { "abcdefg", 7 },
1.27 + { "abcdefg\0hijk", 7 }
1.28 + };
1.29 +
1.30 + int i;
1.31 +
1.32 + printf("Test 001 (PL_strlen) ..."); fflush(stdout);
1.33 +
1.34 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.35 + {
1.36 + if( PL_strlen(array[i].str) != array[i].len )
1.37 + {
1.38 + printf("FAIL (%d: %s->%d, %d)\n", i,
1.39 + array[i].str ? array[i].str : "(null)",
1.40 + PL_strlen(array[i].str), array[i].len);
1.41 + return PR_FALSE;
1.42 + }
1.43 + }
1.44 +
1.45 + printf("PASS\n");
1.46 + return PR_TRUE;
1.47 +}
1.48 +
1.49 +/* PL_strnlen */
1.50 +PRBool test_002(void)
1.51 +{
1.52 + static struct
1.53 + {
1.54 + const char *str;
1.55 + PRUint32 max;
1.56 + PRUint32 len;
1.57 + } array[] =
1.58 + {
1.59 + { (const char *)0, 0, 0 },
1.60 + { (const char *)0, 12, 0 },
1.61 + { "", 0, 0 },
1.62 + { "", 12, 0 },
1.63 + { "a", 0, 0 },
1.64 + { "a", 1, 1 },
1.65 + { "a", 12, 1 },
1.66 + { "abcdefg", 0, 0 },
1.67 + { "abcdefg", 1, 1 },
1.68 + { "abcdefg", 7, 7 },
1.69 + { "abcdefg", 12, 7 },
1.70 + { "abcdefg\0hijk", 0, 0 },
1.71 + { "abcdefg\0hijk", 1, 1 },
1.72 + { "abcdefg\0hijk", 7, 7 },
1.73 + { "abcdefg\0hijk", 12, 7 },
1.74 + };
1.75 +
1.76 + int i;
1.77 +
1.78 + printf("Test 002 (PL_strnlen) ..."); fflush(stdout);
1.79 +
1.80 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.81 + {
1.82 + if( PL_strnlen(array[i].str, array[i].max) != array[i].len )
1.83 + {
1.84 + printf("FAIL (%d: %s,%d->%d, %d)\n", i,
1.85 + array[i].str ? array[i].str : "(null)", array[i].max,
1.86 + PL_strnlen(array[i].str, array[i].max), array[i].len);
1.87 + return PR_FALSE;
1.88 + }
1.89 + }
1.90 +
1.91 + printf("PASS\n");
1.92 + return PR_TRUE;
1.93 +}
1.94 +
1.95 +/* PL_strcpy */
1.96 +PRBool test_003(void)
1.97 +{
1.98 + static char buffer[ 1024 ];
1.99 +
1.100 + static struct
1.101 + {
1.102 + const char *str;
1.103 + char *dest;
1.104 + char *rv;
1.105 + PRBool comp;
1.106 + } array[] =
1.107 + {
1.108 + { (const char *)0, (char *)0, (char *)0, PR_FALSE },
1.109 + { (const char *)0, buffer, (char *)0, PR_FALSE },
1.110 + { "", (char *)0, (char *)0, PR_FALSE },
1.111 + { "", buffer, buffer, PR_TRUE },
1.112 + { "a", (char *)0, (char *)0, PR_FALSE },
1.113 + { "a", buffer, buffer, PR_TRUE },
1.114 + { "abcdefg", (char *)0, (char *)0, PR_FALSE },
1.115 + { "abcdefg", buffer, buffer, PR_TRUE },
1.116 + { "wxyz\0abcdefg", (char *)0, (char *)0, PR_FALSE },
1.117 + { "wxyz\0abcdefg", buffer, buffer, PR_TRUE }
1.118 + };
1.119 +
1.120 + int i;
1.121 +
1.122 + printf("Test 003 (PL_strcpy) ..."); fflush(stdout);
1.123 +
1.124 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.125 + {
1.126 + char *rv;
1.127 + const char *a = array[i].str;
1.128 + const char *b = (const char *)array[i].dest;
1.129 +
1.130 + rv = PL_strcpy(array[i].dest, array[i].str);
1.131 + if( array[i].rv != rv )
1.132 + {
1.133 + printf("FAIL %d: (0x%x, %s)->0x%x\n", i, array[i].dest,
1.134 + array[i].str ? array[i].str : "(null)", rv);
1.135 + return PR_FALSE;
1.136 + }
1.137 +
1.138 + if( array[i].comp )
1.139 + {
1.140 + while( 1 )
1.141 + {
1.142 + if( *a != *b )
1.143 + {
1.144 + printf("FAIL %d: %s->%.32s\n", i,
1.145 + array[i].str ? array[i].str : "(null)",
1.146 + array[i].dest ? array[i].dest : "(null)");
1.147 + return PR_FALSE;
1.148 + }
1.149 +
1.150 + if( (char)0 == *a ) break;
1.151 +
1.152 + a++;
1.153 + b++;
1.154 + }
1.155 + }
1.156 + }
1.157 +
1.158 + printf("PASS\n");
1.159 + return PR_TRUE;
1.160 +}
1.161 +
1.162 +/* PL_strncpy */
1.163 +PRBool test_004(void)
1.164 +{
1.165 + static char buffer[ 1024 ];
1.166 +
1.167 + static struct
1.168 + {
1.169 + const char *str;
1.170 + PRUint32 len;
1.171 + char *dest;
1.172 + char *rv;
1.173 + PRBool comp;
1.174 + const char *result;
1.175 + PRBool nulled;
1.176 + } array[] =
1.177 + {
1.178 + { (const char *)0, 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.179 + { (const char *)0, 0, buffer, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.180 + { (const char *)0, 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.181 + { (const char *)0, 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.182 + { (const char *)0, 1, buffer, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.183 + { (const char *)0, 7, buffer, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.184 + { "", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.185 + { "", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
1.186 + { "", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.187 + { "", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.188 + { "", 1, buffer, buffer, PR_TRUE, "", PR_TRUE },
1.189 + { "", 7, buffer, buffer, PR_TRUE, "", PR_TRUE },
1.190 + { "a", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.191 + { "a", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
1.192 + { "a", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.193 + { "a", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.194 + { "b", 1, buffer, buffer, PR_TRUE, "b", PR_FALSE },
1.195 + { "c", 7, buffer, buffer, PR_TRUE, "c", PR_TRUE },
1.196 + { "de", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.197 + { "de", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
1.198 + { "de", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.199 + { "de", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.200 + { "fg", 1, buffer, buffer, PR_TRUE, "f", PR_FALSE },
1.201 + { "hi", 7, buffer, buffer, PR_TRUE, "hi", PR_TRUE },
1.202 + { "jklmnopq", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.203 + { "jklmnopq", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
1.204 + { "jklmnopq", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.205 + { "jklmnopq", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.206 + { "rstuvwxy", 1, buffer, buffer, PR_TRUE, "r", PR_FALSE },
1.207 + { "zABCDEFG", 7, buffer, buffer, PR_TRUE, "zABCDEF", PR_FALSE },
1.208 + { "a\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.209 + { "a\0XXX", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
1.210 + { "a\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.211 + { "a\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.212 + { "b\0XXX", 1, buffer, buffer, PR_TRUE, "b", PR_FALSE },
1.213 + { "c\0XXX", 7, buffer, buffer, PR_TRUE, "c", PR_TRUE },
1.214 + { "de\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.215 + { "de\0XXX", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
1.216 + { "de\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.217 + { "de\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.218 + { "fg\0XXX", 1, buffer, buffer, PR_TRUE, "f", PR_FALSE },
1.219 + { "hi\0XXX", 7, buffer, buffer, PR_TRUE, "hi", PR_TRUE },
1.220 + { "jklmnopq\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.221 + { "jklmnopq\0XXX", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
1.222 + { "jklmnopq\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.223 + { "jklmnopq\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
1.224 + { "rstuvwxy\0XXX", 1, buffer, buffer, PR_TRUE, "r", PR_FALSE },
1.225 + { "zABCDEFG\0XXX", 7, buffer, buffer, PR_TRUE, "zABCDEF", PR_FALSE },
1.226 + };
1.227 +
1.228 + int i;
1.229 +
1.230 + printf("Test 004 (PL_strncpy) ..."); fflush(stdout);
1.231 +
1.232 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.233 + {
1.234 + char *rv;
1.235 + int j;
1.236 +
1.237 + for( j = 0; j < sizeof(buffer); j++ )
1.238 + buffer[j] = '-';
1.239 +
1.240 + rv = PL_strncpy(array[i].dest, array[i].str, array[i].len);
1.241 + if( array[i].rv != rv )
1.242 + {
1.243 + printf("FAIL %d: (0x%x, %s, %lu)->0x%x\n", i, array[i].dest,
1.244 + array[i].str ? array[i].str : "(null)", array[i].len, rv);
1.245 + return PR_FALSE;
1.246 + }
1.247 +
1.248 + if( array[i].comp )
1.249 + {
1.250 + const char *a = array[i].result;
1.251 + const char *b = array[i].dest;
1.252 +
1.253 + while( *a )
1.254 + {
1.255 + if( *a != *b )
1.256 + {
1.257 + printf("FAIL %d: %s != %.32s\n", i,
1.258 + array[i].result, array[i].dest);
1.259 + return PR_FALSE;
1.260 + }
1.261 +
1.262 + a++;
1.263 + b++;
1.264 + }
1.265 +
1.266 + if( array[i].nulled )
1.267 + {
1.268 + if( *b != '\0' )
1.269 + {
1.270 + printf("FAIL %d: not terminated\n", i);
1.271 + return PR_FALSE;
1.272 + }
1.273 + }
1.274 + else
1.275 + {
1.276 + if( *b != '-' )
1.277 + {
1.278 + printf("FAIL %d: overstepped\n", i);
1.279 + return PR_FALSE;
1.280 + }
1.281 + }
1.282 + }
1.283 + }
1.284 +
1.285 + printf("PASS\n");
1.286 + return PR_TRUE;
1.287 +}
1.288 +
1.289 +/* PL_strncpyz */
1.290 +PRBool test_005(void)
1.291 +{
1.292 + static char buffer[ 1024 ];
1.293 +
1.294 + static struct
1.295 + {
1.296 + const char *str;
1.297 + PRUint32 len;
1.298 + char *dest;
1.299 + char *rv;
1.300 + PRBool comp;
1.301 + const char *result;
1.302 + } array[] =
1.303 + {
1.304 + { (const char *)0, 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.305 + { (const char *)0, 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
1.306 + { (const char *)0, 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.307 + { (const char *)0, 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.308 + { (const char *)0, 1, buffer, (char *)0, PR_FALSE, (const char *)0 },
1.309 + { (const char *)0, 7, buffer, (char *)0, PR_FALSE, (const char *)0 },
1.310 + { "", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.311 + { "", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
1.312 + { "", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.313 + { "", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.314 + { "", 1, buffer, buffer, PR_TRUE, "" },
1.315 + { "", 7, buffer, buffer, PR_TRUE, "" },
1.316 + { "a", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.317 + { "a", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
1.318 + { "a", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.319 + { "a", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.320 + { "b", 1, buffer, buffer, PR_TRUE, "" },
1.321 + { "c", 7, buffer, buffer, PR_TRUE, "c" },
1.322 + { "de", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.323 + { "de", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
1.324 + { "de", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.325 + { "de", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.326 + { "fg", 1, buffer, buffer, PR_TRUE, "" },
1.327 + { "hi", 7, buffer, buffer, PR_TRUE, "hi" },
1.328 + { "jklmnopq", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.329 + { "jklmnopq", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
1.330 + { "jklmnopq", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.331 + { "jklmnopq", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.332 + { "rstuvwxy", 1, buffer, buffer, PR_TRUE, "" },
1.333 + { "zABCDEFG", 7, buffer, buffer, PR_TRUE, "zABCDE" },
1.334 + { "a\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.335 + { "a\0XXX", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
1.336 + { "a\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.337 + { "a\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.338 + { "b\0XXX", 1, buffer, buffer, PR_TRUE, "" },
1.339 + { "c\0XXX", 7, buffer, buffer, PR_TRUE, "c" },
1.340 + { "de\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.341 + { "de\0XXX", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
1.342 + { "de\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.343 + { "de\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.344 + { "fg\0XXX", 1, buffer, buffer, PR_TRUE, "" },
1.345 + { "hi\0XXX", 7, buffer, buffer, PR_TRUE, "hi" },
1.346 + { "jklmnopq\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.347 + { "jklmnopq\0XXX", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
1.348 + { "jklmnopq\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.349 + { "jklmnopq\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
1.350 + { "rstuvwxy\0XXX", 1, buffer, buffer, PR_TRUE, "" },
1.351 + { "zABCDEFG\0XXX", 7, buffer, buffer, PR_TRUE, "zABCDE" },
1.352 + };
1.353 +
1.354 + int i;
1.355 +
1.356 + printf("Test 005 (PL_strncpyz) ..."); fflush(stdout);
1.357 +
1.358 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.359 + {
1.360 + char *rv;
1.361 + int j;
1.362 +
1.363 + for( j = 0; j < sizeof(buffer); j++ )
1.364 + buffer[j] = '-';
1.365 +
1.366 + rv = PL_strncpyz(array[i].dest, array[i].str, array[i].len);
1.367 + if( array[i].rv != rv )
1.368 + {
1.369 + printf("FAIL %d: (0x%x, %s, %lu)->0x%x\n", i, array[i].dest,
1.370 + array[i].str ? array[i].str : "(null)", array[i].len, rv);
1.371 + return PR_FALSE;
1.372 + }
1.373 +
1.374 + if( array[i].comp )
1.375 + {
1.376 + const char *a = array[i].result;
1.377 + const char *b = array[i].dest;
1.378 +
1.379 + while( 1 )
1.380 + {
1.381 + if( *a != *b )
1.382 + {
1.383 + printf("FAIL %d: %s != %.32s\n", i,
1.384 + array[i].result, array[i].dest);
1.385 + return PR_FALSE;
1.386 + }
1.387 +
1.388 + if( (char)0 == *a ) break;
1.389 +
1.390 + a++;
1.391 + b++;
1.392 + }
1.393 + }
1.394 + }
1.395 +
1.396 + printf("PASS\n");
1.397 + return PR_TRUE;
1.398 +}
1.399 +
1.400 +/* PL_strdup */
1.401 +PRBool test_006(void)
1.402 +{
1.403 + static const char *array[] =
1.404 + {
1.405 + (const char *)0,
1.406 + "",
1.407 + "a",
1.408 + "abcdefg"
1.409 + };
1.410 +
1.411 + int i;
1.412 +
1.413 + printf("Test 006 (PL_strdup) ..."); fflush(stdout);
1.414 +
1.415 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.416 + {
1.417 + char *rv = PL_strdup(array[i]);
1.418 +
1.419 + if( (char *)0 == rv )
1.420 + {
1.421 + printf("FAIL %d: 0x%x -> 0\n", i, array[i]);
1.422 + return PR_FALSE;
1.423 + }
1.424 +
1.425 + if( (const char *)0 == array[i] )
1.426 + {
1.427 + if( (char)0 != *rv )
1.428 + {
1.429 + printf("FAIL %d: (const char *)0 -> %.32s\n", i, rv);
1.430 + return PR_FALSE;
1.431 + }
1.432 + }
1.433 + else
1.434 + {
1.435 + const char *a = array[i];
1.436 + const char *b = (const char *)rv;
1.437 +
1.438 + while( 1 )
1.439 + {
1.440 + if( *a != *b )
1.441 + {
1.442 + printf("FAIL %d: %s != %.32s\n", i, array[i], rv);
1.443 + return PR_FALSE;
1.444 + }
1.445 +
1.446 + if( (char)0 == *a ) break;
1.447 +
1.448 + a++;
1.449 + b++;
1.450 + }
1.451 +
1.452 + }
1.453 + PL_strfree(rv);
1.454 + }
1.455 +
1.456 + printf("PASS\n");
1.457 + return PR_TRUE;
1.458 +}
1.459 +
1.460 +/* PL_strndup */
1.461 +PRBool test_007(void)
1.462 +{
1.463 + static struct
1.464 + {
1.465 + const char *str;
1.466 + PRUint32 len;
1.467 + const char *result;
1.468 + } array[] =
1.469 + {
1.470 + { (const char *)0, 0, "" },
1.471 + { (const char *)0, 1, "" },
1.472 + { (const char *)0, 7, "" },
1.473 + { "", 0, "" },
1.474 + { "", 1, "" },
1.475 + { "", 7, "" },
1.476 + { "a", 0, "" },
1.477 + { "a", 1, "a" },
1.478 + { "a", 7, "a" },
1.479 + { "ab", 0, "" },
1.480 + { "ab", 1, "a" },
1.481 + { "ab", 7, "ab" },
1.482 + { "abcdefg", 0, "" },
1.483 + { "abcdefg", 1, "a" },
1.484 + { "abcdefg", 7, "abcdefg" },
1.485 + { "abcdefghijk", 0, "" },
1.486 + { "abcdefghijk", 1, "a" },
1.487 + { "abcdefghijk", 7, "abcdefg" },
1.488 + { "abcdef\0ghijk", 0, "" },
1.489 + { "abcdef\0ghijk", 1, "a" },
1.490 + { "abcdef\0ghijk", 7, "abcdef" }
1.491 + };
1.492 +
1.493 + int i;
1.494 +
1.495 + printf("Test 007 (PL_strndup) ..."); fflush(stdout);
1.496 +
1.497 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.498 + {
1.499 + char *rv = PL_strndup(array[i].str, array[i].len);
1.500 + const char *a;
1.501 + const char *b;
1.502 +
1.503 + if( (char *)0 == rv )
1.504 + {
1.505 + printf("FAIL %d: %s,%lu -> 0\n", i,
1.506 + array[i].str ? array[i].str : "(null)", array[i].len);
1.507 + return PR_FALSE;
1.508 + }
1.509 +
1.510 + a = array[i].result;
1.511 + b = (const char *)rv;
1.512 +
1.513 + while( 1 )
1.514 + {
1.515 + if( *a != *b )
1.516 + {
1.517 + printf("FAIL %d: %s != %.32s\n", i, array[i].result, rv);
1.518 + return PR_FALSE;
1.519 + }
1.520 +
1.521 + if( (char)0 == *a ) break;
1.522 +
1.523 + a++;
1.524 + b++;
1.525 + }
1.526 +
1.527 + free(rv);
1.528 + }
1.529 +
1.530 + printf("PASS\n");
1.531 + return PR_TRUE;
1.532 +}
1.533 +
1.534 +/* PL_strcat */
1.535 +PRBool test_008(void)
1.536 +{
1.537 + static struct
1.538 + {
1.539 + const char *first;
1.540 + const char *second;
1.541 + const char *result;
1.542 + } array[] =
1.543 + {
1.544 + { (const char *)0, (const char *)0, (const char *)0 },
1.545 + { (const char *)0, "xyz", (const char *)0 },
1.546 + { "", (const char *)0, "" },
1.547 + { "", "", "" },
1.548 + { "ab", "", "ab" },
1.549 + { "cd", "ef", "cdef" },
1.550 + { "gh\0X", "", "gh" },
1.551 + { "ij\0X", "kl", "ijkl" },
1.552 + { "mn\0X", "op\0X", "mnop" },
1.553 + { "qr", "st\0X", "qrst" },
1.554 + { "uv\0X", "wx\0X", "uvwx" }
1.555 + };
1.556 +
1.557 + int i;
1.558 +
1.559 + printf("Test 008 (PL_strcat) ..."); fflush(stdout);
1.560 +
1.561 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.562 + {
1.563 + char buffer[ 1024 ];
1.564 + int j;
1.565 + char *rv;
1.566 +
1.567 + for( j = 0; j < sizeof(buffer); j++ )
1.568 + buffer[j] = '-';
1.569 +
1.570 + if( (const char *)0 != array[i].first )
1.571 + (void)PL_strcpy(buffer, array[i].first);
1.572 +
1.573 + rv = PL_strcat(((const char *)0 == array[i].first) ? (char *)0 : buffer,
1.574 + array[i].second);
1.575 +
1.576 + if( (const char *)0 == array[i].result )
1.577 + {
1.578 + if( (char *)0 != rv )
1.579 + {
1.580 + printf("FAIL %d: %s+%s -> %.32s, not zero\n", i,
1.581 + array[i].first ? array[i].first : "(null)",
1.582 + array[i].second ? array[i].second : "(null)",
1.583 + rv);
1.584 + return PR_FALSE;
1.585 + }
1.586 + }
1.587 + else
1.588 + {
1.589 + if( (char *)0 == rv )
1.590 + {
1.591 + printf("FAIL %d: %s+%s -> null, not %s\n", i,
1.592 + array[i].first ? array[i].first : "(null)",
1.593 + array[i].second ? array[i].second : "(null)",
1.594 + array[i].result);
1.595 + return PR_FALSE;
1.596 + }
1.597 + else
1.598 + {
1.599 + const char *a = array[i].result;
1.600 + const char *b = (const char *)rv;
1.601 +
1.602 + while( 1 )
1.603 + {
1.604 + if( *a != *b )
1.605 + {
1.606 + printf("FAIL %d: %s+%s -> %.32s, not %s\n", i,
1.607 + array[i].first ? array[i].first : "(null)",
1.608 + array[i].second ? array[i].second : "(null)",
1.609 + rv, array[i].result);
1.610 + return PR_FALSE;
1.611 + }
1.612 +
1.613 + if( (char)0 == *a ) break;
1.614 +
1.615 + a++;
1.616 + b++;
1.617 + }
1.618 + }
1.619 + }
1.620 + }
1.621 +
1.622 + printf("PASS\n");
1.623 + return PR_TRUE;
1.624 +}
1.625 +
1.626 +/* PL_strncat */
1.627 +PRBool test_009(void)
1.628 +{
1.629 + static struct
1.630 + {
1.631 + const char *first;
1.632 + const char *second;
1.633 + PRUint32 length;
1.634 + PRBool nulled;
1.635 + const char *result;
1.636 + } array[] =
1.637 + {
1.638 + { (const char *)0, (const char *)0, 0, PR_FALSE, (const char *)0 },
1.639 + { (const char *)0, (const char *)0, 1, PR_FALSE, (const char *)0 },
1.640 + { (const char *)0, (const char *)0, 7, PR_FALSE, (const char *)0 },
1.641 + { (const char *)0, "", 0, PR_FALSE, (const char *)0 },
1.642 + { (const char *)0, "", 1, PR_FALSE, (const char *)0 },
1.643 + { (const char *)0, "", 7, PR_FALSE, (const char *)0 },
1.644 + { (const char *)0, "stuff", 0, PR_FALSE, (const char *)0 },
1.645 + { (const char *)0, "stuff", 1, PR_FALSE, (const char *)0 },
1.646 + { (const char *)0, "stuff", 7, PR_FALSE, (const char *)0 },
1.647 + { "", (const char *)0, 0, PR_TRUE, "" },
1.648 + { "", (const char *)0, 1, PR_TRUE, "" },
1.649 + { "", (const char *)0, 7, PR_TRUE, "" },
1.650 + { "", "", 0, PR_TRUE, "" },
1.651 + { "", "", 1, PR_TRUE, "" },
1.652 + { "", "", 7, PR_TRUE, "" },
1.653 + { "", "abcdefgh", 0, PR_TRUE, "" },
1.654 + { "", "abcdefgh", 1, PR_FALSE, "a" },
1.655 + { "", "abcdefgh", 7, PR_FALSE, "abcdefg" },
1.656 + { "xyz", (const char *)0, 0, PR_TRUE, "xyz" },
1.657 + { "xyz", (const char *)0, 1, PR_TRUE, "xyz" },
1.658 + { "xyz", (const char *)0, 7, PR_TRUE, "xyz" },
1.659 + { "xyz", "", 0, PR_TRUE, "xyz" },
1.660 + { "xyz", "", 1, PR_TRUE, "xyz" },
1.661 + { "xyz", "", 7, PR_TRUE, "xyz" },
1.662 + { "xyz", "abcdefgh", 0, PR_TRUE, "xyz" },
1.663 + { "xyz", "abcdefgh", 1, PR_FALSE, "xyza" },
1.664 + { "xyz", "abcdefgh", 7, PR_FALSE, "xyzabcdefg" }
1.665 + };
1.666 +
1.667 + int i;
1.668 +
1.669 + printf("Test 009 (PL_strncat) ..."); fflush(stdout);
1.670 +
1.671 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.672 + {
1.673 + char buffer[ 1024 ];
1.674 + int j;
1.675 + char *rv;
1.676 +
1.677 + for( j = 0; j < sizeof(buffer); j++ )
1.678 + buffer[j] = '-';
1.679 +
1.680 + if( (const char *)0 != array[i].first )
1.681 + (void)PL_strcpy(buffer, array[i].first);
1.682 +
1.683 + rv = PL_strncat(((const char *)0 == array[i].first) ? (char *)0 : buffer,
1.684 + array[i].second, array[i].length);
1.685 +
1.686 + if( (const char *)0 == array[i].result )
1.687 + {
1.688 + if( (char *)0 != rv )
1.689 + {
1.690 + printf("FAIL %d: %s+%s/%lu -> %.32s, not zero\n", i,
1.691 + array[i].first ? array[i].first : "(null)",
1.692 + array[i].second ? array[i].second : "(null)",
1.693 + array[i].length, rv);
1.694 + return PR_FALSE;
1.695 + }
1.696 + }
1.697 + else
1.698 + {
1.699 + if( (char *)0 == rv )
1.700 + {
1.701 + printf("FAIL %d: %s+%s/%lu -> null, not %s\n", i,
1.702 + array[i].first ? array[i].first : "(null)",
1.703 + array[i].second ? array[i].second : "(null)",
1.704 + array[i].length, array[i].result);
1.705 + return PR_FALSE;
1.706 + }
1.707 + else
1.708 + {
1.709 + const char *a = array[i].result;
1.710 + const char *b = (const char *)rv;
1.711 +
1.712 + while( *a )
1.713 + {
1.714 + if( *a != *b )
1.715 + {
1.716 + printf("FAIL %d: %s+%s/%lu -> %.32s, not %s\n", i,
1.717 + array[i].first ? array[i].first : "(null)",
1.718 + array[i].second ? array[i].second : "(null)",
1.719 + array[i].length, rv, array[i].result);
1.720 + return PR_FALSE;
1.721 + }
1.722 +
1.723 + a++;
1.724 + b++;
1.725 + }
1.726 +
1.727 + if( array[i].nulled )
1.728 + {
1.729 + if( (char)0 != *b )
1.730 + {
1.731 + printf("FAIL %d: %s+%s/%lu -> not nulled\n", i,
1.732 + array[i].first ? array[i].first : "(null)",
1.733 + array[i].second ? array[i].second : "(null)",
1.734 + array[i].length);
1.735 + return PR_FALSE;
1.736 + }
1.737 + }
1.738 + else
1.739 + {
1.740 + if( (char)0 == *b )
1.741 + {
1.742 + printf("FAIL %d: %s+%s/%lu -> overrun\n", i,
1.743 + array[i].first ? array[i].first : "(null)",
1.744 + array[i].second ? array[i].second : "(null)",
1.745 + array[i].length);
1.746 + return PR_FALSE;
1.747 + }
1.748 + }
1.749 + }
1.750 + }
1.751 + }
1.752 +
1.753 + printf("PASS\n");
1.754 + return PR_TRUE;
1.755 +}
1.756 +
1.757 +/* PL_strcatn */
1.758 +PRBool test_010(void)
1.759 +{
1.760 + static struct
1.761 + {
1.762 + const char *first;
1.763 + const char *second;
1.764 + PRUint32 length;
1.765 + const char *result;
1.766 + } array[] =
1.767 + {
1.768 + { (const char *)0, (const char *)0, 0, (const char *)0 },
1.769 + { (const char *)0, (const char *)0, 1, (const char *)0 },
1.770 + { (const char *)0, (const char *)0, 7, (const char *)0 },
1.771 + { (const char *)0, "", 0, (const char *)0 },
1.772 + { (const char *)0, "", 1, (const char *)0 },
1.773 + { (const char *)0, "", 7, (const char *)0 },
1.774 + { (const char *)0, "stuff", 0, (const char *)0 },
1.775 + { (const char *)0, "stuff", 1, (const char *)0 },
1.776 + { (const char *)0, "stuff", 7, (const char *)0 },
1.777 + { "", (const char *)0, 0, "" },
1.778 + { "", (const char *)0, 1, "" },
1.779 + { "", (const char *)0, 7, "" },
1.780 + { "", "", 0, "" },
1.781 + { "", "", 1, "" },
1.782 + { "", "", 7, "" },
1.783 + { "", "abcdefgh", 0, "" },
1.784 + { "", "abcdefgh", 1, "" },
1.785 + { "", "abcdefgh", 7, "abcdef" },
1.786 + { "xyz", (const char *)0, 0, "xyz" },
1.787 + { "xyz", (const char *)0, 1, "xyz" },
1.788 + { "xyz", (const char *)0, 7, "xyz" },
1.789 + { "xyz", "", 0, "xyz" },
1.790 + { "xyz", "", 1, "xyz" },
1.791 + { "xyz", "", 7, "xyz" },
1.792 + { "xyz", "abcdefgh", 0, "xyz" },
1.793 + { "xyz", "abcdefgh", 1, "xyz" },
1.794 + { "xyz", "abcdefgh", 7, "xyzabc" }
1.795 + };
1.796 +
1.797 + int i;
1.798 +
1.799 + printf("Test 010 (PL_strcatn) ..."); fflush(stdout);
1.800 +
1.801 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.802 + {
1.803 + char buffer[ 1024 ];
1.804 + int j;
1.805 + char *rv;
1.806 +
1.807 + for( j = 0; j < sizeof(buffer); j++ )
1.808 + buffer[j] = '-';
1.809 +
1.810 + if( (const char *)0 != array[i].first )
1.811 + (void)PL_strcpy(buffer, array[i].first);
1.812 +
1.813 + rv = PL_strcatn(((const char *)0 == array[i].first) ? (char *)0 : buffer,
1.814 + array[i].length, array[i].second);
1.815 +
1.816 + if( (const char *)0 == array[i].result )
1.817 + {
1.818 + if( (char *)0 != rv )
1.819 + {
1.820 + printf("FAIL %d: %s+%s/%lu -> %.32s, not zero\n", i,
1.821 + array[i].first ? array[i].first : "(null)",
1.822 + array[i].second ? array[i].second : "(null)",
1.823 + array[i].length, rv);
1.824 + return PR_FALSE;
1.825 + }
1.826 + }
1.827 + else
1.828 + {
1.829 + if( (char *)0 == rv )
1.830 + {
1.831 + printf("FAIL %d: %s+%s/%lu -> null, not %s\n", i,
1.832 + array[i].first ? array[i].first : "(null)",
1.833 + array[i].second ? array[i].second : "(null)",
1.834 + array[i].length, array[i].result);
1.835 + return PR_FALSE;
1.836 + }
1.837 + else
1.838 + {
1.839 + const char *a = array[i].result;
1.840 + const char *b = (const char *)rv;
1.841 +
1.842 + while( 1 )
1.843 + {
1.844 + if( *a != *b )
1.845 + {
1.846 + printf("FAIL %d: %s+%s/%lu -> %.32s, not %s\n", i,
1.847 + array[i].first ? array[i].first : "(null)",
1.848 + array[i].second ? array[i].second : "(null)",
1.849 + array[i].length, rv, array[i].result);
1.850 + return PR_FALSE;
1.851 + }
1.852 +
1.853 + if( (char)0 == *a ) break;
1.854 +
1.855 + a++;
1.856 + b++;
1.857 + }
1.858 + }
1.859 + }
1.860 + }
1.861 +
1.862 + printf("PASS\n");
1.863 + return PR_TRUE;
1.864 +}
1.865 +
1.866 +/* PL_strcmp */
1.867 +PRBool test_011(void)
1.868 +{
1.869 + static struct
1.870 + {
1.871 + const char *one;
1.872 + const char *two;
1.873 + PRIntn sign;
1.874 + } array[] =
1.875 + {
1.876 + { (const char *)0, (const char *)0, 0 },
1.877 + { (const char *)0, "word", -1 },
1.878 + { "word", (const char *)0, 1 },
1.879 + { "word", "word", 0 },
1.880 + { "aZYXVUT", "bZYXVUT", -1 },
1.881 + { "aZYXVUT", "bAAAAAA", -1 },
1.882 + { "a", "aa", -1 },
1.883 + { "a", "a", 0 },
1.884 + { "a", "A", 1 },
1.885 + { "aaaaa", "baaaa", -1 },
1.886 + { "aaaaa", "abaaa", -1 },
1.887 + { "aaaaa", "aabaa", -1 },
1.888 + { "aaaaa", "aaaba", -1 },
1.889 + { "aaaaa", "aaaab", -1 },
1.890 + { "bZYXVUT", "aZYXVUT", 1 },
1.891 + { "bAAAAAA", "aZYXVUT", 1 },
1.892 + { "aa", "a", 1 },
1.893 + { "A", "a", -1 },
1.894 + { "baaaa", "aaaaa", 1 },
1.895 + { "abaaa", "aaaaa", 1 },
1.896 + { "aabaa", "aaaaa", 1 },
1.897 + { "aaaba", "aaaaa", 1 },
1.898 + { "aaaab", "aaaaa", 1 },
1.899 + { "word", "Word", 1 },
1.900 + { "word", "wOrd", 1 },
1.901 + { "word", "woRd", 1 },
1.902 + { "word", "worD", 1 },
1.903 + { "WORD", "wORD", -1 },
1.904 + { "WORD", "WoRD", -1 },
1.905 + { "WORD", "WOrD", -1 },
1.906 + { "WORD", "WORd", -1 }
1.907 + };
1.908 +
1.909 + int i;
1.910 +
1.911 + printf("Test 011 (PL_strcmp) ..."); fflush(stdout);
1.912 +
1.913 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.914 + {
1.915 + PRIntn rv = PL_strcmp(array[i].one, array[i].two);
1.916 +
1.917 + switch( array[i].sign )
1.918 + {
1.919 + case -1:
1.920 + if( rv < 0 ) continue;
1.921 + break;
1.922 + case 1:
1.923 + if( rv > 0 ) continue;
1.924 + break;
1.925 + case 0:
1.926 + if( 0 == rv ) continue;
1.927 + break;
1.928 + default:
1.929 + PR_NOT_REACHED("static data inconsistancy");
1.930 + break;
1.931 + }
1.932 +
1.933 + printf("FAIL %d: %s-%s -> %d, not %d\n", i,
1.934 + array[i].one ? array[i].one : "(null)",
1.935 + array[i].two ? array[i].two : "(null)",
1.936 + rv, array[i].sign);
1.937 + return PR_FALSE;
1.938 + }
1.939 +
1.940 + printf("PASS\n");
1.941 + return PR_TRUE;
1.942 +}
1.943 +
1.944 +/* PL_strncmp */
1.945 +PRBool test_012(void)
1.946 +{
1.947 + static struct
1.948 + {
1.949 + const char *one;
1.950 + const char *two;
1.951 + PRUint32 max;
1.952 + PRIntn sign;
1.953 + } array[] =
1.954 + {
1.955 + { (const char *)0, (const char *)0, 0, 0 },
1.956 + { (const char *)0, (const char *)0, 1, 0 },
1.957 + { (const char *)0, (const char *)0, 4, 0 },
1.958 + { (const char *)0, "word", 0, -1 },
1.959 + { (const char *)0, "word", 1, -1 },
1.960 + { (const char *)0, "word", 4, -1 },
1.961 + { "word", (const char *)0, 0, 1 },
1.962 + { "word", (const char *)0, 1, 1 },
1.963 + { "word", (const char *)0, 4, 1 },
1.964 + { "word", "word", 0, 0 },
1.965 + { "word", "word", 1, 0 },
1.966 + { "word", "word", 3, 0 },
1.967 + { "word", "word", 5, 0 },
1.968 + { "aZYXVUT", "bZYXVUT", 0, 0 },
1.969 + { "aZYXVUT", "bZYXVUT", 1, -1 },
1.970 + { "aZYXVUT", "bZYXVUT", 4, -1 },
1.971 + { "aZYXVUT", "bZYXVUT", 9, -1 },
1.972 + { "aZYXVUT", "bAAAAAA", 0, 0 },
1.973 + { "aZYXVUT", "bAAAAAA", 1, -1 },
1.974 + { "aZYXVUT", "bAAAAAA", 4, -1 },
1.975 + { "aZYXVUT", "bAAAAAA", 5, -1 },
1.976 + { "a", "aa", 0, 0 },
1.977 + { "a", "aa", 1, 0 },
1.978 + { "a", "aa", 4, -1 },
1.979 + { "a", "a", 0, 0 },
1.980 + { "a", "a", 1, 0 },
1.981 + { "a", "a", 4, 0 },
1.982 + { "a", "A", 0, 0 },
1.983 + { "a", "A", 1, 1 },
1.984 + { "a", "A", 4, 1 },
1.985 + { "aaaaa", "baaaa", 0, 0 },
1.986 + { "aaaaa", "baaaa", 1, -1 },
1.987 + { "aaaaa", "baaaa", 4, -1 },
1.988 + { "aaaaa", "abaaa", 0, 0 },
1.989 + { "aaaaa", "abaaa", 1, 0 },
1.990 + { "aaaaa", "abaaa", 4, -1 },
1.991 + { "aaaaa", "aabaa", 0, 0 },
1.992 + { "aaaaa", "aabaa", 1, 0 },
1.993 + { "aaaaa", "aabaa", 4, -1 },
1.994 + { "aaaaa", "aaaba", 0, 0 },
1.995 + { "aaaaa", "aaaba", 1, 0 },
1.996 + { "aaaaa", "aaaba", 4, -1 },
1.997 + { "aaaaa", "aaaab", 0, 0 },
1.998 + { "aaaaa", "aaaab", 1, 0 },
1.999 + { "aaaaa", "aaaab", 4, 0 },
1.1000 + { "bZYXVUT", "aZYXVUT", 0, 0 },
1.1001 + { "bZYXVUT", "aZYXVUT", 1, 1 },
1.1002 + { "bZYXVUT", "aZYXVUT", 4, 1 },
1.1003 + { "bAAAAAA", "aZYXVUT", 0, 0 },
1.1004 + { "bAAAAAA", "aZYXVUT", 1, 1 },
1.1005 + { "bAAAAAA", "aZYXVUT", 4, 1 },
1.1006 + { "aa", "a", 0, 0 },
1.1007 + { "aa", "a", 1, 0 },
1.1008 + { "aa", "a", 4, 1 },
1.1009 + { "A", "a", 0, 0 },
1.1010 + { "A", "a", 1, -1 },
1.1011 + { "A", "a", 4, -1 },
1.1012 + { "baaaa", "aaaaa", 0, 0 },
1.1013 + { "baaaa", "aaaaa", 1, 1 },
1.1014 + { "baaaa", "aaaaa", 4, 1 },
1.1015 + { "abaaa", "aaaaa", 0, 0 },
1.1016 + { "abaaa", "aaaaa", 1, 0 },
1.1017 + { "abaaa", "aaaaa", 4, 1 },
1.1018 + { "aabaa", "aaaaa", 0, 0 },
1.1019 + { "aabaa", "aaaaa", 1, 0 },
1.1020 + { "aabaa", "aaaaa", 4, 1 },
1.1021 + { "aaaba", "aaaaa", 0, 0 },
1.1022 + { "aaaba", "aaaaa", 1, 0 },
1.1023 + { "aaaba", "aaaaa", 4, 1 },
1.1024 + { "aaaab", "aaaaa", 0, 0 },
1.1025 + { "aaaab", "aaaaa", 1, 0 },
1.1026 + { "aaaab", "aaaaa", 4, 0 },
1.1027 + { "word", "Word", 0, 0 },
1.1028 + { "word", "Word", 1, 1 },
1.1029 + { "word", "Word", 3, 1 },
1.1030 + { "word", "wOrd", 0, 0 },
1.1031 + { "word", "wOrd", 1, 0 },
1.1032 + { "word", "wOrd", 3, 1 },
1.1033 + { "word", "woRd", 0, 0 },
1.1034 + { "word", "woRd", 1, 0 },
1.1035 + { "word", "woRd", 3, 1 },
1.1036 + { "word", "worD", 0, 0 },
1.1037 + { "word", "worD", 1, 0 },
1.1038 + { "word", "worD", 3, 0 },
1.1039 + { "WORD", "wORD", 0, 0 },
1.1040 + { "WORD", "wORD", 1, -1 },
1.1041 + { "WORD", "wORD", 3, -1 },
1.1042 + { "WORD", "WoRD", 0, 0 },
1.1043 + { "WORD", "WoRD", 1, 0 },
1.1044 + { "WORD", "WoRD", 3, -1 },
1.1045 + { "WORD", "WOrD", 0, 0 },
1.1046 + { "WORD", "WOrD", 1, 0 },
1.1047 + { "WORD", "WOrD", 3, -1 },
1.1048 + { "WORD", "WORd", 0, 0 },
1.1049 + { "WORD", "WORd", 1, 0 },
1.1050 + { "WORD", "WORd", 3, 0 }
1.1051 +
1.1052 + };
1.1053 +
1.1054 + int i;
1.1055 +
1.1056 + printf("Test 012 (PL_strncmp) ..."); fflush(stdout);
1.1057 +
1.1058 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.1059 + {
1.1060 + PRIntn rv = PL_strncmp(array[i].one, array[i].two, array[i].max);
1.1061 +
1.1062 + switch( array[i].sign )
1.1063 + {
1.1064 + case -1:
1.1065 + if( rv < 0 ) continue;
1.1066 + break;
1.1067 + case 1:
1.1068 + if( rv > 0 ) continue;
1.1069 + break;
1.1070 + case 0:
1.1071 + if( 0 == rv ) continue;
1.1072 + break;
1.1073 + default:
1.1074 + PR_NOT_REACHED("static data inconsistancy");
1.1075 + break;
1.1076 + }
1.1077 +
1.1078 + printf("FAIL %d: %s-%s/%ld -> %d, not %d\n", i,
1.1079 + array[i].one ? array[i].one : "(null)",
1.1080 + array[i].two ? array[i].two : "(null)",
1.1081 + array[i].max, rv, array[i].sign);
1.1082 + return PR_FALSE;
1.1083 + }
1.1084 +
1.1085 + printf("PASS\n");
1.1086 + return PR_TRUE;
1.1087 +}
1.1088 +
1.1089 +/* PL_strcasecmp */
1.1090 +PRBool test_013(void)
1.1091 +{
1.1092 + static struct
1.1093 + {
1.1094 + const char *one;
1.1095 + const char *two;
1.1096 + PRIntn sign;
1.1097 + } array[] =
1.1098 + {
1.1099 + { (const char *)0, (const char *)0, 0 },
1.1100 + { (const char *)0, "word", -1 },
1.1101 + { "word", (const char *)0, 1 },
1.1102 + { "word", "word", 0 },
1.1103 + { "aZYXVUT", "bZYXVUT", -1 },
1.1104 + { "aZYXVUT", "bAAAAAA", -1 },
1.1105 + { "a", "aa", -1 },
1.1106 + { "a", "a", 0 },
1.1107 + { "a", "A", 0 },
1.1108 + { "aaaaa", "baaaa", -1 },
1.1109 + { "aaaaa", "abaaa", -1 },
1.1110 + { "aaaaa", "aabaa", -1 },
1.1111 + { "aaaaa", "aaaba", -1 },
1.1112 + { "aaaaa", "aaaab", -1 },
1.1113 + { "bZYXVUT", "aZYXVUT", 1 },
1.1114 + { "bAAAAAA", "aZYXVUT", 1 },
1.1115 + { "aa", "a", 1 },
1.1116 + { "A", "a", 0 },
1.1117 + { "baaaa", "aaaaa", 1 },
1.1118 + { "abaaa", "aaaaa", 1 },
1.1119 + { "aabaa", "aaaaa", 1 },
1.1120 + { "aaaba", "aaaaa", 1 },
1.1121 + { "aaaab", "aaaaa", 1 },
1.1122 + { "word", "Word", 0 },
1.1123 + { "word", "wOrd", 0 },
1.1124 + { "word", "woRd", 0 },
1.1125 + { "word", "worD", 0 },
1.1126 + { "WORD", "wORD", 0 },
1.1127 + { "WORD", "WoRD", 0 },
1.1128 + { "WORD", "WOrD", 0 },
1.1129 + { "WORD", "WORd", 0 }
1.1130 + };
1.1131 +
1.1132 + int i;
1.1133 +
1.1134 + printf("Test 013 (PL_strcasecmp) ..."); fflush(stdout);
1.1135 +
1.1136 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.1137 + {
1.1138 + PRIntn rv = PL_strcasecmp(array[i].one, array[i].two);
1.1139 +
1.1140 + switch( array[i].sign )
1.1141 + {
1.1142 + case -1:
1.1143 + if( rv < 0 ) continue;
1.1144 + break;
1.1145 + case 1:
1.1146 + if( rv > 0 ) continue;
1.1147 + break;
1.1148 + case 0:
1.1149 + if( 0 == rv ) continue;
1.1150 + break;
1.1151 + default:
1.1152 + PR_NOT_REACHED("static data inconsistancy");
1.1153 + break;
1.1154 + }
1.1155 +
1.1156 + printf("FAIL %d: %s-%s -> %d, not %d\n", i,
1.1157 + array[i].one ? array[i].one : "(null)",
1.1158 + array[i].two ? array[i].two : "(null)",
1.1159 + rv, array[i].sign);
1.1160 + return PR_FALSE;
1.1161 + }
1.1162 +
1.1163 + printf("PASS\n");
1.1164 + return PR_TRUE;
1.1165 +}
1.1166 +
1.1167 +/* PL_strncasecmp */
1.1168 +PRBool test_014(void)
1.1169 +{
1.1170 + static struct
1.1171 + {
1.1172 + const char *one;
1.1173 + const char *two;
1.1174 + PRUint32 max;
1.1175 + PRIntn sign;
1.1176 + } array[] =
1.1177 + {
1.1178 + { (const char *)0, (const char *)0, 0, 0 },
1.1179 + { (const char *)0, (const char *)0, 1, 0 },
1.1180 + { (const char *)0, (const char *)0, 4, 0 },
1.1181 + { (const char *)0, "word", 0, -1 },
1.1182 + { (const char *)0, "word", 1, -1 },
1.1183 + { (const char *)0, "word", 4, -1 },
1.1184 + { "word", (const char *)0, 0, 1 },
1.1185 + { "word", (const char *)0, 1, 1 },
1.1186 + { "word", (const char *)0, 4, 1 },
1.1187 + { "word", "word", 0, 0 },
1.1188 + { "word", "word", 1, 0 },
1.1189 + { "word", "word", 3, 0 },
1.1190 + { "word", "word", 5, 0 },
1.1191 + { "aZYXVUT", "bZYXVUT", 0, 0 },
1.1192 + { "aZYXVUT", "bZYXVUT", 1, -1 },
1.1193 + { "aZYXVUT", "bZYXVUT", 4, -1 },
1.1194 + { "aZYXVUT", "bZYXVUT", 9, -1 },
1.1195 + { "aZYXVUT", "bAAAAAA", 0, 0 },
1.1196 + { "aZYXVUT", "bAAAAAA", 1, -1 },
1.1197 + { "aZYXVUT", "bAAAAAA", 4, -1 },
1.1198 + { "aZYXVUT", "bAAAAAA", 5, -1 },
1.1199 + { "a", "aa", 0, 0 },
1.1200 + { "a", "aa", 1, 0 },
1.1201 + { "a", "aa", 4, -1 },
1.1202 + { "a", "a", 0, 0 },
1.1203 + { "a", "a", 1, 0 },
1.1204 + { "a", "a", 4, 0 },
1.1205 + { "a", "A", 0, 0 },
1.1206 + { "a", "A", 1, 0 },
1.1207 + { "a", "A", 4, 0 },
1.1208 + { "aaaaa", "baaaa", 0, 0 },
1.1209 + { "aaaaa", "baaaa", 1, -1 },
1.1210 + { "aaaaa", "baaaa", 4, -1 },
1.1211 + { "aaaaa", "abaaa", 0, 0 },
1.1212 + { "aaaaa", "abaaa", 1, 0 },
1.1213 + { "aaaaa", "abaaa", 4, -1 },
1.1214 + { "aaaaa", "aabaa", 0, 0 },
1.1215 + { "aaaaa", "aabaa", 1, 0 },
1.1216 + { "aaaaa", "aabaa", 4, -1 },
1.1217 + { "aaaaa", "aaaba", 0, 0 },
1.1218 + { "aaaaa", "aaaba", 1, 0 },
1.1219 + { "aaaaa", "aaaba", 4, -1 },
1.1220 + { "aaaaa", "aaaab", 0, 0 },
1.1221 + { "aaaaa", "aaaab", 1, 0 },
1.1222 + { "aaaaa", "aaaab", 4, 0 },
1.1223 + { "bZYXVUT", "aZYXVUT", 0, 0 },
1.1224 + { "bZYXVUT", "aZYXVUT", 1, 1 },
1.1225 + { "bZYXVUT", "aZYXVUT", 4, 1 },
1.1226 + { "bAAAAAA", "aZYXVUT", 0, 0 },
1.1227 + { "bAAAAAA", "aZYXVUT", 1, 1 },
1.1228 + { "bAAAAAA", "aZYXVUT", 4, 1 },
1.1229 + { "aa", "a", 0, 0 },
1.1230 + { "aa", "a", 1, 0 },
1.1231 + { "aa", "a", 4, 1 },
1.1232 + { "A", "a", 0, 0 },
1.1233 + { "A", "a", 1, 0 },
1.1234 + { "A", "a", 4, 0 },
1.1235 + { "baaaa", "aaaaa", 0, 0 },
1.1236 + { "baaaa", "aaaaa", 1, 1 },
1.1237 + { "baaaa", "aaaaa", 4, 1 },
1.1238 + { "abaaa", "aaaaa", 0, 0 },
1.1239 + { "abaaa", "aaaaa", 1, 0 },
1.1240 + { "abaaa", "aaaaa", 4, 1 },
1.1241 + { "aabaa", "aaaaa", 0, 0 },
1.1242 + { "aabaa", "aaaaa", 1, 0 },
1.1243 + { "aabaa", "aaaaa", 4, 1 },
1.1244 + { "aaaba", "aaaaa", 0, 0 },
1.1245 + { "aaaba", "aaaaa", 1, 0 },
1.1246 + { "aaaba", "aaaaa", 4, 1 },
1.1247 + { "aaaab", "aaaaa", 0, 0 },
1.1248 + { "aaaab", "aaaaa", 1, 0 },
1.1249 + { "aaaab", "aaaaa", 4, 0 },
1.1250 + { "word", "Word", 0, 0 },
1.1251 + { "word", "Word", 1, 0 },
1.1252 + { "word", "Word", 3, 0 },
1.1253 + { "word", "wOrd", 0, 0 },
1.1254 + { "word", "wOrd", 1, 0 },
1.1255 + { "word", "wOrd", 3, 0 },
1.1256 + { "word", "woRd", 0, 0 },
1.1257 + { "word", "woRd", 1, 0 },
1.1258 + { "word", "woRd", 3, 0 },
1.1259 + { "word", "worD", 0, 0 },
1.1260 + { "word", "worD", 1, 0 },
1.1261 + { "word", "worD", 3, 0 },
1.1262 + { "WORD", "wORD", 0, 0 },
1.1263 + { "WORD", "wORD", 1, 0 },
1.1264 + { "WORD", "wORD", 3, 0 },
1.1265 + { "WORD", "WoRD", 0, 0 },
1.1266 + { "WORD", "WoRD", 1, 0 },
1.1267 + { "WORD", "WoRD", 3, 0 },
1.1268 + { "WORD", "WOrD", 0, 0 },
1.1269 + { "WORD", "WOrD", 1, 0 },
1.1270 + { "WORD", "WOrD", 3, 0 },
1.1271 + { "WORD", "WORd", 0, 0 },
1.1272 + { "WORD", "WORd", 1, 0 },
1.1273 + { "WORD", "WORd", 3, 0 }
1.1274 + };
1.1275 +
1.1276 + int i;
1.1277 +
1.1278 + printf("Test 014 (PL_strncasecmp) ..."); fflush(stdout);
1.1279 +
1.1280 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.1281 + {
1.1282 + PRIntn rv = PL_strncasecmp(array[i].one, array[i].two, array[i].max);
1.1283 +
1.1284 + switch( array[i].sign )
1.1285 + {
1.1286 + case -1:
1.1287 + if( rv < 0 ) continue;
1.1288 + break;
1.1289 + case 1:
1.1290 + if( rv > 0 ) continue;
1.1291 + break;
1.1292 + case 0:
1.1293 + if( 0 == rv ) continue;
1.1294 + break;
1.1295 + default:
1.1296 + PR_NOT_REACHED("static data inconsistancy");
1.1297 + break;
1.1298 + }
1.1299 +
1.1300 + printf("FAIL %d: %s-%s/%ld -> %d, not %d\n", i,
1.1301 + array[i].one ? array[i].one : "(null)",
1.1302 + array[i].two ? array[i].two : "(null)",
1.1303 + array[i].max, rv, array[i].sign);
1.1304 + return PR_FALSE;
1.1305 + }
1.1306 +
1.1307 + printf("PASS\n");
1.1308 + return PR_TRUE;
1.1309 +}
1.1310 +
1.1311 +/* PL_strchr */
1.1312 +PRBool test_015(void)
1.1313 +{
1.1314 + static struct
1.1315 + {
1.1316 + const char *str;
1.1317 + char chr;
1.1318 + PRBool ret;
1.1319 + PRUint32 off;
1.1320 + } array[] =
1.1321 + {
1.1322 + { (const char *)0, 'a', PR_FALSE, 0 },
1.1323 + { (const char *)0, '\0', PR_FALSE, 0 },
1.1324 + { "abcdefg", 'a', PR_TRUE, 0 },
1.1325 + { "abcdefg", 'b', PR_TRUE, 1 },
1.1326 + { "abcdefg", 'c', PR_TRUE, 2 },
1.1327 + { "abcdefg", 'd', PR_TRUE, 3 },
1.1328 + { "abcdefg", 'e', PR_TRUE, 4 },
1.1329 + { "abcdefg", 'f', PR_TRUE, 5 },
1.1330 + { "abcdefg", 'g', PR_TRUE, 6 },
1.1331 + { "abcdefg", 'h', PR_FALSE, 0 },
1.1332 + { "abcdefg", '\0', PR_TRUE, 7 },
1.1333 + { "abcdefg", 'A', PR_FALSE, 0 },
1.1334 + { "abcdefg", 'B', PR_FALSE, 0 },
1.1335 + { "abcdefg", 'C', PR_FALSE, 0 },
1.1336 + { "abcdefg", 'D', PR_FALSE, 0 },
1.1337 + { "abcdefg", 'E', PR_FALSE, 0 },
1.1338 + { "abcdefg", 'F', PR_FALSE, 0 },
1.1339 + { "abcdefg", 'G', PR_FALSE, 0 },
1.1340 + { "abcdefg", 'H', PR_FALSE, 0 },
1.1341 + { "abcdefgabcdefg", 'a', PR_TRUE, 0 },
1.1342 + { "abcdefgabcdefg", 'b', PR_TRUE, 1 },
1.1343 + { "abcdefgabcdefg", 'c', PR_TRUE, 2 },
1.1344 + { "abcdefgabcdefg", 'd', PR_TRUE, 3 },
1.1345 + { "abcdefgabcdefg", 'e', PR_TRUE, 4 },
1.1346 + { "abcdefgabcdefg", 'f', PR_TRUE, 5 },
1.1347 + { "abcdefgabcdefg", 'g', PR_TRUE, 6 },
1.1348 + { "abcdefgabcdefg", 'h', PR_FALSE, 0 },
1.1349 + { "abcdefgabcdefg", '\0', PR_TRUE, 14 }
1.1350 + };
1.1351 +
1.1352 + int i;
1.1353 +
1.1354 + printf("Test 015 (PL_strchr) ..."); fflush(stdout);
1.1355 +
1.1356 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.1357 + {
1.1358 + char *rv = PL_strchr(array[i].str, array[i].chr);
1.1359 +
1.1360 + if( PR_FALSE == array[i].ret )
1.1361 + {
1.1362 + if( (char *)0 != rv )
1.1363 + {
1.1364 + printf("FAIL %d: %s,%c -> %.32s, not zero\n", i, array[i].str,
1.1365 + array[i].chr, rv);
1.1366 + return PR_FALSE;
1.1367 + }
1.1368 + }
1.1369 + else
1.1370 + {
1.1371 + if( (char *)0 == rv )
1.1372 + {
1.1373 + printf("FAIL %d: %s,%c -> null, not +%lu\n", i, array[i].str,
1.1374 + array[i].chr, array[i].off);
1.1375 + return PR_FALSE;
1.1376 + }
1.1377 +
1.1378 + if( &array[i].str[ array[i].off ] != rv )
1.1379 + {
1.1380 + printf("FAIL %d: %s,%c -> 0x%x, not 0x%x+%lu\n", i, array[i].str,
1.1381 + array[i].chr, rv, array[i].str, array[i].off);
1.1382 + return PR_FALSE;
1.1383 + }
1.1384 + }
1.1385 + }
1.1386 +
1.1387 + printf("PASS\n");
1.1388 + return PR_TRUE;
1.1389 +}
1.1390 +
1.1391 +/* PL_strrchr */
1.1392 +PRBool test_016(void)
1.1393 +{
1.1394 + static struct
1.1395 + {
1.1396 + const char *str;
1.1397 + char chr;
1.1398 + PRBool ret;
1.1399 + PRUint32 off;
1.1400 + } array[] =
1.1401 + {
1.1402 + { (const char *)0, 'a', PR_FALSE, 0 },
1.1403 + { (const char *)0, '\0', PR_FALSE, 0 },
1.1404 + { "abcdefg", 'a', PR_TRUE, 0 },
1.1405 + { "abcdefg", 'b', PR_TRUE, 1 },
1.1406 + { "abcdefg", 'c', PR_TRUE, 2 },
1.1407 + { "abcdefg", 'd', PR_TRUE, 3 },
1.1408 + { "abcdefg", 'e', PR_TRUE, 4 },
1.1409 + { "abcdefg", 'f', PR_TRUE, 5 },
1.1410 + { "abcdefg", 'g', PR_TRUE, 6 },
1.1411 + { "abcdefg", 'h', PR_FALSE, 0 },
1.1412 + { "abcdefg", '\0', PR_TRUE, 7 },
1.1413 + { "abcdefg", 'A', PR_FALSE, 0 },
1.1414 + { "abcdefg", 'B', PR_FALSE, 0 },
1.1415 + { "abcdefg", 'C', PR_FALSE, 0 },
1.1416 + { "abcdefg", 'D', PR_FALSE, 0 },
1.1417 + { "abcdefg", 'E', PR_FALSE, 0 },
1.1418 + { "abcdefg", 'F', PR_FALSE, 0 },
1.1419 + { "abcdefg", 'G', PR_FALSE, 0 },
1.1420 + { "abcdefg", 'H', PR_FALSE, 0 },
1.1421 + { "abcdefgabcdefg", 'a', PR_TRUE, 7 },
1.1422 + { "abcdefgabcdefg", 'b', PR_TRUE, 8 },
1.1423 + { "abcdefgabcdefg", 'c', PR_TRUE, 9 },
1.1424 + { "abcdefgabcdefg", 'd', PR_TRUE, 10 },
1.1425 + { "abcdefgabcdefg", 'e', PR_TRUE, 11 },
1.1426 + { "abcdefgabcdefg", 'f', PR_TRUE, 12 },
1.1427 + { "abcdefgabcdefg", 'g', PR_TRUE, 13 },
1.1428 + { "abcdefgabcdefg", 'h', PR_FALSE, 0 },
1.1429 + { "abcdefgabcdefg", '\0', PR_TRUE, 14 }
1.1430 + };
1.1431 +
1.1432 + int i;
1.1433 +
1.1434 + printf("Test 016 (PL_strrchr) ..."); fflush(stdout);
1.1435 +
1.1436 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.1437 + {
1.1438 + char *rv = PL_strrchr(array[i].str, array[i].chr);
1.1439 +
1.1440 + if( PR_FALSE == array[i].ret )
1.1441 + {
1.1442 + if( (char *)0 != rv )
1.1443 + {
1.1444 + printf("FAIL %d: %s,%c -> %.32s, not zero\n", i, array[i].str,
1.1445 + array[i].chr, rv);
1.1446 + return PR_FALSE;
1.1447 + }
1.1448 + }
1.1449 + else
1.1450 + {
1.1451 + if( (char *)0 == rv )
1.1452 + {
1.1453 + printf("FAIL %d: %s,%c -> null, not +%lu\n", i, array[i].str,
1.1454 + array[i].chr, array[i].off);
1.1455 + return PR_FALSE;
1.1456 + }
1.1457 +
1.1458 + if( &array[i].str[ array[i].off ] != rv )
1.1459 + {
1.1460 + printf("FAIL %d: %s,%c -> 0x%x, not 0x%x+%lu\n", i, array[i].str,
1.1461 + array[i].chr, rv, array[i].str, array[i].off);
1.1462 + return PR_FALSE;
1.1463 + }
1.1464 + }
1.1465 + }
1.1466 +
1.1467 + printf("PASS\n");
1.1468 + return PR_TRUE;
1.1469 +}
1.1470 +
1.1471 +/* PL_strnchr */
1.1472 +PRBool test_017(void)
1.1473 +{
1.1474 + static struct
1.1475 + {
1.1476 + const char *str;
1.1477 + char chr;
1.1478 + PRUint32 max;
1.1479 + PRBool ret;
1.1480 + PRUint32 off;
1.1481 + } array[] =
1.1482 + {
1.1483 + { (const char *)0, 'a', 2, PR_FALSE, 0 },
1.1484 + { (const char *)0, '\0', 2, PR_FALSE, 0 },
1.1485 + { "abcdefg", 'a', 5, PR_TRUE, 0 },
1.1486 + { "abcdefg", 'b', 5, PR_TRUE, 1 },
1.1487 + { "abcdefg", 'c', 5, PR_TRUE, 2 },
1.1488 + { "abcdefg", 'd', 5, PR_TRUE, 3 },
1.1489 + { "abcdefg", 'e', 5, PR_TRUE, 4 },
1.1490 + { "abcdefg", 'f', 5, PR_FALSE, 0 },
1.1491 + { "abcdefg", 'g', 5, PR_FALSE, 0 },
1.1492 + { "abcdefg", 'h', 5, PR_FALSE, 0 },
1.1493 + { "abcdefg", '\0', 5, PR_FALSE, 0 },
1.1494 + { "abcdefg", '\0', 15, PR_TRUE, 7 },
1.1495 + { "abcdefg", 'A', 5, PR_FALSE, 0 },
1.1496 + { "abcdefg", 'B', 5, PR_FALSE, 0 },
1.1497 + { "abcdefg", 'C', 5, PR_FALSE, 0 },
1.1498 + { "abcdefg", 'D', 5, PR_FALSE, 0 },
1.1499 + { "abcdefg", 'E', 5, PR_FALSE, 0 },
1.1500 + { "abcdefg", 'F', 5, PR_FALSE, 0 },
1.1501 + { "abcdefg", 'G', 5, PR_FALSE, 0 },
1.1502 + { "abcdefg", 'H', 5, PR_FALSE, 0 },
1.1503 + { "abcdefgabcdefg", 'a', 10, PR_TRUE, 0 },
1.1504 + { "abcdefgabcdefg", 'b', 10, PR_TRUE, 1 },
1.1505 + { "abcdefgabcdefg", 'c', 10, PR_TRUE, 2 },
1.1506 + { "abcdefgabcdefg", 'd', 10, PR_TRUE, 3 },
1.1507 + { "abcdefgabcdefg", 'e', 10, PR_TRUE, 4 },
1.1508 + { "abcdefgabcdefg", 'f', 10, PR_TRUE, 5 },
1.1509 + { "abcdefgabcdefg", 'g', 10, PR_TRUE, 6 },
1.1510 + { "abcdefgabcdefg", 'h', 10, PR_FALSE, 0 },
1.1511 + { "abcdefgabcdefg", '\0', 10, PR_FALSE, 0 },
1.1512 + { "abcdefgabcdefg", '\0', 14, PR_FALSE, 0 },
1.1513 + { "abcdefgabcdefg", '\0', 15, PR_TRUE, 14 }
1.1514 + };
1.1515 +
1.1516 + int i;
1.1517 +
1.1518 + printf("Test 017 (PL_strnchr) ..."); fflush(stdout);
1.1519 +
1.1520 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.1521 + {
1.1522 + char *rv = PL_strnchr(array[i].str, array[i].chr, array[i].max);
1.1523 +
1.1524 + if( PR_FALSE == array[i].ret )
1.1525 + {
1.1526 + if( (char *)0 != rv )
1.1527 + {
1.1528 + printf("FAIL %d: %s,%c/%lu -> %.32s, not zero\n", i, array[i].str,
1.1529 + array[i].chr, array[i].max, rv);
1.1530 + return PR_FALSE;
1.1531 + }
1.1532 + }
1.1533 + else
1.1534 + {
1.1535 + if( (char *)0 == rv )
1.1536 + {
1.1537 + printf("FAIL %d: %s,%c/%lu -> null, not +%lu\n", i, array[i].str,
1.1538 + array[i].chr, array[i].max, array[i].off);
1.1539 + return PR_FALSE;
1.1540 + }
1.1541 +
1.1542 + if( &array[i].str[ array[i].off ] != rv )
1.1543 + {
1.1544 + printf("FAIL %d: %s,%c/%lu -> 0x%x, not 0x%x+%lu\n", i, array[i].str,
1.1545 + array[i].chr, array[i].max, rv, array[i].str, array[i].off);
1.1546 + return PR_FALSE;
1.1547 + }
1.1548 + }
1.1549 + }
1.1550 +
1.1551 + printf("PASS\n");
1.1552 + return PR_TRUE;
1.1553 +}
1.1554 +
1.1555 +/* PL_strnrchr */
1.1556 +PRBool test_018(void)
1.1557 +{
1.1558 + static struct
1.1559 + {
1.1560 + const char *str;
1.1561 + char chr;
1.1562 + PRUint32 max;
1.1563 + PRBool ret;
1.1564 + PRUint32 off;
1.1565 + } array[] =
1.1566 + {
1.1567 + { (const char *)0, 'a', 2, PR_FALSE, 0 },
1.1568 + { (const char *)0, '\0', 2, PR_FALSE, 0 },
1.1569 + { "abcdefg", 'a', 5, PR_TRUE, 0 },
1.1570 + { "abcdefg", 'b', 5, PR_TRUE, 1 },
1.1571 + { "abcdefg", 'c', 5, PR_TRUE, 2 },
1.1572 + { "abcdefg", 'd', 5, PR_TRUE, 3 },
1.1573 + { "abcdefg", 'e', 5, PR_TRUE, 4 },
1.1574 + { "abcdefg", 'f', 5, PR_FALSE, 0 },
1.1575 + { "abcdefg", 'g', 5, PR_FALSE, 0 },
1.1576 + { "abcdefg", 'h', 5, PR_FALSE, 0 },
1.1577 + { "abcdefg", '\0', 5, PR_FALSE, 0 },
1.1578 + { "abcdefg", '\0', 15, PR_TRUE, 7 },
1.1579 + { "abcdefg", 'A', 5, PR_FALSE, 0 },
1.1580 + { "abcdefg", 'B', 5, PR_FALSE, 0 },
1.1581 + { "abcdefg", 'C', 5, PR_FALSE, 0 },
1.1582 + { "abcdefg", 'D', 5, PR_FALSE, 0 },
1.1583 + { "abcdefg", 'E', 5, PR_FALSE, 0 },
1.1584 + { "abcdefg", 'F', 5, PR_FALSE, 0 },
1.1585 + { "abcdefg", 'G', 5, PR_FALSE, 0 },
1.1586 + { "abcdefg", 'H', 5, PR_FALSE, 0 },
1.1587 + { "abcdefgabcdefg", 'a', 10, PR_TRUE, 7 },
1.1588 + { "abcdefgabcdefg", 'b', 10, PR_TRUE, 8 },
1.1589 + { "abcdefgabcdefg", 'c', 10, PR_TRUE, 9 },
1.1590 + { "abcdefgabcdefg", 'd', 10, PR_TRUE, 3 },
1.1591 + { "abcdefgabcdefg", 'e', 10, PR_TRUE, 4 },
1.1592 + { "abcdefgabcdefg", 'f', 10, PR_TRUE, 5 },
1.1593 + { "abcdefgabcdefg", 'g', 10, PR_TRUE, 6 },
1.1594 + { "abcdefgabcdefg", 'h', 10, PR_FALSE, 0 },
1.1595 + { "abcdefgabcdefg", '\0', 10, PR_FALSE, 0 },
1.1596 + { "abcdefgabcdefg", '\0', 14, PR_FALSE, 0 },
1.1597 + { "abcdefgabcdefg", '\0', 15, PR_TRUE, 14 }
1.1598 + };
1.1599 +
1.1600 + int i;
1.1601 +
1.1602 + printf("Test 018 (PL_strnrchr) ..."); fflush(stdout);
1.1603 +
1.1604 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.1605 + {
1.1606 + char *rv = PL_strnrchr(array[i].str, array[i].chr, array[i].max);
1.1607 +
1.1608 + if( PR_FALSE == array[i].ret )
1.1609 + {
1.1610 + if( (char *)0 != rv )
1.1611 + {
1.1612 + printf("FAIL %d: %s,%c/%lu -> %.32s, not zero\n", i, array[i].str,
1.1613 + array[i].chr, array[i].max, rv);
1.1614 + return PR_FALSE;
1.1615 + }
1.1616 + }
1.1617 + else
1.1618 + {
1.1619 + if( (char *)0 == rv )
1.1620 + {
1.1621 + printf("FAIL %d: %s,%c/%lu -> null, not +%lu\n", i, array[i].str,
1.1622 + array[i].chr, array[i].max, array[i].off);
1.1623 + return PR_FALSE;
1.1624 + }
1.1625 +
1.1626 + if( &array[i].str[ array[i].off ] != rv )
1.1627 + {
1.1628 + printf("FAIL %d: %s,%c/%lu -> 0x%x, not 0x%x+%lu\n", i, array[i].str,
1.1629 + array[i].chr, array[i].max, rv, array[i].str, array[i].off);
1.1630 + return PR_FALSE;
1.1631 + }
1.1632 + }
1.1633 + }
1.1634 +
1.1635 + printf("PASS\n");
1.1636 + return PR_TRUE;
1.1637 +}
1.1638 +
1.1639 +/* PL_strpbrk */
1.1640 +PRBool test_019(void)
1.1641 +{
1.1642 + static struct
1.1643 + {
1.1644 + const char *str;
1.1645 + const char *chrs;
1.1646 + PRBool ret;
1.1647 + PRUint32 off;
1.1648 + } array[] =
1.1649 + {
1.1650 + { (const char *)0, (const char *)0, PR_FALSE, 0 },
1.1651 + { (const char *)0, "abc", PR_FALSE, 0 },
1.1652 + { "abc", (const char *)0, PR_FALSE, 0 },
1.1653 + { "abcdefg", "", PR_FALSE, 0 },
1.1654 + { "", "aeiou", PR_FALSE, 0 },
1.1655 + { "abcdefg", "ae", PR_TRUE, 0 },
1.1656 + { "abcdefg", "ei", PR_TRUE, 4 },
1.1657 + { "abcdefg", "io", PR_FALSE, 0 },
1.1658 + { "abcdefg", "bcd", PR_TRUE, 1 },
1.1659 + { "abcdefg", "cbd", PR_TRUE, 1 },
1.1660 + { "abcdefg", "dbc", PR_TRUE, 1 },
1.1661 + { "abcdefg", "ghi", PR_TRUE, 6 },
1.1662 + { "abcdefg", "AE", PR_FALSE, 0 },
1.1663 + { "abcdefg", "EI", PR_FALSE, 0 },
1.1664 + { "abcdefg", "IO", PR_FALSE, 0 },
1.1665 + { "abcdefg", "BCD", PR_FALSE, 0 },
1.1666 + { "abcdefg", "CBD", PR_FALSE, 0 },
1.1667 + { "abcdefg", "DBC", PR_FALSE, 0 },
1.1668 + { "abcdefg", "GHI", PR_FALSE, 0 },
1.1669 + { "abcdefgabcdefg", "ae", PR_TRUE, 0 },
1.1670 + { "abcdefgabcdefg", "ei", PR_TRUE, 4 },
1.1671 + { "abcdefgabcdefg", "io", PR_FALSE, 0 },
1.1672 + { "abcdefgabcdefg", "bcd", PR_TRUE, 1 },
1.1673 + { "abcdefgabcdefg", "cbd", PR_TRUE, 1 },
1.1674 + { "abcdefgabcdefg", "dbc", PR_TRUE, 1 },
1.1675 + { "abcdefgabcdefg", "ghi", PR_TRUE, 6 },
1.1676 + { "abcdefgabcdefg", "AE", PR_FALSE, 0 },
1.1677 + { "abcdefgabcdefg", "EI", PR_FALSE, 0 },
1.1678 + { "abcdefgabcdefg", "IO", PR_FALSE, 0 },
1.1679 + { "abcdefgabcdefg", "BCD", PR_FALSE, 0 },
1.1680 + { "abcdefgabcdefg", "CBD", PR_FALSE, 0 },
1.1681 + { "abcdefgabcdefg", "DBC", PR_FALSE, 0 },
1.1682 + { "abcdefgabcdefg", "GHI", PR_FALSE, 0 }
1.1683 + };
1.1684 +
1.1685 + int i;
1.1686 +
1.1687 + printf("Test 019 (PL_strpbrk) ..."); fflush(stdout);
1.1688 +
1.1689 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.1690 + {
1.1691 + char *rv = PL_strpbrk(array[i].str, array[i].chrs);
1.1692 +
1.1693 + if( PR_FALSE == array[i].ret )
1.1694 + {
1.1695 + if( (char *)0 != rv )
1.1696 + {
1.1697 + printf("FAIL %d: %s,%s -> %.32s, not null\n", i,
1.1698 + array[i].str ? array[i].str : "(null)",
1.1699 + array[i].chrs ? array[i].chrs : "(null)",
1.1700 + rv);
1.1701 + return PR_FALSE;
1.1702 + }
1.1703 + }
1.1704 + else
1.1705 + {
1.1706 + if( (char *)0 == rv )
1.1707 + {
1.1708 + printf("FAIL %d: %s,%s -> null, not +%lu\n", i,
1.1709 + array[i].str ? array[i].str : "(null)",
1.1710 + array[i].chrs ? array[i].chrs : "(null)",
1.1711 + array[i].off);
1.1712 + return PR_FALSE;
1.1713 + }
1.1714 +
1.1715 + if( &array[i].str[ array[i].off ] != rv )
1.1716 + {
1.1717 + printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i,
1.1718 + array[i].str ? array[i].str : "(null)",
1.1719 + array[i].chrs ? array[i].chrs : "(null)",
1.1720 + rv, array[i].str, array[i].off);
1.1721 + return PR_FALSE;
1.1722 + }
1.1723 + }
1.1724 + }
1.1725 +
1.1726 + printf("PASS\n");
1.1727 + return PR_TRUE;
1.1728 +}
1.1729 +
1.1730 +/* PL_strprbrk */
1.1731 +PRBool test_020(void)
1.1732 +{
1.1733 + static struct
1.1734 + {
1.1735 + const char *str;
1.1736 + const char *chrs;
1.1737 + PRBool ret;
1.1738 + PRUint32 off;
1.1739 + } array[] =
1.1740 + {
1.1741 + { (const char *)0, (const char *)0, PR_FALSE, 0 },
1.1742 + { (const char *)0, "abc", PR_FALSE, 0 },
1.1743 + { "abc", (const char *)0, PR_FALSE, 0 },
1.1744 + { "abcdefg", "", PR_FALSE, 0 },
1.1745 + { "", "aeiou", PR_FALSE, 0 },
1.1746 + { "abcdefg", "ae", PR_TRUE, 4 },
1.1747 + { "abcdefg", "ei", PR_TRUE, 4 },
1.1748 + { "abcdefg", "io", PR_FALSE, 0 },
1.1749 + { "abcdefg", "bcd", PR_TRUE, 3 },
1.1750 + { "abcdefg", "cbd", PR_TRUE, 3 },
1.1751 + { "abcdefg", "dbc", PR_TRUE, 3 },
1.1752 + { "abcdefg", "ghi", PR_TRUE, 6 },
1.1753 + { "abcdefg", "AE", PR_FALSE, 0 },
1.1754 + { "abcdefg", "EI", PR_FALSE, 0 },
1.1755 + { "abcdefg", "IO", PR_FALSE, 0 },
1.1756 + { "abcdefg", "BCD", PR_FALSE, 0 },
1.1757 + { "abcdefg", "CBD", PR_FALSE, 0 },
1.1758 + { "abcdefg", "DBC", PR_FALSE, 0 },
1.1759 + { "abcdefg", "GHI", PR_FALSE, 0 },
1.1760 + { "abcdefgabcdefg", "ae", PR_TRUE, 11 },
1.1761 + { "abcdefgabcdefg", "ei", PR_TRUE, 11 },
1.1762 + { "abcdefgabcdefg", "io", PR_FALSE, 0 },
1.1763 + { "abcdefgabcdefg", "bcd", PR_TRUE, 10 },
1.1764 + { "abcdefgabcdefg", "cbd", PR_TRUE, 10 },
1.1765 + { "abcdefgabcdefg", "dbc", PR_TRUE, 10 },
1.1766 + { "abcdefgabcdefg", "ghi", PR_TRUE, 13 },
1.1767 + { "abcdefgabcdefg", "AE", PR_FALSE, 0 },
1.1768 + { "abcdefgabcdefg", "EI", PR_FALSE, 0 },
1.1769 + { "abcdefgabcdefg", "IO", PR_FALSE, 0 },
1.1770 + { "abcdefgabcdefg", "BCD", PR_FALSE, 0 },
1.1771 + { "abcdefgabcdefg", "CBD", PR_FALSE, 0 },
1.1772 + { "abcdefgabcdefg", "DBC", PR_FALSE, 0 },
1.1773 + { "abcdefgabcdefg", "GHI", PR_FALSE, 0 }
1.1774 + };
1.1775 +
1.1776 + int i;
1.1777 +
1.1778 + printf("Test 020 (PL_strprbrk) ..."); fflush(stdout);
1.1779 +
1.1780 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.1781 + {
1.1782 + char *rv = PL_strprbrk(array[i].str, array[i].chrs);
1.1783 +
1.1784 + if( PR_FALSE == array[i].ret )
1.1785 + {
1.1786 + if( (char *)0 != rv )
1.1787 + {
1.1788 + printf("FAIL %d: %s,%s -> %.32s, not null\n", i,
1.1789 + array[i].str ? array[i].str : "(null)",
1.1790 + array[i].chrs ? array[i].chrs : "(null)",
1.1791 + rv);
1.1792 + return PR_FALSE;
1.1793 + }
1.1794 + }
1.1795 + else
1.1796 + {
1.1797 + if( (char *)0 == rv )
1.1798 + {
1.1799 + printf("FAIL %d: %s,%s -> null, not +%lu\n", i,
1.1800 + array[i].str ? array[i].str : "(null)",
1.1801 + array[i].chrs ? array[i].chrs : "(null)",
1.1802 + array[i].off);
1.1803 + return PR_FALSE;
1.1804 + }
1.1805 +
1.1806 + if( &array[i].str[ array[i].off ] != rv )
1.1807 + {
1.1808 + printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i,
1.1809 + array[i].str ? array[i].str : "(null)",
1.1810 + array[i].chrs ? array[i].chrs : "(null)",
1.1811 + rv, array[i].str, array[i].off);
1.1812 + return PR_FALSE;
1.1813 + }
1.1814 + }
1.1815 + }
1.1816 +
1.1817 + printf("PASS\n");
1.1818 + return PR_TRUE;
1.1819 +}
1.1820 +
1.1821 +/* PL_strnpbrk */
1.1822 +PRBool test_021(void)
1.1823 +{
1.1824 + static struct
1.1825 + {
1.1826 + const char *str;
1.1827 + const char *chrs;
1.1828 + PRUint32 max;
1.1829 + PRBool ret;
1.1830 + PRUint32 off;
1.1831 + } array[] =
1.1832 + {
1.1833 + { (const char *)0, (const char *)0, 3, PR_FALSE, 0 },
1.1834 + { (const char *)0, "abc", 3, PR_FALSE, 0 },
1.1835 + { "abc", (const char *)0, 3, PR_FALSE, 0 },
1.1836 + { "abcdefg", "", 3, PR_FALSE, 0 },
1.1837 + { "", "aeiou", 3, PR_FALSE, 0 },
1.1838 + { "abcdefg", "ae", 0, PR_FALSE, 0 },
1.1839 + { "abcdefg", "ae", 1, PR_TRUE, 0 },
1.1840 + { "abcdefg", "ae", 4, PR_TRUE, 0 },
1.1841 + { "abcdefg", "ae", 5, PR_TRUE, 0 },
1.1842 + { "abcdefg", "ae", 6, PR_TRUE, 0 },
1.1843 + { "abcdefg", "ei", 4, PR_FALSE, 0 },
1.1844 + { "abcdefg", "io", 10, PR_FALSE, 0 },
1.1845 + { "abcdefg", "bcd", 2, PR_TRUE, 1 },
1.1846 + { "abcdefg", "cbd", 2, PR_TRUE, 1 },
1.1847 + { "abcdefg", "dbc", 2, PR_TRUE, 1 },
1.1848 + { "abcdefg", "ghi", 6, PR_FALSE, 0 },
1.1849 + { "abcdefg", "ghi", 7, PR_TRUE, 6 },
1.1850 + { "abcdefg", "AE", 9, PR_FALSE, 0 },
1.1851 + { "abcdefg", "EI", 9, PR_FALSE, 0 },
1.1852 + { "abcdefg", "IO", 9, PR_FALSE, 0 },
1.1853 + { "abcdefg", "BCD", 9, PR_FALSE, 0 },
1.1854 + { "abcdefg", "CBD", 9, PR_FALSE, 0 },
1.1855 + { "abcdefg", "DBC", 9, PR_FALSE, 0 },
1.1856 + { "abcdefg", "GHI", 9, PR_FALSE, 0 },
1.1857 + { "abcdefgabcdefg", "ae", 10, PR_TRUE, 0 },
1.1858 + { "abcdefgabcdefg", "ei", 10, PR_TRUE, 4 },
1.1859 + { "abcdefgabcdefg", "io", 10, PR_FALSE, 0 },
1.1860 + { "abcdefgabcdefg", "bcd", 10, PR_TRUE, 1 },
1.1861 + { "abcdefgabcdefg", "cbd", 10, PR_TRUE, 1 },
1.1862 + { "abcdefgabcdefg", "dbc", 10, PR_TRUE, 1 },
1.1863 + { "abcdefgabcdefg", "ghi", 10, PR_TRUE, 6 },
1.1864 + { "abcdefgabcdefg", "AE", 10, PR_FALSE, 0 },
1.1865 + { "abcdefgabcdefg", "EI", 10, PR_FALSE, 0 },
1.1866 + { "abcdefgabcdefg", "IO", 10, PR_FALSE, 0 },
1.1867 + { "abcdefgabcdefg", "BCD", 10, PR_FALSE, 0 },
1.1868 + { "abcdefgabcdefg", "CBD", 10, PR_FALSE, 0 },
1.1869 + { "abcdefgabcdefg", "DBC", 10, PR_FALSE, 0 },
1.1870 + { "abcdefgabcdefg", "GHI", 10, PR_FALSE, 0 }
1.1871 + };
1.1872 +
1.1873 + int i;
1.1874 +
1.1875 + printf("Test 021 (PL_strnpbrk) ..."); fflush(stdout);
1.1876 +
1.1877 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.1878 + {
1.1879 + char *rv = PL_strnpbrk(array[i].str, array[i].chrs, array[i].max);
1.1880 +
1.1881 + if( PR_FALSE == array[i].ret )
1.1882 + {
1.1883 + if( (char *)0 != rv )
1.1884 + {
1.1885 + printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i,
1.1886 + array[i].str ? array[i].str : "(null)",
1.1887 + array[i].chrs ? array[i].chrs : "(null)",
1.1888 + array[i].max, rv);
1.1889 + return PR_FALSE;
1.1890 + }
1.1891 + }
1.1892 + else
1.1893 + {
1.1894 + if( (char *)0 == rv )
1.1895 + {
1.1896 + printf("FAIL %d: %s,%s/%lu -> null, not +%lu\n", i,
1.1897 + array[i].str ? array[i].str : "(null)",
1.1898 + array[i].chrs ? array[i].chrs : "(null)",
1.1899 + array[i].max, array[i].off);
1.1900 + return PR_FALSE;
1.1901 + }
1.1902 +
1.1903 + if( &array[i].str[ array[i].off ] != rv )
1.1904 + {
1.1905 + printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i,
1.1906 + array[i].str ? array[i].str : "(null)",
1.1907 + array[i].chrs ? array[i].chrs : "(null)",
1.1908 + array[i].max, rv, array[i].str, array[i].off);
1.1909 + return PR_FALSE;
1.1910 + }
1.1911 + }
1.1912 + }
1.1913 +
1.1914 + printf("PASS\n");
1.1915 + return PR_TRUE;
1.1916 +}
1.1917 +
1.1918 +/* PL_strnprbrk */
1.1919 +PRBool test_022(void)
1.1920 +{
1.1921 + static struct
1.1922 + {
1.1923 + const char *str;
1.1924 + const char *chrs;
1.1925 + PRUint32 max;
1.1926 + PRBool ret;
1.1927 + PRUint32 off;
1.1928 + } array[] =
1.1929 + {
1.1930 + { (const char *)0, (const char *)0, 3, PR_FALSE, 0 },
1.1931 + { (const char *)0, "abc", 3, PR_FALSE, 0 },
1.1932 + { "abc", (const char *)0, 3, PR_FALSE, 0 },
1.1933 + { "abcdefg", "", 3, PR_FALSE, 0 },
1.1934 + { "", "aeiou", 3, PR_FALSE, 0 },
1.1935 + { "abcdefg", "ae", 0, PR_FALSE, 0 },
1.1936 + { "abcdefg", "ae", 1, PR_TRUE, 0 },
1.1937 + { "abcdefg", "ae", 4, PR_TRUE, 0 },
1.1938 + { "abcdefg", "ae", 5, PR_TRUE, 4 },
1.1939 + { "abcdefg", "ae", 6, PR_TRUE, 4 },
1.1940 + { "abcdefg", "ei", 4, PR_FALSE, 0 },
1.1941 + { "abcdefg", "io", 10, PR_FALSE, 0 },
1.1942 + { "abcdefg", "bcd", 2, PR_TRUE, 1 },
1.1943 + { "abcdefg", "cbd", 2, PR_TRUE, 1 },
1.1944 + { "abcdefg", "dbc", 2, PR_TRUE, 1 },
1.1945 + { "abcdefg", "bcd", 3, PR_TRUE, 2 },
1.1946 + { "abcdefg", "cbd", 3, PR_TRUE, 2 },
1.1947 + { "abcdefg", "dbc", 3, PR_TRUE, 2 },
1.1948 + { "abcdefg", "bcd", 5, PR_TRUE, 3 },
1.1949 + { "abcdefg", "cbd", 5, PR_TRUE, 3 },
1.1950 + { "abcdefg", "dbc", 5, PR_TRUE, 3 },
1.1951 + { "abcdefg", "bcd", 15, PR_TRUE, 3 },
1.1952 + { "abcdefg", "cbd", 15, PR_TRUE, 3 },
1.1953 + { "abcdefg", "dbc", 15, PR_TRUE, 3 },
1.1954 + { "abcdefg", "ghi", 6, PR_FALSE, 0 },
1.1955 + { "abcdefg", "ghi", 7, PR_TRUE, 6 },
1.1956 + { "abcdefg", "AE", 9, PR_FALSE, 0 },
1.1957 + { "abcdefg", "EI", 9, PR_FALSE, 0 },
1.1958 + { "abcdefg", "IO", 9, PR_FALSE, 0 },
1.1959 + { "abcdefg", "BCD", 9, PR_FALSE, 0 },
1.1960 + { "abcdefg", "CBD", 9, PR_FALSE, 0 },
1.1961 + { "abcdefg", "DBC", 9, PR_FALSE, 0 },
1.1962 + { "abcdefg", "GHI", 9, PR_FALSE, 0 },
1.1963 + { "abcdefgabcdefg", "ae", 10, PR_TRUE, 7 },
1.1964 + { "abcdefgabcdefg", "ei", 10, PR_TRUE, 4 },
1.1965 + { "abcdefgabcdefg", "io", 10, PR_FALSE, 0 },
1.1966 + { "abcdefgabcdefg", "bcd", 10, PR_TRUE, 9 },
1.1967 + { "abcdefgabcdefg", "cbd", 10, PR_TRUE, 9 },
1.1968 + { "abcdefgabcdefg", "dbc", 10, PR_TRUE, 9 },
1.1969 + { "abcdefgabcdefg", "ghi", 10, PR_TRUE, 6 },
1.1970 + { "abcdefgabcdefg", "AE", 10, PR_FALSE, 0 },
1.1971 + { "abcdefgabcdefg", "EI", 10, PR_FALSE, 0 },
1.1972 + { "abcdefgabcdefg", "IO", 10, PR_FALSE, 0 },
1.1973 + { "abcdefgabcdefg", "BCD", 10, PR_FALSE, 0 },
1.1974 + { "abcdefgabcdefg", "CBD", 10, PR_FALSE, 0 },
1.1975 + { "abcdefgabcdefg", "DBC", 10, PR_FALSE, 0 },
1.1976 + { "abcdefgabcdefg", "GHI", 10, PR_FALSE, 0 }
1.1977 + };
1.1978 +
1.1979 + int i;
1.1980 +
1.1981 + printf("Test 022 (PL_strnprbrk) ..."); fflush(stdout);
1.1982 +
1.1983 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.1984 + {
1.1985 + char *rv = PL_strnprbrk(array[i].str, array[i].chrs, array[i].max);
1.1986 +
1.1987 + if( PR_FALSE == array[i].ret )
1.1988 + {
1.1989 + if( (char *)0 != rv )
1.1990 + {
1.1991 + printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i,
1.1992 + array[i].str ? array[i].str : "(null)",
1.1993 + array[i].chrs ? array[i].chrs : "(null)",
1.1994 + array[i].max, rv);
1.1995 + return PR_FALSE;
1.1996 + }
1.1997 + }
1.1998 + else
1.1999 + {
1.2000 + if( (char *)0 == rv )
1.2001 + {
1.2002 + printf("FAIL %d: %s,%s/%lu -> null, not +%lu\n", i,
1.2003 + array[i].str ? array[i].str : "(null)",
1.2004 + array[i].chrs ? array[i].chrs : "(null)",
1.2005 + array[i].max, array[i].off);
1.2006 + return PR_FALSE;
1.2007 + }
1.2008 +
1.2009 + if( &array[i].str[ array[i].off ] != rv )
1.2010 + {
1.2011 + printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i,
1.2012 + array[i].str ? array[i].str : "(null)",
1.2013 + array[i].chrs ? array[i].chrs : "(null)",
1.2014 + array[i].max, rv, array[i].str, array[i].off);
1.2015 + return PR_FALSE;
1.2016 + }
1.2017 + }
1.2018 + }
1.2019 +
1.2020 + printf("PASS\n");
1.2021 + return PR_TRUE;
1.2022 +}
1.2023 +
1.2024 +/* PL_strstr */
1.2025 +PRBool test_023(void)
1.2026 +{
1.2027 + static struct
1.2028 + {
1.2029 + const char *str;
1.2030 + const char *sub;
1.2031 + PRBool ret;
1.2032 + PRUint32 off;
1.2033 + } array[] =
1.2034 + {
1.2035 + { (const char *)0, (const char *)0, PR_FALSE, 0 },
1.2036 + { (const char *)0, "blah", PR_FALSE, 0 },
1.2037 + { "blah-de-blah", (const char *)0, PR_FALSE, 0 },
1.2038 + { "blah-de-blah", "blah", PR_TRUE, 0 },
1.2039 + { "", "blah", PR_FALSE, 0 },
1.2040 + { "blah-de-blah", "", PR_FALSE, 0 },
1.2041 + { "abcdefg", "a", PR_TRUE, 0 },
1.2042 + { "abcdefg", "c", PR_TRUE, 2 },
1.2043 + { "abcdefg", "e", PR_TRUE, 4 },
1.2044 + { "abcdefg", "g", PR_TRUE, 6 },
1.2045 + { "abcdefg", "i", PR_FALSE, 0 },
1.2046 + { "abcdefg", "ab", PR_TRUE, 0 },
1.2047 + { "abcdefg", "cd", PR_TRUE, 2 },
1.2048 + { "abcdefg", "ef", PR_TRUE, 4 },
1.2049 + { "abcdefg", "gh", PR_FALSE, 0 },
1.2050 + { "abcdabc", "bc", PR_TRUE, 1 },
1.2051 + { "abcdefg", "abcdefg", PR_TRUE, 0 },
1.2052 + { "abcdefgabcdefg", "a", PR_TRUE, 0 },
1.2053 + { "abcdefgabcdefg", "c", PR_TRUE, 2 },
1.2054 + { "abcdefgabcdefg", "e", PR_TRUE, 4 },
1.2055 + { "abcdefgabcdefg", "g", PR_TRUE, 6 },
1.2056 + { "abcdefgabcdefg", "i", PR_FALSE, 0 },
1.2057 + { "abcdefgabcdefg", "ab", PR_TRUE, 0 },
1.2058 + { "abcdefgabcdefg", "cd", PR_TRUE, 2 },
1.2059 + { "abcdefgabcdefg", "ef", PR_TRUE, 4 },
1.2060 + { "abcdefgabcdefg", "gh", PR_FALSE, 0 },
1.2061 + { "abcdabcabcdabc", "bc", PR_TRUE, 1 },
1.2062 + { "abcdefgabcdefg", "abcdefg", PR_TRUE, 0 },
1.2063 + { "ABCDEFG", "a", PR_FALSE, 0 },
1.2064 + { "ABCDEFG", "c", PR_FALSE, 0 },
1.2065 + { "ABCDEFG", "e", PR_FALSE, 0 },
1.2066 + { "ABCDEFG", "g", PR_FALSE, 0 },
1.2067 + { "ABCDEFG", "i", PR_FALSE, 0 },
1.2068 + { "ABCDEFG", "ab", PR_FALSE, 0 },
1.2069 + { "ABCDEFG", "cd", PR_FALSE, 0 },
1.2070 + { "ABCDEFG", "ef", PR_FALSE, 0 },
1.2071 + { "ABCDEFG", "gh", PR_FALSE, 0 },
1.2072 + { "ABCDABC", "bc", PR_FALSE, 0 },
1.2073 + { "ABCDEFG", "abcdefg", PR_FALSE, 0 },
1.2074 + { "ABCDEFGABCDEFG", "a", PR_FALSE, 0 },
1.2075 + { "ABCDEFGABCDEFG", "c", PR_FALSE, 0 },
1.2076 + { "ABCDEFGABCDEFG", "e", PR_FALSE, 0 },
1.2077 + { "ABCDEFGABCDEFG", "g", PR_FALSE, 0 },
1.2078 + { "ABCDEFGABCDEFG", "i", PR_FALSE, 0 },
1.2079 + { "ABCDEFGABCDEFG", "ab", PR_FALSE, 0 },
1.2080 + { "ABCDEFGABCDEFG", "cd", PR_FALSE, 0 },
1.2081 + { "ABCDEFGABCDEFG", "ef", PR_FALSE, 0 },
1.2082 + { "ABCDEFGABCDEFG", "gh", PR_FALSE, 0 },
1.2083 + { "ABCDABCABCDABC", "bc", PR_FALSE, 0 },
1.2084 + { "ABCDEFGABCDEFG", "abcdefg", PR_FALSE, 0 }
1.2085 + };
1.2086 +
1.2087 + int i;
1.2088 +
1.2089 + printf("Test 023 (PL_strstr) ..."); fflush(stdout);
1.2090 +
1.2091 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.2092 + {
1.2093 + char *rv = PL_strstr(array[i].str, array[i].sub);
1.2094 +
1.2095 + if( PR_FALSE == array[i].ret )
1.2096 + {
1.2097 + if( (char *)0 != rv )
1.2098 + {
1.2099 + printf("FAIL %d: %s,%s -> %.32s, not null\n", i,
1.2100 + array[i].str ? array[i].str : "(null)",
1.2101 + array[i].sub ? array[i].sub : "(null)",
1.2102 + rv);
1.2103 + return PR_FALSE;
1.2104 + }
1.2105 + }
1.2106 + else
1.2107 + {
1.2108 + if( (char *)0 == rv )
1.2109 + {
1.2110 + printf("FAIL %d: %s,%s -> null, not 0x%x+%lu\n", i,
1.2111 + array[i].str ? array[i].str : "(null)",
1.2112 + array[i].sub ? array[i].sub : "(null)",
1.2113 + array[i].str, array[i].off);
1.2114 + return PR_FALSE;
1.2115 + }
1.2116 +
1.2117 + if( &array[i].str[ array[i].off ] != rv )
1.2118 + {
1.2119 + printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i,
1.2120 + array[i].str ? array[i].str : "(null)",
1.2121 + array[i].sub ? array[i].sub : "(null)",
1.2122 + rv, array[i].str, array[i].off);
1.2123 + return PR_FALSE;
1.2124 + }
1.2125 + }
1.2126 + }
1.2127 +
1.2128 + printf("PASS\n");
1.2129 + return PR_TRUE;
1.2130 +}
1.2131 +
1.2132 +/* PL_strrstr */
1.2133 +PRBool test_024(void)
1.2134 +{
1.2135 + static struct
1.2136 + {
1.2137 + const char *str;
1.2138 + const char *sub;
1.2139 + PRBool ret;
1.2140 + PRUint32 off;
1.2141 + } array[] =
1.2142 + {
1.2143 + { (const char *)0, (const char *)0, PR_FALSE, 0 },
1.2144 + { (const char *)0, "blah", PR_FALSE, 0 },
1.2145 + { "blah-de-blah", (const char *)0, PR_FALSE, 0 },
1.2146 + { "blah-de-blah", "blah", PR_TRUE, 8 },
1.2147 + { "", "blah", PR_FALSE, 0 },
1.2148 + { "blah-de-blah", "", PR_FALSE, 0 },
1.2149 + { "abcdefg", "a", PR_TRUE, 0 },
1.2150 + { "abcdefg", "c", PR_TRUE, 2 },
1.2151 + { "abcdefg", "e", PR_TRUE, 4 },
1.2152 + { "abcdefg", "g", PR_TRUE, 6 },
1.2153 + { "abcdefg", "i", PR_FALSE, 0 },
1.2154 + { "abcdefg", "ab", PR_TRUE, 0 },
1.2155 + { "abcdefg", "cd", PR_TRUE, 2 },
1.2156 + { "abcdefg", "ef", PR_TRUE, 4 },
1.2157 + { "abcdefg", "gh", PR_FALSE, 0 },
1.2158 + { "abcdabc", "bc", PR_TRUE, 5 },
1.2159 + { "abcdefg", "abcdefg", PR_TRUE, 0 },
1.2160 + { "abcdefgabcdefg", "a", PR_TRUE, 7 },
1.2161 + { "abcdefgabcdefg", "c", PR_TRUE, 9 },
1.2162 + { "abcdefgabcdefg", "e", PR_TRUE, 11 },
1.2163 + { "abcdefgabcdefg", "g", PR_TRUE, 13 },
1.2164 + { "abcdefgabcdefg", "i", PR_FALSE, 0 },
1.2165 + { "abcdefgabcdefg", "ab", PR_TRUE, 7 },
1.2166 + { "abcdefgabcdefg", "cd", PR_TRUE, 9 },
1.2167 + { "abcdefgabcdefg", "ef", PR_TRUE, 11 },
1.2168 + { "abcdefgabcdefg", "gh", PR_FALSE, 0 },
1.2169 + { "abcdabcabcdabc", "bc", PR_TRUE, 12 },
1.2170 + { "abcdefgabcdefg", "abcdefg", PR_TRUE, 7 },
1.2171 + { "ABCDEFG", "a", PR_FALSE, 0 },
1.2172 + { "ABCDEFG", "c", PR_FALSE, 0 },
1.2173 + { "ABCDEFG", "e", PR_FALSE, 0 },
1.2174 + { "ABCDEFG", "g", PR_FALSE, 0 },
1.2175 + { "ABCDEFG", "i", PR_FALSE, 0 },
1.2176 + { "ABCDEFG", "ab", PR_FALSE, 0 },
1.2177 + { "ABCDEFG", "cd", PR_FALSE, 0 },
1.2178 + { "ABCDEFG", "ef", PR_FALSE, 0 },
1.2179 + { "ABCDEFG", "gh", PR_FALSE, 0 },
1.2180 + { "ABCDABC", "bc", PR_FALSE, 0 },
1.2181 + { "ABCDEFG", "abcdefg", PR_FALSE, 0 },
1.2182 + { "ABCDEFGABCDEFG", "a", PR_FALSE, 0 },
1.2183 + { "ABCDEFGABCDEFG", "c", PR_FALSE, 0 },
1.2184 + { "ABCDEFGABCDEFG", "e", PR_FALSE, 0 },
1.2185 + { "ABCDEFGABCDEFG", "g", PR_FALSE, 0 },
1.2186 + { "ABCDEFGABCDEFG", "i", PR_FALSE, 0 },
1.2187 + { "ABCDEFGABCDEFG", "ab", PR_FALSE, 0 },
1.2188 + { "ABCDEFGABCDEFG", "cd", PR_FALSE, 0 },
1.2189 + { "ABCDEFGABCDEFG", "ef", PR_FALSE, 0 },
1.2190 + { "ABCDEFGABCDEFG", "gh", PR_FALSE, 0 },
1.2191 + { "ABCDABCABCDABC", "bc", PR_FALSE, 0 },
1.2192 + { "ABCDEFGABCDEFG", "abcdefg", PR_FALSE, 0 }
1.2193 + };
1.2194 +
1.2195 + int i;
1.2196 +
1.2197 + printf("Test 024 (PL_strrstr) ..."); fflush(stdout);
1.2198 +
1.2199 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.2200 + {
1.2201 + char *rv = PL_strrstr(array[i].str, array[i].sub);
1.2202 +
1.2203 + if( PR_FALSE == array[i].ret )
1.2204 + {
1.2205 + if( (char *)0 != rv )
1.2206 + {
1.2207 + printf("FAIL %d: %s,%s -> %.32s, not null\n", i,
1.2208 + array[i].str ? array[i].str : "(null)",
1.2209 + array[i].sub ? array[i].sub : "(null)",
1.2210 + rv);
1.2211 + return PR_FALSE;
1.2212 + }
1.2213 + }
1.2214 + else
1.2215 + {
1.2216 + if( (char *)0 == rv )
1.2217 + {
1.2218 + printf("FAIL %d: %s,%s -> null, not 0x%x+%lu\n", i,
1.2219 + array[i].str ? array[i].str : "(null)",
1.2220 + array[i].sub ? array[i].sub : "(null)",
1.2221 + array[i].str, array[i].off);
1.2222 + return PR_FALSE;
1.2223 + }
1.2224 +
1.2225 + if( &array[i].str[ array[i].off ] != rv )
1.2226 + {
1.2227 + printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i,
1.2228 + array[i].str ? array[i].str : "(null)",
1.2229 + array[i].sub ? array[i].sub : "(null)",
1.2230 + rv, array[i].str, array[i].off);
1.2231 + return PR_FALSE;
1.2232 + }
1.2233 + }
1.2234 + }
1.2235 +
1.2236 + printf("PASS\n");
1.2237 + return PR_TRUE;
1.2238 +}
1.2239 +
1.2240 +/* PL_strnstr */
1.2241 +PRBool test_025(void)
1.2242 +{
1.2243 + static struct
1.2244 + {
1.2245 + const char *str;
1.2246 + const char *sub;
1.2247 + PRUint32 max;
1.2248 + PRBool ret;
1.2249 + PRUint32 off;
1.2250 + } array[] =
1.2251 + {
1.2252 + { (const char *)0, (const char *)0, 12, PR_FALSE, 0 },
1.2253 + { (const char *)0, "blah", 12, PR_FALSE, 0 },
1.2254 + { "blah-de-blah", (const char *)0, 12, PR_FALSE, 0 },
1.2255 + { "blah-de-blah", "blah", 0, PR_FALSE, 0 },
1.2256 + { "blah-de-blah", "blah", 2, PR_FALSE, 0 },
1.2257 + { "blah-de-blah", "blah", 3, PR_FALSE, 0 },
1.2258 + { "blah-de-blah", "blah", 4, PR_TRUE, 0 },
1.2259 + { "blah-de-blah", "blah", 5, PR_TRUE, 0 },
1.2260 + { "blah-de-blah", "blah", 12, PR_TRUE, 0 },
1.2261 + { "", "blah", 12, PR_FALSE, 0 },
1.2262 + { "blah-de-blah", "", 12, PR_FALSE, 0 },
1.2263 + { "abcdefg", "a", 5, PR_TRUE, 0 },
1.2264 + { "abcdefg", "c", 5, PR_TRUE, 2 },
1.2265 + { "abcdefg", "e", 5, PR_TRUE, 4 },
1.2266 + { "abcdefg", "g", 5, PR_FALSE, 0 },
1.2267 + { "abcdefg", "i", 5, PR_FALSE, 0 },
1.2268 + { "abcdefg", "ab", 5, PR_TRUE, 0 },
1.2269 + { "abcdefg", "cd", 5, PR_TRUE, 2 },
1.2270 + { "abcdefg", "ef", 5, PR_FALSE, 0 },
1.2271 + { "abcdefg", "gh", 5, PR_FALSE, 0 },
1.2272 + { "abcdabc", "bc", 5, PR_TRUE, 1 },
1.2273 + { "abcdabc", "bc", 6, PR_TRUE, 1 },
1.2274 + { "abcdabc", "bc", 7, PR_TRUE, 1 },
1.2275 + { "abcdefg", "abcdefg", 6, PR_FALSE, 0 },
1.2276 + { "abcdefg", "abcdefg", 7, PR_TRUE, 0 },
1.2277 + { "abcdefg", "abcdefg", 8, PR_TRUE, 0 },
1.2278 + { "abcdefgabcdefg", "a", 12, PR_TRUE, 0 },
1.2279 + { "abcdefgabcdefg", "c", 12, PR_TRUE, 2 },
1.2280 + { "abcdefgabcdefg", "e", 12, PR_TRUE, 4 },
1.2281 + { "abcdefgabcdefg", "g", 12, PR_TRUE, 6 },
1.2282 + { "abcdefgabcdefg", "i", 12, PR_FALSE, 0 },
1.2283 + { "abcdefgabcdefg", "ab", 12, PR_TRUE, 0 },
1.2284 + { "abcdefgabcdefg", "cd", 12, PR_TRUE, 2 },
1.2285 + { "abcdefgabcdefg", "ef", 12, PR_TRUE, 4 },
1.2286 + { "abcdefgabcdefg", "gh", 12, PR_FALSE, 0 },
1.2287 + { "abcdabcabcdabc", "bc", 5, PR_TRUE, 1 },
1.2288 + { "abcdabcabcdabc", "bc", 6, PR_TRUE, 1 },
1.2289 + { "abcdabcabcdabc", "bc", 7, PR_TRUE, 1 },
1.2290 + { "abcdefgabcdefg", "abcdefg", 6, PR_FALSE, 0 },
1.2291 + { "abcdefgabcdefg", "abcdefg", 7, PR_TRUE, 0 },
1.2292 + { "abcdefgabcdefg", "abcdefg", 8, PR_TRUE, 0 },
1.2293 + { "ABCDEFG", "a", 5, PR_FALSE, 0 },
1.2294 + { "ABCDEFG", "c", 5, PR_FALSE, 0 },
1.2295 + { "ABCDEFG", "e", 5, PR_FALSE, 0 },
1.2296 + { "ABCDEFG", "g", 5, PR_FALSE, 0 },
1.2297 + { "ABCDEFG", "i", 5, PR_FALSE, 0 },
1.2298 + { "ABCDEFG", "ab", 5, PR_FALSE, 0 },
1.2299 + { "ABCDEFG", "cd", 5, PR_FALSE, 0 },
1.2300 + { "ABCDEFG", "ef", 5, PR_FALSE, 0 },
1.2301 + { "ABCDEFG", "gh", 5, PR_FALSE, 0 },
1.2302 + { "ABCDABC", "bc", 5, PR_FALSE, 0 },
1.2303 + { "ABCDABC", "bc", 6, PR_FALSE, 0 },
1.2304 + { "ABCDABC", "bc", 7, PR_FALSE, 0 },
1.2305 + { "ABCDEFG", "abcdefg", 6, PR_FALSE, 0 },
1.2306 + { "ABCDEFG", "abcdefg", 7, PR_FALSE, 0 },
1.2307 + { "ABCDEFG", "abcdefg", 8, PR_FALSE, 0 },
1.2308 + { "ABCDEFGABCDEFG", "a", 12, PR_FALSE, 0 },
1.2309 + { "ABCDEFGABCDEFG", "c", 12, PR_FALSE, 0 },
1.2310 + { "ABCDEFGABCDEFG", "e", 12, PR_FALSE, 0 },
1.2311 + { "ABCDEFGABCDEFG", "g", 12, PR_FALSE, 0 },
1.2312 + { "ABCDEFGABCDEFG", "i", 12, PR_FALSE, 0 },
1.2313 + { "ABCDEFGABCDEFG", "ab", 12, PR_FALSE, 0 },
1.2314 + { "ABCDEFGABCDEFG", "cd", 12, PR_FALSE, 0 },
1.2315 + { "ABCDEFGABCDEFG", "ef", 12, PR_FALSE, 0 },
1.2316 + { "ABCDEFGABCDEFG", "gh", 12, PR_FALSE, 0 },
1.2317 + { "ABCDABCABCDABC", "bc", 5, PR_FALSE, 0 },
1.2318 + { "ABCDABCABCDABC", "bc", 6, PR_FALSE, 0 },
1.2319 + { "ABCDABCABCDABC", "bc", 7, PR_FALSE, },
1.2320 + { "ABCDEFGABCDEFG", "abcdefg", 6, PR_FALSE, 0 },
1.2321 + { "ABCDEFGABCDEFG", "abcdefg", 7, PR_FALSE, 0 },
1.2322 + { "ABCDEFGABCDEFG", "abcdefg", 8, PR_FALSE, 0 }
1.2323 + };
1.2324 +
1.2325 + int i;
1.2326 +
1.2327 + printf("Test 025 (PL_strnstr) ..."); fflush(stdout);
1.2328 +
1.2329 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.2330 + {
1.2331 + char *rv = PL_strnstr(array[i].str, array[i].sub, array[i].max);
1.2332 +
1.2333 + if( PR_FALSE == array[i].ret )
1.2334 + {
1.2335 + if( (char *)0 != rv )
1.2336 + {
1.2337 + printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i,
1.2338 + array[i].str ? array[i].str : "(null)",
1.2339 + array[i].sub ? array[i].sub : "(null)",
1.2340 + array[i].max, rv);
1.2341 + return PR_FALSE;
1.2342 + }
1.2343 + }
1.2344 + else
1.2345 + {
1.2346 + if( (char *)0 == rv )
1.2347 + {
1.2348 + printf("FAIL %d: %s,%s/%lu -> null, not 0x%x+%lu\n", i,
1.2349 + array[i].str ? array[i].str : "(null)",
1.2350 + array[i].sub ? array[i].sub : "(null)",
1.2351 + array[i].max, array[i].str, array[i].off);
1.2352 + return PR_FALSE;
1.2353 + }
1.2354 +
1.2355 + if( &array[i].str[ array[i].off ] != rv )
1.2356 + {
1.2357 + printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i,
1.2358 + array[i].str ? array[i].str : "(null)",
1.2359 + array[i].sub ? array[i].sub : "(null)",
1.2360 + array[i].max, rv, array[i].str, array[i].off);
1.2361 + return PR_FALSE;
1.2362 + }
1.2363 + }
1.2364 + }
1.2365 +
1.2366 + printf("PASS\n");
1.2367 + return PR_TRUE;
1.2368 +}
1.2369 +
1.2370 +/* PL_strnrstr */
1.2371 +PRBool test_026(void)
1.2372 +{
1.2373 + static struct
1.2374 + {
1.2375 + const char *str;
1.2376 + const char *sub;
1.2377 + PRUint32 max;
1.2378 + PRBool ret;
1.2379 + PRUint32 off;
1.2380 + } array[] =
1.2381 + {
1.2382 + { (const char *)0, (const char *)0, 12, PR_FALSE, 0 },
1.2383 + { (const char *)0, "blah", 12, PR_FALSE, 0 },
1.2384 + { "blah-de-blah", (const char *)0, 12, PR_FALSE, 0 },
1.2385 + { "blah-de-blah", "blah", 0, PR_FALSE, 0 },
1.2386 + { "blah-de-blah", "blah", 2, PR_FALSE, 0 },
1.2387 + { "blah-de-blah", "blah", 3, PR_FALSE, 0 },
1.2388 + { "blah-de-blah", "blah", 4, PR_TRUE, 0 },
1.2389 + { "blah-de-blah", "blah", 5, PR_TRUE, 0 },
1.2390 + { "blah-de-blah", "blah", 11, PR_TRUE, 0 },
1.2391 + { "blah-de-blah", "blah", 12, PR_TRUE, 8 },
1.2392 + { "blah-de-blah", "blah", 13, PR_TRUE, 8 },
1.2393 + { "", "blah", 12, PR_FALSE, 0 },
1.2394 + { "blah-de-blah", "", 12, PR_FALSE, 0 },
1.2395 + { "abcdefg", "a", 5, PR_TRUE, 0 },
1.2396 + { "abcdefg", "c", 5, PR_TRUE, 2 },
1.2397 + { "abcdefg", "e", 5, PR_TRUE, 4 },
1.2398 + { "abcdefg", "g", 5, PR_FALSE, 0 },
1.2399 + { "abcdefg", "i", 5, PR_FALSE, 0 },
1.2400 + { "abcdefg", "ab", 5, PR_TRUE, 0 },
1.2401 + { "abcdefg", "cd", 5, PR_TRUE, 2 },
1.2402 + { "abcdefg", "ef", 5, PR_FALSE, 0 },
1.2403 + { "abcdefg", "gh", 5, PR_FALSE, 0 },
1.2404 + { "abcdabc", "bc", 5, PR_TRUE, 1 },
1.2405 + { "abcdabc", "bc", 6, PR_TRUE, 1 },
1.2406 + { "abcdabc", "bc", 7, PR_TRUE, 5 },
1.2407 + { "abcdefg", "abcdefg", 6, PR_FALSE, 0 },
1.2408 + { "abcdefg", "abcdefg", 7, PR_TRUE, 0 },
1.2409 + { "abcdefg", "abcdefg", 8, PR_TRUE, 0 },
1.2410 + { "abcdefgabcdefg", "a", 12, PR_TRUE, 7 },
1.2411 + { "abcdefgabcdefg", "c", 12, PR_TRUE, 9 },
1.2412 + { "abcdefgabcdefg", "e", 12, PR_TRUE, 11 },
1.2413 + { "abcdefgabcdefg", "g", 12, PR_TRUE, 6 },
1.2414 + { "abcdefgabcdefg", "i", 12, PR_FALSE, 0 },
1.2415 + { "abcdefgabcdefg", "ab", 12, PR_TRUE, 7 },
1.2416 + { "abcdefgabcdefg", "cd", 12, PR_TRUE, 9 },
1.2417 + { "abcdefgabcdefg", "ef", 12, PR_TRUE, 4 },
1.2418 + { "abcdefgabcdefg", "gh", 12, PR_FALSE, 0 },
1.2419 + { "abcdabcabcdabc", "bc", 12, PR_TRUE, 8 },
1.2420 + { "abcdabcabcdabc", "bc", 13, PR_TRUE, 8 },
1.2421 + { "abcdabcabcdabc", "bc", 14, PR_TRUE, 12 },
1.2422 + { "abcdefgabcdefg", "abcdefg", 13, PR_TRUE, 0 },
1.2423 + { "abcdefgabcdefg", "abcdefg", 14, PR_TRUE, 7 },
1.2424 + { "abcdefgabcdefg", "abcdefg", 15, PR_TRUE, 7 },
1.2425 + { "ABCDEFG", "a", 5, PR_FALSE, 0 },
1.2426 + { "ABCDEFG", "c", 5, PR_FALSE, 0 },
1.2427 + { "ABCDEFG", "e", 5, PR_FALSE, 0 },
1.2428 + { "ABCDEFG", "g", 5, PR_FALSE, 0 },
1.2429 + { "ABCDEFG", "i", 5, PR_FALSE, 0 },
1.2430 + { "ABCDEFG", "ab", 5, PR_FALSE, 0 },
1.2431 + { "ABCDEFG", "cd", 5, PR_FALSE, 0 },
1.2432 + { "ABCDEFG", "ef", 5, PR_FALSE, 0 },
1.2433 + { "ABCDEFG", "gh", 5, PR_FALSE, 0 },
1.2434 + { "ABCDABC", "bc", 5, PR_FALSE, 0 },
1.2435 + { "ABCDABC", "bc", 6, PR_FALSE, 0 },
1.2436 + { "ABCDABC", "bc", 7, PR_FALSE, 0 },
1.2437 + { "ABCDEFG", "abcdefg", 6, PR_FALSE, 0 },
1.2438 + { "ABCDEFG", "abcdefg", 7, PR_FALSE, 0 },
1.2439 + { "ABCDEFG", "abcdefg", 8, PR_FALSE, 0 },
1.2440 + { "ABCDEFGABCDEFG", "a", 12, PR_FALSE, 0 },
1.2441 + { "ABCDEFGABCDEFG", "c", 12, PR_FALSE, 0 },
1.2442 + { "ABCDEFGABCDEFG", "e", 12, PR_FALSE, 0 },
1.2443 + { "ABCDEFGABCDEFG", "g", 12, PR_FALSE, 0 },
1.2444 + { "ABCDEFGABCDEFG", "i", 12, PR_FALSE, 0 },
1.2445 + { "ABCDEFGABCDEFG", "ab", 12, PR_FALSE, 0 },
1.2446 + { "ABCDEFGABCDEFG", "cd", 12, PR_FALSE, 0 },
1.2447 + { "ABCDEFGABCDEFG", "ef", 12, PR_FALSE, 0 },
1.2448 + { "ABCDEFGABCDEFG", "gh", 12, PR_FALSE, 0 },
1.2449 + { "ABCDABCABCDABC", "bc", 12, PR_FALSE, 0 },
1.2450 + { "ABCDABCABCDABC", "bc", 13, PR_FALSE, 0 },
1.2451 + { "ABCDABCABCDABC", "bc", 14, PR_FALSE, 0 },
1.2452 + { "ABCDEFGABCDEFG", "abcdefg", 13, PR_FALSE, 0 },
1.2453 + { "ABCDEFGABCDEFG", "abcdefg", 14, PR_FALSE, 0 },
1.2454 + { "ABCDEFGABCDEFG", "abcdefg", 15, PR_FALSE, 0 }
1.2455 + };
1.2456 +
1.2457 + int i;
1.2458 +
1.2459 + printf("Test 026 (PL_strnrstr) ..."); fflush(stdout);
1.2460 +
1.2461 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.2462 + {
1.2463 + char *rv = PL_strnrstr(array[i].str, array[i].sub, array[i].max);
1.2464 +
1.2465 + if( PR_FALSE == array[i].ret )
1.2466 + {
1.2467 + if( (char *)0 != rv )
1.2468 + {
1.2469 + printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i,
1.2470 + array[i].str ? array[i].str : "(null)",
1.2471 + array[i].sub ? array[i].sub : "(null)",
1.2472 + array[i].max, rv);
1.2473 + return PR_FALSE;
1.2474 + }
1.2475 + }
1.2476 + else
1.2477 + {
1.2478 + if( (char *)0 == rv )
1.2479 + {
1.2480 + printf("FAIL %d: %s,%s/%lu -> null, not 0x%x+%lu\n", i,
1.2481 + array[i].str ? array[i].str : "(null)",
1.2482 + array[i].sub ? array[i].sub : "(null)",
1.2483 + array[i].max, array[i].str, array[i].off);
1.2484 + return PR_FALSE;
1.2485 + }
1.2486 +
1.2487 + if( &array[i].str[ array[i].off ] != rv )
1.2488 + {
1.2489 + printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i,
1.2490 + array[i].str ? array[i].str : "(null)",
1.2491 + array[i].sub ? array[i].sub : "(null)",
1.2492 + array[i].max, rv, array[i].str, array[i].off);
1.2493 + return PR_FALSE;
1.2494 + }
1.2495 + }
1.2496 + }
1.2497 +
1.2498 + printf("PASS\n");
1.2499 + return PR_TRUE;
1.2500 +}
1.2501 +
1.2502 +/* PL_strcasestr */
1.2503 +PRBool test_027(void)
1.2504 +{
1.2505 + static struct
1.2506 + {
1.2507 + const char *str;
1.2508 + const char *sub;
1.2509 + PRBool ret;
1.2510 + PRUint32 off;
1.2511 + } array[] =
1.2512 + {
1.2513 + { (const char *)0, (const char *)0, PR_FALSE, 0 },
1.2514 + { (const char *)0, "blah", PR_FALSE, 0 },
1.2515 + { "blah-de-blah", (const char *)0, PR_FALSE, 0 },
1.2516 + { "blah-de-blah", "blah", PR_TRUE, 0 },
1.2517 + { "", "blah", PR_FALSE, 0 },
1.2518 + { "blah-de-blah", "", PR_FALSE, 0 },
1.2519 + { "abcdefg", "a", PR_TRUE, 0 },
1.2520 + { "abcdefg", "c", PR_TRUE, 2 },
1.2521 + { "abcdefg", "e", PR_TRUE, 4 },
1.2522 + { "abcdefg", "g", PR_TRUE, 6 },
1.2523 + { "abcdefg", "i", PR_FALSE, 0 },
1.2524 + { "abcdefg", "ab", PR_TRUE, 0 },
1.2525 + { "abcdefg", "cd", PR_TRUE, 2 },
1.2526 + { "abcdefg", "ef", PR_TRUE, 4 },
1.2527 + { "abcdefg", "gh", PR_FALSE, 0 },
1.2528 + { "abcdabc", "bc", PR_TRUE, 1 },
1.2529 + { "abcdefg", "abcdefg", PR_TRUE, 0 },
1.2530 + { "abcdefgabcdefg", "a", PR_TRUE, 0 },
1.2531 + { "abcdefgabcdefg", "c", PR_TRUE, 2 },
1.2532 + { "abcdefgabcdefg", "e", PR_TRUE, 4 },
1.2533 + { "abcdefgabcdefg", "g", PR_TRUE, 6 },
1.2534 + { "abcdefgabcdefg", "i", PR_FALSE, 0 },
1.2535 + { "abcdefgabcdefg", "ab", PR_TRUE, 0 },
1.2536 + { "abcdefgabcdefg", "cd", PR_TRUE, 2 },
1.2537 + { "abcdefgabcdefg", "ef", PR_TRUE, 4 },
1.2538 + { "abcdefgabcdefg", "gh", PR_FALSE, 0 },
1.2539 + { "abcdabcabcdabc", "bc", PR_TRUE, 1 },
1.2540 + { "abcdefgabcdefg", "abcdefg", PR_TRUE, 0 },
1.2541 + { "ABCDEFG", "a", PR_TRUE, 0 },
1.2542 + { "ABCDEFG", "c", PR_TRUE, 2 },
1.2543 + { "ABCDEFG", "e", PR_TRUE, 4 },
1.2544 + { "ABCDEFG", "g", PR_TRUE, 6 },
1.2545 + { "ABCDEFG", "i", PR_FALSE, 0 },
1.2546 + { "ABCDEFG", "ab", PR_TRUE, 0 },
1.2547 + { "ABCDEFG", "cd", PR_TRUE, 2 },
1.2548 + { "ABCDEFG", "ef", PR_TRUE, 4 },
1.2549 + { "ABCDEFG", "gh", PR_FALSE, 0 },
1.2550 + { "ABCDABC", "bc", PR_TRUE, 1 },
1.2551 + { "ABCDEFG", "abcdefg", PR_TRUE, 0 },
1.2552 + { "ABCDEFGABCDEFG", "a", PR_TRUE, 0 },
1.2553 + { "ABCDEFGABCDEFG", "c", PR_TRUE, 2 },
1.2554 + { "ABCDEFGABCDEFG", "e", PR_TRUE, 4 },
1.2555 + { "ABCDEFGABCDEFG", "g", PR_TRUE, 6 },
1.2556 + { "ABCDEFGABCDEFG", "i", PR_FALSE, 0 },
1.2557 + { "ABCDEFGABCDEFG", "ab", PR_TRUE, 0 },
1.2558 + { "ABCDEFGABCDEFG", "cd", PR_TRUE, 2 },
1.2559 + { "ABCDEFGABCDEFG", "ef", PR_TRUE, 4 },
1.2560 + { "ABCDEFGABCDEFG", "gh", PR_FALSE, 0 },
1.2561 + { "ABCDABCABCDABC", "bc", PR_TRUE, 1 },
1.2562 + { "ABCDEFGABCDEFG", "abcdefg", PR_TRUE, 0 }
1.2563 + };
1.2564 +
1.2565 + int i;
1.2566 +
1.2567 + printf("Test 027 (PL_strcasestr) ..."); fflush(stdout);
1.2568 +
1.2569 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.2570 + {
1.2571 + char *rv = PL_strcasestr(array[i].str, array[i].sub);
1.2572 +
1.2573 + if( PR_FALSE == array[i].ret )
1.2574 + {
1.2575 + if( (char *)0 != rv )
1.2576 + {
1.2577 + printf("FAIL %d: %s,%s -> %.32s, not null\n", i,
1.2578 + array[i].str ? array[i].str : "(null)",
1.2579 + array[i].sub ? array[i].sub : "(null)",
1.2580 + rv);
1.2581 + return PR_FALSE;
1.2582 + }
1.2583 + }
1.2584 + else
1.2585 + {
1.2586 + if( (char *)0 == rv )
1.2587 + {
1.2588 + printf("FAIL %d: %s,%s -> null, not 0x%x+%lu\n", i,
1.2589 + array[i].str ? array[i].str : "(null)",
1.2590 + array[i].sub ? array[i].sub : "(null)",
1.2591 + array[i].str, array[i].off);
1.2592 + return PR_FALSE;
1.2593 + }
1.2594 +
1.2595 + if( &array[i].str[ array[i].off ] != rv )
1.2596 + {
1.2597 + printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i,
1.2598 + array[i].str ? array[i].str : "(null)",
1.2599 + array[i].sub ? array[i].sub : "(null)",
1.2600 + rv, array[i].str, array[i].off);
1.2601 + return PR_FALSE;
1.2602 + }
1.2603 + }
1.2604 + }
1.2605 +
1.2606 + printf("PASS\n");
1.2607 + return PR_TRUE;
1.2608 +}
1.2609 +
1.2610 +/* PL_strcaserstr */
1.2611 +PRBool test_028(void)
1.2612 +{
1.2613 + static struct
1.2614 + {
1.2615 + const char *str;
1.2616 + const char *sub;
1.2617 + PRBool ret;
1.2618 + PRUint32 off;
1.2619 + } array[] =
1.2620 + {
1.2621 + { (const char *)0, (const char *)0, PR_FALSE, 0 },
1.2622 + { (const char *)0, "blah", PR_FALSE, 0 },
1.2623 + { "blah-de-blah", (const char *)0, PR_FALSE, 0 },
1.2624 + { "blah-de-blah", "blah", PR_TRUE, 8 },
1.2625 + { "", "blah", PR_FALSE, 0 },
1.2626 + { "blah-de-blah", "", PR_FALSE, 0 },
1.2627 + { "abcdefg", "a", PR_TRUE, 0 },
1.2628 + { "abcdefg", "c", PR_TRUE, 2 },
1.2629 + { "abcdefg", "e", PR_TRUE, 4 },
1.2630 + { "abcdefg", "g", PR_TRUE, 6 },
1.2631 + { "abcdefg", "i", PR_FALSE, 0 },
1.2632 + { "abcdefg", "ab", PR_TRUE, 0 },
1.2633 + { "abcdefg", "cd", PR_TRUE, 2 },
1.2634 + { "abcdefg", "ef", PR_TRUE, 4 },
1.2635 + { "abcdefg", "gh", PR_FALSE, 0 },
1.2636 + { "abcdabc", "bc", PR_TRUE, 5 },
1.2637 + { "abcdefg", "abcdefg", PR_TRUE, 0 },
1.2638 + { "abcdefgabcdefg", "a", PR_TRUE, 7 },
1.2639 + { "abcdefgabcdefg", "c", PR_TRUE, 9 },
1.2640 + { "abcdefgabcdefg", "e", PR_TRUE, 11 },
1.2641 + { "abcdefgabcdefg", "g", PR_TRUE, 13 },
1.2642 + { "abcdefgabcdefg", "i", PR_FALSE, 0 },
1.2643 + { "abcdefgabcdefg", "ab", PR_TRUE, 7 },
1.2644 + { "abcdefgabcdefg", "cd", PR_TRUE, 9 },
1.2645 + { "abcdefgabcdefg", "ef", PR_TRUE, 11 },
1.2646 + { "abcdefgabcdefg", "gh", PR_FALSE, 0 },
1.2647 + { "abcdabcabcdabc", "bc", PR_TRUE, 12 },
1.2648 + { "abcdefgabcdefg", "abcdefg", PR_TRUE, 7 },
1.2649 + { "ABCDEFG", "a", PR_TRUE, 0 },
1.2650 + { "ABCDEFG", "c", PR_TRUE, 2 },
1.2651 + { "ABCDEFG", "e", PR_TRUE, 4 },
1.2652 + { "ABCDEFG", "g", PR_TRUE, 6 },
1.2653 + { "ABCDEFG", "i", PR_FALSE, 0 },
1.2654 + { "ABCDEFG", "ab", PR_TRUE, 0 },
1.2655 + { "ABCDEFG", "cd", PR_TRUE, 2 },
1.2656 + { "ABCDEFG", "ef", PR_TRUE, 4 },
1.2657 + { "ABCDEFG", "gh", PR_FALSE, 0 },
1.2658 + { "ABCDABC", "bc", PR_TRUE, 5 },
1.2659 + { "ABCDEFG", "abcdefg", PR_TRUE, 0 },
1.2660 + { "ABCDEFGABCDEFG", "a", PR_TRUE, 7 },
1.2661 + { "ABCDEFGABCDEFG", "c", PR_TRUE, 9 },
1.2662 + { "ABCDEFGABCDEFG", "e", PR_TRUE, 11 },
1.2663 + { "ABCDEFGABCDEFG", "g", PR_TRUE, 13 },
1.2664 + { "ABCDEFGABCDEFG", "i", PR_FALSE, 0 },
1.2665 + { "ABCDEFGABCDEFG", "ab", PR_TRUE, 7 },
1.2666 + { "ABCDEFGABCDEFG", "cd", PR_TRUE, 9 },
1.2667 + { "ABCDEFGABCDEFG", "ef", PR_TRUE, 11 },
1.2668 + { "ABCDEFGABCDEFG", "gh", PR_FALSE, 0 },
1.2669 + { "ABCDABCABCDABC", "bc", PR_TRUE, 12 },
1.2670 + { "ABCDEFGABCDEFG", "abcdefg", PR_TRUE, 7 }
1.2671 + };
1.2672 +
1.2673 + int i;
1.2674 +
1.2675 + printf("Test 028 (PL_strcaserstr) ..."); fflush(stdout);
1.2676 +
1.2677 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.2678 + {
1.2679 + char *rv = PL_strcaserstr(array[i].str, array[i].sub);
1.2680 +
1.2681 + if( PR_FALSE == array[i].ret )
1.2682 + {
1.2683 + if( (char *)0 != rv )
1.2684 + {
1.2685 + printf("FAIL %d: %s,%s -> %.32s, not null\n", i,
1.2686 + array[i].str ? array[i].str : "(null)",
1.2687 + array[i].sub ? array[i].sub : "(null)",
1.2688 + rv);
1.2689 + return PR_FALSE;
1.2690 + }
1.2691 + }
1.2692 + else
1.2693 + {
1.2694 + if( (char *)0 == rv )
1.2695 + {
1.2696 + printf("FAIL %d: %s,%s -> null, not 0x%x+%lu\n", i,
1.2697 + array[i].str ? array[i].str : "(null)",
1.2698 + array[i].sub ? array[i].sub : "(null)",
1.2699 + array[i].str, array[i].off);
1.2700 + return PR_FALSE;
1.2701 + }
1.2702 +
1.2703 + if( &array[i].str[ array[i].off ] != rv )
1.2704 + {
1.2705 + printf("FAIL %d: %s,%s -> 0x%x, not 0x%x+%lu\n", i,
1.2706 + array[i].str ? array[i].str : "(null)",
1.2707 + array[i].sub ? array[i].sub : "(null)",
1.2708 + rv, array[i].str, array[i].off);
1.2709 + return PR_FALSE;
1.2710 + }
1.2711 + }
1.2712 + }
1.2713 +
1.2714 + printf("PASS\n");
1.2715 + return PR_TRUE;
1.2716 +}
1.2717 +
1.2718 +/* PL_strncasestr */
1.2719 +PRBool test_029(void)
1.2720 +{
1.2721 + static struct
1.2722 + {
1.2723 + const char *str;
1.2724 + const char *sub;
1.2725 + PRUint32 max;
1.2726 + PRBool ret;
1.2727 + PRUint32 off;
1.2728 + } array[] =
1.2729 + {
1.2730 + { (const char *)0, (const char *)0, 12, PR_FALSE, 0 },
1.2731 + { (const char *)0, "blah", 12, PR_FALSE, 0 },
1.2732 + { "blah-de-blah", (const char *)0, 12, PR_FALSE, 0 },
1.2733 + { "blah-de-blah", "blah", 0, PR_FALSE, 0 },
1.2734 + { "blah-de-blah", "blah", 2, PR_FALSE, 0 },
1.2735 + { "blah-de-blah", "blah", 3, PR_FALSE, 0 },
1.2736 + { "blah-de-blah", "blah", 4, PR_TRUE, 0 },
1.2737 + { "blah-de-blah", "blah", 5, PR_TRUE, 0 },
1.2738 + { "blah-de-blah", "blah", 12, PR_TRUE, 0 },
1.2739 + { "", "blah", 12, PR_FALSE, 0 },
1.2740 + { "blah-de-blah", "", 12, PR_FALSE, 0 },
1.2741 + { "abcdefg", "a", 5, PR_TRUE, 0 },
1.2742 + { "abcdefg", "c", 5, PR_TRUE, 2 },
1.2743 + { "abcdefg", "e", 5, PR_TRUE, 4 },
1.2744 + { "abcdefg", "g", 5, PR_FALSE, 0 },
1.2745 + { "abcdefg", "i", 5, PR_FALSE, 0 },
1.2746 + { "abcdefg", "ab", 5, PR_TRUE, 0 },
1.2747 + { "abcdefg", "cd", 5, PR_TRUE, 2 },
1.2748 + { "abcdefg", "ef", 5, PR_FALSE, 0 },
1.2749 + { "abcdefg", "gh", 5, PR_FALSE, 0 },
1.2750 + { "abcdabc", "bc", 5, PR_TRUE, 1 },
1.2751 + { "abcdabc", "bc", 6, PR_TRUE, 1 },
1.2752 + { "abcdabc", "bc", 7, PR_TRUE, 1 },
1.2753 + { "abcdefg", "abcdefg", 6, PR_FALSE, 0 },
1.2754 + { "abcdefg", "abcdefg", 7, PR_TRUE, 0 },
1.2755 + { "abcdefg", "abcdefg", 8, PR_TRUE, 0 },
1.2756 + { "abcdefgabcdefg", "a", 12, PR_TRUE, 0 },
1.2757 + { "abcdefgabcdefg", "c", 12, PR_TRUE, 2 },
1.2758 + { "abcdefgabcdefg", "e", 12, PR_TRUE, 4 },
1.2759 + { "abcdefgabcdefg", "g", 12, PR_TRUE, 6 },
1.2760 + { "abcdefgabcdefg", "i", 12, PR_FALSE, 0 },
1.2761 + { "abcdefgabcdefg", "ab", 12, PR_TRUE, 0 },
1.2762 + { "abcdefgabcdefg", "cd", 12, PR_TRUE, 2 },
1.2763 + { "abcdefgabcdefg", "ef", 12, PR_TRUE, 4 },
1.2764 + { "abcdefgabcdefg", "gh", 12, PR_FALSE, 0 },
1.2765 + { "abcdabcabcdabc", "bc", 5, PR_TRUE, 1 },
1.2766 + { "abcdabcabcdabc", "bc", 6, PR_TRUE, 1 },
1.2767 + { "abcdabcabcdabc", "bc", 7, PR_TRUE, 1 },
1.2768 + { "abcdefgabcdefg", "abcdefg", 6, PR_FALSE, 0 },
1.2769 + { "abcdefgabcdefg", "abcdefg", 7, PR_TRUE, 0 },
1.2770 + { "abcdefgabcdefg", "abcdefg", 8, PR_TRUE, 0 },
1.2771 + { "ABCDEFG", "a", 5, PR_TRUE, 0 },
1.2772 + { "ABCDEFG", "c", 5, PR_TRUE, 2 },
1.2773 + { "ABCDEFG", "e", 5, PR_TRUE, 4 },
1.2774 + { "ABCDEFG", "g", 5, PR_FALSE, 0 },
1.2775 + { "ABCDEFG", "i", 5, PR_FALSE, 0 },
1.2776 + { "ABCDEFG", "ab", 5, PR_TRUE, 0 },
1.2777 + { "ABCDEFG", "cd", 5, PR_TRUE, 2 },
1.2778 + { "ABCDEFG", "ef", 5, PR_FALSE, 0 },
1.2779 + { "ABCDEFG", "gh", 5, PR_FALSE, 0 },
1.2780 + { "ABCDABC", "bc", 5, PR_TRUE, 1 },
1.2781 + { "ABCDABC", "bc", 6, PR_TRUE, 1 },
1.2782 + { "ABCDABC", "bc", 7, PR_TRUE, 1 },
1.2783 + { "ABCDEFG", "abcdefg", 6, PR_FALSE, 0 },
1.2784 + { "ABCDEFG", "abcdefg", 7, PR_TRUE, 0 },
1.2785 + { "ABCDEFG", "abcdefg", 8, PR_TRUE, 0 },
1.2786 + { "ABCDEFGABCDEFG", "a", 12, PR_TRUE, 0 },
1.2787 + { "ABCDEFGABCDEFG", "c", 12, PR_TRUE, 2 },
1.2788 + { "ABCDEFGABCDEFG", "e", 12, PR_TRUE, 4 },
1.2789 + { "ABCDEFGABCDEFG", "g", 12, PR_TRUE, 6 },
1.2790 + { "ABCDEFGABCDEFG", "i", 12, PR_FALSE, 0 },
1.2791 + { "ABCDEFGABCDEFG", "ab", 12, PR_TRUE, 0 },
1.2792 + { "ABCDEFGABCDEFG", "cd", 12, PR_TRUE, 2 },
1.2793 + { "ABCDEFGABCDEFG", "ef", 12, PR_TRUE, 4 },
1.2794 + { "ABCDEFGABCDEFG", "gh", 12, PR_FALSE, 0 },
1.2795 + { "ABCDABCABCDABC", "bc", 5, PR_TRUE, 1 },
1.2796 + { "ABCDABCABCDABC", "bc", 6, PR_TRUE, 1 },
1.2797 + { "ABCDABCABCDABC", "bc", 7, PR_TRUE, 1 },
1.2798 + { "ABCDEFGABCDEFG", "abcdefg", 6, PR_FALSE, 0 },
1.2799 + { "ABCDEFGABCDEFG", "abcdefg", 7, PR_TRUE, 0 },
1.2800 + { "ABCDEFGABCDEFG", "abcdefg", 8, PR_TRUE, 0 }
1.2801 + };
1.2802 +
1.2803 + int i;
1.2804 +
1.2805 + printf("Test 029 (PL_strncasestr) ..."); fflush(stdout);
1.2806 +
1.2807 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.2808 + {
1.2809 + char *rv = PL_strncasestr(array[i].str, array[i].sub, array[i].max);
1.2810 +
1.2811 + if( PR_FALSE == array[i].ret )
1.2812 + {
1.2813 + if( (char *)0 != rv )
1.2814 + {
1.2815 + printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i,
1.2816 + array[i].str ? array[i].str : "(null)",
1.2817 + array[i].sub ? array[i].sub : "(null)",
1.2818 + array[i].max, rv);
1.2819 + return PR_FALSE;
1.2820 + }
1.2821 + }
1.2822 + else
1.2823 + {
1.2824 + if( (char *)0 == rv )
1.2825 + {
1.2826 + printf("FAIL %d: %s,%s/%lu -> null, not 0x%x+%lu\n", i,
1.2827 + array[i].str ? array[i].str : "(null)",
1.2828 + array[i].sub ? array[i].sub : "(null)",
1.2829 + array[i].max, array[i].str, array[i].off);
1.2830 + return PR_FALSE;
1.2831 + }
1.2832 +
1.2833 + if( &array[i].str[ array[i].off ] != rv )
1.2834 + {
1.2835 + printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i,
1.2836 + array[i].str ? array[i].str : "(null)",
1.2837 + array[i].sub ? array[i].sub : "(null)",
1.2838 + array[i].max, rv, array[i].str, array[i].off);
1.2839 + return PR_FALSE;
1.2840 + }
1.2841 + }
1.2842 + }
1.2843 +
1.2844 + printf("PASS\n");
1.2845 + return PR_TRUE;
1.2846 +}
1.2847 +
1.2848 +/* PL_strncaserstr */
1.2849 +PRBool test_030(void)
1.2850 +{
1.2851 + static struct
1.2852 + {
1.2853 + const char *str;
1.2854 + const char *sub;
1.2855 + PRUint32 max;
1.2856 + PRBool ret;
1.2857 + PRUint32 off;
1.2858 + } array[] =
1.2859 + {
1.2860 + { (const char *)0, (const char *)0, 12, PR_FALSE, 0 },
1.2861 + { (const char *)0, "blah", 12, PR_FALSE, 0 },
1.2862 + { "blah-de-blah", (const char *)0, 12, PR_FALSE, 0 },
1.2863 + { "blah-de-blah", "blah", 0, PR_FALSE, 0 },
1.2864 + { "blah-de-blah", "blah", 2, PR_FALSE, 0 },
1.2865 + { "blah-de-blah", "blah", 3, PR_FALSE, 0 },
1.2866 + { "blah-de-blah", "blah", 4, PR_TRUE, 0 },
1.2867 + { "blah-de-blah", "blah", 5, PR_TRUE, 0 },
1.2868 + { "blah-de-blah", "blah", 11, PR_TRUE, 0 },
1.2869 + { "blah-de-blah", "blah", 12, PR_TRUE, 8 },
1.2870 + { "blah-de-blah", "blah", 13, PR_TRUE, 8 },
1.2871 + { "", "blah", 12, PR_FALSE, 0 },
1.2872 + { "blah-de-blah", "", 12, PR_FALSE, 0 },
1.2873 + { "abcdefg", "a", 5, PR_TRUE, 0 },
1.2874 + { "abcdefg", "c", 5, PR_TRUE, 2 },
1.2875 + { "abcdefg", "e", 5, PR_TRUE, 4 },
1.2876 + { "abcdefg", "g", 5, PR_FALSE, 0 },
1.2877 + { "abcdefg", "i", 5, PR_FALSE, 0 },
1.2878 + { "abcdefg", "ab", 5, PR_TRUE, 0 },
1.2879 + { "abcdefg", "cd", 5, PR_TRUE, 2 },
1.2880 + { "abcdefg", "ef", 5, PR_FALSE, 0 },
1.2881 + { "abcdefg", "gh", 5, PR_FALSE, 0 },
1.2882 + { "abcdabc", "bc", 5, PR_TRUE, 1 },
1.2883 + { "abcdabc", "bc", 6, PR_TRUE, 1 },
1.2884 + { "abcdabc", "bc", 7, PR_TRUE, 5 },
1.2885 + { "abcdefg", "abcdefg", 6, PR_FALSE, 0 },
1.2886 + { "abcdefg", "abcdefg", 7, PR_TRUE, 0 },
1.2887 + { "abcdefg", "abcdefg", 8, PR_TRUE, 0 },
1.2888 + { "abcdefgabcdefg", "a", 12, PR_TRUE, 7 },
1.2889 + { "abcdefgabcdefg", "c", 12, PR_TRUE, 9 },
1.2890 + { "abcdefgabcdefg", "e", 12, PR_TRUE, 11 },
1.2891 + { "abcdefgabcdefg", "g", 12, PR_TRUE, 6 },
1.2892 + { "abcdefgabcdefg", "i", 12, PR_FALSE, 0 },
1.2893 + { "abcdefgabcdefg", "ab", 12, PR_TRUE, 7 },
1.2894 + { "abcdefgabcdefg", "cd", 12, PR_TRUE, 9 },
1.2895 + { "abcdefgabcdefg", "ef", 12, PR_TRUE, 4 },
1.2896 + { "abcdefgabcdefg", "gh", 12, PR_FALSE, 0 },
1.2897 + { "abcdabcabcdabc", "bc", 12, PR_TRUE, 8 },
1.2898 + { "abcdabcabcdabc", "bc", 13, PR_TRUE, 8 },
1.2899 + { "abcdabcabcdabc", "bc", 14, PR_TRUE, 12 },
1.2900 + { "abcdefgabcdefg", "abcdefg", 13, PR_TRUE, 0 },
1.2901 + { "abcdefgabcdefg", "abcdefg", 14, PR_TRUE, 7 },
1.2902 + { "abcdefgabcdefg", "abcdefg", 15, PR_TRUE, 7 },
1.2903 + { "ABCDEFG", "a", 5, PR_TRUE, 0 },
1.2904 + { "ABCDEFG", "c", 5, PR_TRUE, 2 },
1.2905 + { "ABCDEFG", "e", 5, PR_TRUE, 4 },
1.2906 + { "ABCDEFG", "g", 5, PR_FALSE, 0 },
1.2907 + { "ABCDEFG", "i", 5, PR_FALSE, 0 },
1.2908 + { "ABCDEFG", "ab", 5, PR_TRUE, 0 },
1.2909 + { "ABCDEFG", "cd", 5, PR_TRUE, 2 },
1.2910 + { "ABCDEFG", "ef", 5, PR_FALSE, 0 },
1.2911 + { "ABCDEFG", "gh", 5, PR_FALSE, 0 },
1.2912 + { "ABCDABC", "bc", 5, PR_TRUE, 1 },
1.2913 + { "ABCDABC", "bc", 6, PR_TRUE, 1 },
1.2914 + { "ABCDABC", "bc", 7, PR_TRUE, 5 },
1.2915 + { "ABCDEFG", "abcdefg", 6, PR_FALSE, 0 },
1.2916 + { "ABCDEFG", "abcdefg", 7, PR_TRUE, 0 },
1.2917 + { "ABCDEFG", "abcdefg", 8, PR_TRUE, 0 },
1.2918 + { "ABCDEFGABCDEFG", "a", 12, PR_TRUE, 7 },
1.2919 + { "ABCDEFGABCDEFG", "c", 12, PR_TRUE, 9 },
1.2920 + { "ABCDEFGABCDEFG", "e", 12, PR_TRUE, 11 },
1.2921 + { "ABCDEFGABCDEFG", "g", 12, PR_TRUE, 6 },
1.2922 + { "ABCDEFGABCDEFG", "i", 12, PR_FALSE, 0 },
1.2923 + { "ABCDEFGABCDEFG", "ab", 12, PR_TRUE, 7 },
1.2924 + { "ABCDEFGABCDEFG", "cd", 12, PR_TRUE, 9 },
1.2925 + { "ABCDEFGABCDEFG", "ef", 12, PR_TRUE, 4 },
1.2926 + { "ABCDEFGABCDEFG", "gh", 12, PR_FALSE, 0 },
1.2927 + { "ABCDABCABCDABC", "bc", 12, PR_TRUE, 8 },
1.2928 + { "ABCDABCABCDABC", "bc", 13, PR_TRUE, 8 },
1.2929 + { "ABCDABCABCDABC", "bc", 14, PR_TRUE, 12 },
1.2930 + { "ABCDEFGABCDEFG", "abcdefg", 13, PR_TRUE, 0 },
1.2931 + { "ABCDEFGABCDEFG", "abcdefg", 14, PR_TRUE, 7 },
1.2932 + { "ABCDEFGABCDEFG", "abcdefg", 15, PR_TRUE, 7 }
1.2933 + };
1.2934 +
1.2935 + int i;
1.2936 +
1.2937 + printf("Test 030 (PL_strncaserstr)..."); fflush(stdout);
1.2938 +
1.2939 + for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
1.2940 + {
1.2941 + char *rv = PL_strncaserstr(array[i].str, array[i].sub, array[i].max);
1.2942 +
1.2943 + if( PR_FALSE == array[i].ret )
1.2944 + {
1.2945 + if( (char *)0 != rv )
1.2946 + {
1.2947 + printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i,
1.2948 + array[i].str ? array[i].str : "(null)",
1.2949 + array[i].sub ? array[i].sub : "(null)",
1.2950 + array[i].max, rv);
1.2951 + return PR_FALSE;
1.2952 + }
1.2953 + }
1.2954 + else
1.2955 + {
1.2956 + if( (char *)0 == rv )
1.2957 + {
1.2958 + printf("FAIL %d: %s,%s/%lu -> null, not 0x%x+%lu\n", i,
1.2959 + array[i].str ? array[i].str : "(null)",
1.2960 + array[i].sub ? array[i].sub : "(null)",
1.2961 + array[i].max, array[i].str, array[i].off);
1.2962 + return PR_FALSE;
1.2963 + }
1.2964 +
1.2965 + if( &array[i].str[ array[i].off ] != rv )
1.2966 + {
1.2967 + printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i,
1.2968 + array[i].str ? array[i].str : "(null)",
1.2969 + array[i].sub ? array[i].sub : "(null)",
1.2970 + array[i].max, rv, array[i].str, array[i].off);
1.2971 + return PR_FALSE;
1.2972 + }
1.2973 + }
1.2974 + }
1.2975 +
1.2976 + printf("PASS\n");
1.2977 + return PR_TRUE;
1.2978 +}
1.2979 +
1.2980 +/* PL_strtok_r */
1.2981 +PRBool test_031(void)
1.2982 +{
1.2983 + static const char *tokens[] = {
1.2984 + "wtc", "relyea", "nelsonb", "jpierre", "nicolson",
1.2985 + "ian.mcgreer", "kirk.erickson", "sonja.mirtitsch", "mhein"
1.2986 + };
1.2987 +
1.2988 + static const char *seps[] = {
1.2989 + ", ", ",", " ", "\t", ",,,", " ,", " ", " \t\t", ","
1.2990 + };
1.2991 +
1.2992 + static const char s2[] = ", \t";
1.2993 +
1.2994 + char string[ 1024 ];
1.2995 + char *s1;
1.2996 + char *token;
1.2997 + char *lasts;
1.2998 + unsigned int i;
1.2999 +
1.3000 + printf("Test 031 (PL_strtok_r) ..."); fflush(stdout);
1.3001 +
1.3002 + /* Build the string. */
1.3003 + string[0] = '\0';
1.3004 + for( i = 0; i < sizeof(tokens)/sizeof(tokens[0]); i++ )
1.3005 + {
1.3006 + PL_strcat(string, tokens[i]);
1.3007 + PL_strcat(string, seps[i]);
1.3008 + }
1.3009 +
1.3010 + /* Scan the string for tokens. */
1.3011 + i = 0;
1.3012 + s1 = string;
1.3013 + while( (token = PL_strtok_r(s1, s2, &lasts)) != NULL)
1.3014 + {
1.3015 + if( PL_strcmp(token, tokens[i]) != 0 )
1.3016 + {
1.3017 + printf("FAIL wrong token scanned\n");
1.3018 + return PR_FALSE;
1.3019 + }
1.3020 + i++;
1.3021 + s1 = NULL;
1.3022 + }
1.3023 + if( i != sizeof(tokens)/sizeof(tokens[0]) )
1.3024 + {
1.3025 + printf("FAIL wrong number of tokens scanned\n");
1.3026 + return PR_FALSE;
1.3027 + }
1.3028 +
1.3029 + printf("PASS\n");
1.3030 + return PR_TRUE;
1.3031 +}
1.3032 +
1.3033 +int
1.3034 +main
1.3035 +(
1.3036 + int argc,
1.3037 + char *argv[]
1.3038 +)
1.3039 +{
1.3040 + printf("Testing the Portable Library string functions:\n");
1.3041 +
1.3042 + if( 1
1.3043 + && test_001()
1.3044 + && test_001()
1.3045 + && test_002()
1.3046 + && test_003()
1.3047 + && test_004()
1.3048 + && test_005()
1.3049 + && test_006()
1.3050 + && test_007()
1.3051 + && test_008()
1.3052 + && test_009()
1.3053 + && test_010()
1.3054 + && test_011()
1.3055 + && test_012()
1.3056 + && test_013()
1.3057 + && test_014()
1.3058 + && test_015()
1.3059 + && test_016()
1.3060 + && test_017()
1.3061 + && test_018()
1.3062 + && test_019()
1.3063 + && test_020()
1.3064 + && test_021()
1.3065 + && test_022()
1.3066 + && test_023()
1.3067 + && test_024()
1.3068 + && test_025()
1.3069 + && test_026()
1.3070 + && test_027()
1.3071 + && test_028()
1.3072 + && test_029()
1.3073 + && test_030()
1.3074 + && test_031()
1.3075 + )
1.3076 + {
1.3077 + printf("Suite passed.\n");
1.3078 + return 0;
1.3079 + }
1.3080 + else
1.3081 + {
1.3082 + printf("Suite failed.\n");
1.3083 + return 1;
1.3084 + }
1.3085 +
1.3086 + /*NOTREACHED*/
1.3087 +}
