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