string.c

Netscape NSPR库源码

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 * 
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 * 
 * The Original Code is the Netscape Portable Runtime (NSPR).
 * 
 * The Initial Developer of the Original Code is Netscape
 * Communications Corporation.  Portions created by Netscape are 
 * Copyright (C) 1998-2000 Netscape Communications Corporation.  All
 * Rights Reserved.
 * 
 * Contributor(s):
 * 
 * Alternatively, the contents of this file may be used under the
 * terms of the GNU General Public License Version 2 or later (the
 * "GPL"), in which case the provisions of the GPL are applicable 
 * instead of those above.  If you wish to allow use of your 
 * version of this file only under the terms of the GPL and not to
 * allow others to use your version of this file under the MPL,
 * indicate your decision by deleting the provisions above and
 * replace them with the notice and other provisions required by
 * the GPL.  If you do not delete the provisions above, a recipient
 * may use your version of this file under either the MPL or the
 * GPL.
 */

#include "plstr.h"
#include "nspr.h"

#include <stdio.h>

/* PL_strlen */
PRBool test_001(void)
{
    static struct
    {
        const char *str;
        PRUint32    len;
    } array[] =
      {
          { (const char *)0, 0 },
          { "", 0 },
          { "a", 1 },
          { "abcdefg", 7 },
          { "abcdefg\0hijk", 7 }
      };

    int i;

    printf("Test 001 (PL_strlen)      ..."); fflush(stdout);

    for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
    {
        if( PL_strlen(array[i].str) != array[i].len )
        {
            printf("FAIL (%d: %s->%d, %d)\n", i, 
                   array[i].str ? array[i].str : "(null)",
                   PL_strlen(array[i].str), array[i].len);
            return PR_FALSE;
        }
    }

    printf("PASS\n");
    return PR_TRUE;
}

/* PL_strnlen */
PRBool test_002(void)
{
    static struct
    {
        const char *str;
        PRUint32    max;
        PRUint32    len;
    } array[] =
      {
          { (const char *)0, 0, 0 },
          { (const char *)0, 12, 0 },
          { "", 0, 0 },
          { "", 12, 0 },
          { "a", 0, 0 },
          { "a", 1, 1 },
          { "a", 12, 1 },
          { "abcdefg", 0, 0 },
          { "abcdefg", 1, 1 },
          { "abcdefg", 7, 7 },
          { "abcdefg", 12, 7 },
          { "abcdefg\0hijk", 0, 0 },
          { "abcdefg\0hijk", 1, 1 },
          { "abcdefg\0hijk", 7, 7 },
          { "abcdefg\0hijk", 12, 7 },
      };

    int i;

    printf("Test 002 (PL_strnlen)     ..."); fflush(stdout);

    for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
    {
        if( PL_strnlen(array[i].str, array[i].max) != array[i].len )
        {
            printf("FAIL (%d: %s,%d->%d, %d)\n", i,
                   array[i].str ? array[i].str : "(null)", array[i].max,
                   PL_strnlen(array[i].str, array[i].max), array[i].len);
            return PR_FALSE;
        }
    }

    printf("PASS\n");
    return PR_TRUE;
}

/* PL_strcpy */
PRBool test_003(void)
{
    static char buffer[ 1024 ];

    static struct
    {
        const char *str;
        char       *dest;
        char       *rv;
        PRBool      comp;
    } array[] =
      {
          { (const char *)0, (char *)0, (char *)0, PR_FALSE },
          { (const char *)0, buffer, (char *)0, PR_FALSE },
          { "", (char *)0, (char *)0, PR_FALSE },
          { "", buffer, buffer, PR_TRUE },
          { "a", (char *)0, (char *)0, PR_FALSE },
          { "a", buffer, buffer, PR_TRUE },
          { "abcdefg", (char *)0, (char *)0, PR_FALSE },
          { "abcdefg", buffer, buffer, PR_TRUE },
          { "wxyz\0abcdefg", (char *)0, (char *)0, PR_FALSE },
          { "wxyz\0abcdefg", buffer, buffer, PR_TRUE }
      };

    int i;

    printf("Test 003 (PL_strcpy)      ..."); fflush(stdout);

    for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
    {
        char *rv;
        const char *a = array[i].str;
        const char *b = (const char *)array[i].dest;

        rv = PL_strcpy(array[i].dest, array[i].str);
        if( array[i].rv != rv )
        {
            printf("FAIL %d: (0x%x, %s)->0x%x\n", i, array[i].dest,
                   array[i].str ? array[i].str : "(null)", rv);
            return PR_FALSE;
        }

        if( array[i].comp )
        {
            while( 1 )
            {
                if( *a != *b )
                {
                    printf("FAIL %d: %s->%.32s\n", i, 
                           array[i].str ? array[i].str : "(null)", 
                           array[i].dest ? array[i].dest : "(null)");
                    return PR_FALSE;
                }

                if( (char)0 == *a ) break;

                a++;
                b++;
            }
        }
    }

    printf("PASS\n");
    return PR_TRUE;
}

/* PL_strncpy */
PRBool test_004(void)
{
    static char buffer[ 1024 ];

    static struct
    {
        const char *str;
        PRUint32    len;
        char       *dest;
        char       *rv;
        PRBool      comp;
        const char *result;
        PRBool      nulled;
    } array[] =
      {
          { (const char *)0, 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { (const char *)0, 0, buffer, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { (const char *)0, 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { (const char *)0, 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { (const char *)0, 1, buffer, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { (const char *)0, 7, buffer, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
          { "", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "", 1, buffer, buffer, PR_TRUE, "", PR_TRUE },
          { "", 7, buffer, buffer, PR_TRUE, "", PR_TRUE },
          { "a", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "a", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
          { "a", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "a", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "b", 1, buffer, buffer, PR_TRUE, "b", PR_FALSE },
          { "c", 7, buffer, buffer, PR_TRUE, "c", PR_TRUE },
          { "de", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "de", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
          { "de", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "de", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "fg", 1, buffer, buffer, PR_TRUE, "f", PR_FALSE },
          { "hi", 7, buffer, buffer, PR_TRUE, "hi", PR_TRUE },
          { "jklmnopq", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "jklmnopq", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
          { "jklmnopq", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "jklmnopq", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "rstuvwxy", 1, buffer, buffer, PR_TRUE, "r", PR_FALSE },
          { "zABCDEFG", 7, buffer, buffer, PR_TRUE, "zABCDEF", PR_FALSE },
          { "a\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "a\0XXX", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
          { "a\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "a\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "b\0XXX", 1, buffer, buffer, PR_TRUE, "b", PR_FALSE },
          { "c\0XXX", 7, buffer, buffer, PR_TRUE, "c", PR_TRUE },
          { "de\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "de\0XXX", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
          { "de\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "de\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "fg\0XXX", 1, buffer, buffer, PR_TRUE, "f", PR_FALSE },
          { "hi\0XXX", 7, buffer, buffer, PR_TRUE, "hi", PR_TRUE },
          { "jklmnopq\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "jklmnopq\0XXX", 0, buffer, buffer, PR_FALSE, (const char *)0, PR_FALSE },
          { "jklmnopq\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "jklmnopq\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0, PR_FALSE },
          { "rstuvwxy\0XXX", 1, buffer, buffer, PR_TRUE, "r", PR_FALSE },
          { "zABCDEFG\0XXX", 7, buffer, buffer, PR_TRUE, "zABCDEF", PR_FALSE },
      };

    int i;

    printf("Test 004 (PL_strncpy)     ..."); fflush(stdout);

    for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
    {
        char *rv;
        int j;

        for( j = 0; j < sizeof(buffer); j++ )
            buffer[j] = '-';

        rv = PL_strncpy(array[i].dest, array[i].str, array[i].len);
        if( array[i].rv != rv )
        {
            printf("FAIL %d: (0x%x, %s, %lu)->0x%x\n", i, array[i].dest,
                   array[i].str ? array[i].str : "(null)", array[i].len, rv);
            return PR_FALSE;
        }

        if( array[i].comp )
        {
            const char *a = array[i].result;
            const char *b = array[i].dest;

            while( *a )
            {
                if( *a != *b )
                {
                    printf("FAIL %d: %s != %.32s\n", i, 
                           array[i].result, array[i].dest);
                    return PR_FALSE;
                }

                a++;
                b++;
            }

            if( array[i].nulled )
            {
                if( *b != '\0' )
                {
                    printf("FAIL %d: not terminated\n", i);
                    return PR_FALSE;
                }
            }
            else
            {
                if( *b != '-' )
                {
                    printf("FAIL %d: overstepped\n", i);
                    return PR_FALSE;
                }
            }
        }
    }
                
    printf("PASS\n");
    return PR_TRUE;
}

/* PL_strncpyz */
PRBool test_005(void)
{
    static char buffer[ 1024 ];

    static struct
    {
        const char *str;
        PRUint32    len;
        char       *dest;
        char       *rv;
        PRBool      comp;
        const char *result;
    } array[] =
      {
          { (const char *)0, 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { (const char *)0, 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
          { (const char *)0, 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { (const char *)0, 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { (const char *)0, 1, buffer, (char *)0, PR_FALSE, (const char *)0 },
          { (const char *)0, 7, buffer, (char *)0, PR_FALSE, (const char *)0 },
          { "", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
          { "", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "", 1, buffer, buffer, PR_TRUE, "" },
          { "", 7, buffer, buffer, PR_TRUE, "" },
          { "a", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "a", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
          { "a", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "a", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "b", 1, buffer, buffer, PR_TRUE, "" },
          { "c", 7, buffer, buffer, PR_TRUE, "c" },
          { "de", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "de", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
          { "de", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "de", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "fg", 1, buffer, buffer, PR_TRUE, "" },
          { "hi", 7, buffer, buffer, PR_TRUE, "hi" },
          { "jklmnopq", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "jklmnopq", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
          { "jklmnopq", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "jklmnopq", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "rstuvwxy", 1, buffer, buffer, PR_TRUE, "" },
          { "zABCDEFG", 7, buffer, buffer, PR_TRUE, "zABCDE" },
          { "a\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "a\0XXX", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
          { "a\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "a\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "b\0XXX", 1, buffer, buffer, PR_TRUE, "" },
          { "c\0XXX", 7, buffer, buffer, PR_TRUE, "c" },
          { "de\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "de\0XXX", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
          { "de\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "de\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "fg\0XXX", 1, buffer, buffer, PR_TRUE, "" },
          { "hi\0XXX", 7, buffer, buffer, PR_TRUE, "hi" },
          { "jklmnopq\0XXX", 0, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "jklmnopq\0XXX", 0, buffer, (char *)0, PR_FALSE, (const char *)0 },
          { "jklmnopq\0XXX", 1, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "jklmnopq\0XXX", 7, (char *)0, (char *)0, PR_FALSE, (const char *)0 },
          { "rstuvwxy\0XXX", 1, buffer, buffer, PR_TRUE, "" },
          { "zABCDEFG\0XXX", 7, buffer, buffer, PR_TRUE, "zABCDE" },
      };

    int i;

    printf("Test 005 (PL_strncpyz)    ..."); fflush(stdout);

    for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
    {
        char *rv;
        int j;

        for( j = 0; j < sizeof(buffer); j++ )
            buffer[j] = '-';

        rv = PL_strncpyz(array[i].dest, array[i].str, array[i].len);
        if( array[i].rv != rv )
        {
            printf("FAIL %d: (0x%x, %s, %lu)->0x%x\n", i, array[i].dest,
                   array[i].str ? array[i].str : "(null)", array[i].len, rv);
            return PR_FALSE;