string.c

Netscape NSPR库源码

        PRBool      ret;
        PRUint32    off;
    } array[] =
      {
          { (const char *)0, 'a', 2, PR_FALSE, 0 },
          { (const char *)0, '\0', 2, PR_FALSE, 0 },
          { "abcdefg", 'a', 5, PR_TRUE, 0 },
          { "abcdefg", 'b', 5, PR_TRUE, 1 },
          { "abcdefg", 'c', 5, PR_TRUE, 2 },
          { "abcdefg", 'd', 5, PR_TRUE, 3 },
          { "abcdefg", 'e', 5, PR_TRUE, 4 },
          { "abcdefg", 'f', 5, PR_FALSE, 0 },
          { "abcdefg", 'g', 5, PR_FALSE, 0 },
          { "abcdefg", 'h', 5, PR_FALSE, 0 },
          { "abcdefg", '\0', 5, PR_FALSE, 0 },
          { "abcdefg", '\0', 15, PR_TRUE, 7 },
          { "abcdefg", 'A', 5, PR_FALSE, 0 },
          { "abcdefg", 'B', 5, PR_FALSE, 0 },
          { "abcdefg", 'C', 5, PR_FALSE, 0 },
          { "abcdefg", 'D', 5, PR_FALSE, 0 },
          { "abcdefg", 'E', 5, PR_FALSE, 0 },
          { "abcdefg", 'F', 5, PR_FALSE, 0 },
          { "abcdefg", 'G', 5, PR_FALSE, 0 },
          { "abcdefg", 'H', 5, PR_FALSE, 0 },
          { "abcdefgabcdefg", 'a', 10, PR_TRUE, 7 },
          { "abcdefgabcdefg", 'b', 10, PR_TRUE, 8 },
          { "abcdefgabcdefg", 'c', 10, PR_TRUE, 9 },
          { "abcdefgabcdefg", 'd', 10, PR_TRUE, 3 },
          { "abcdefgabcdefg", 'e', 10, PR_TRUE, 4 },
          { "abcdefgabcdefg", 'f', 10, PR_TRUE, 5 },
          { "abcdefgabcdefg", 'g', 10, PR_TRUE, 6 },
          { "abcdefgabcdefg", 'h', 10, PR_FALSE, 0 },
          { "abcdefgabcdefg", '\0', 10, PR_FALSE, 0 },
          { "abcdefgabcdefg", '\0', 14, PR_FALSE, 0 },
          { "abcdefgabcdefg", '\0', 15, PR_TRUE, 14 }
      };

    int i;

    printf("Test 018 (PL_strnrchr)    ..."); fflush(stdout);

    for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
    {
        char *rv = PL_strnrchr(array[i].str, array[i].chr, array[i].max);

        if( PR_FALSE == array[i].ret )
        {
            if( (char *)0 != rv )
            {
                printf("FAIL %d: %s,%c/%lu -> %.32s, not zero\n", i, array[i].str,
                       array[i].chr, array[i].max, rv);
                return PR_FALSE;
            }
        }
        else
        {
            if( (char *)0 == rv )
            {
                printf("FAIL %d: %s,%c/%lu -> null, not +%lu\n", i, array[i].str,
                       array[i].chr, array[i].max, array[i].off);
                return PR_FALSE;
            }

            if( &array[i].str[ array[i].off ] != rv )
            {
                printf("FAIL %d: %s,%c/%lu -> 0x%x, not 0x%x+%lu\n", i, array[i].str,
                       array[i].chr, array[i].max, rv, array[i].str, array[i].off);
                return PR_FALSE;
            }
        }
    }

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

/* PL_strpbrk */
PRBool test_019(void)
{
    static struct
    {
        const char *str;
        const char *chrs;
        PRBool      ret;
        PRUint32    off;
    } array[] =
      {
          { (const char *)0, (const char *)0, PR_FALSE, 0 },
          { (const char *)0, "abc", PR_FALSE, 0 },
          { "abc", (const char *)0, PR_FALSE, 0 },
          { "abcdefg", "", PR_FALSE, 0 },
          { "", "aeiou", PR_FALSE, 0 },
          { "abcdefg", "ae", PR_TRUE, 0 },
          { "abcdefg", "ei", PR_TRUE, 4 },
          { "abcdefg", "io", PR_FALSE, 0 },
          { "abcdefg", "bcd", PR_TRUE, 1 },
          { "abcdefg", "cbd", PR_TRUE, 1 },
          { "abcdefg", "dbc", PR_TRUE, 1 },
          { "abcdefg", "ghi", PR_TRUE, 6 },
          { "abcdefg", "AE", PR_FALSE, 0 },
          { "abcdefg", "EI", PR_FALSE, 0 },
          { "abcdefg", "IO", PR_FALSE, 0 },
          { "abcdefg", "BCD", PR_FALSE, 0 },
          { "abcdefg", "CBD", PR_FALSE, 0 },
          { "abcdefg", "DBC", PR_FALSE, 0 },
          { "abcdefg", "GHI", PR_FALSE, 0 },
          { "abcdefgabcdefg", "ae", PR_TRUE, 0 },
          { "abcdefgabcdefg", "ei", PR_TRUE, 4 },
          { "abcdefgabcdefg", "io", PR_FALSE, 0 },
          { "abcdefgabcdefg", "bcd", PR_TRUE, 1 },
          { "abcdefgabcdefg", "cbd", PR_TRUE, 1 },
          { "abcdefgabcdefg", "dbc", PR_TRUE, 1 },
          { "abcdefgabcdefg", "ghi", PR_TRUE, 6 },
          { "abcdefgabcdefg", "AE", PR_FALSE, 0 },
          { "abcdefgabcdefg", "EI", PR_FALSE, 0 },
          { "abcdefgabcdefg", "IO", PR_FALSE, 0 },
          { "abcdefgabcdefg", "BCD", PR_FALSE, 0 },
          { "abcdefgabcdefg", "CBD", PR_FALSE, 0 },
          { "abcdefgabcdefg", "DBC", PR_FALSE, 0 },
          { "abcdefgabcdefg", "GHI", PR_FALSE, 0 }
      };

    int i;

    printf("Test 019 (PL_strpbrk)     ..."); fflush(stdout);

    for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
    {
        char *rv = PL_strpbrk(array[i].str, array[i].chrs);

        if( PR_FALSE == array[i].ret )
        {
            if( (char *)0 != rv )
            {
                printf("FAIL %d: %s,%s -> %.32s, not null\n", i, 
                       array[i].str ? array[i].str : "(null)",
                       array[i].chrs ? array[i].chrs : "(null)", 
                       rv);
                return PR_FALSE;
            }
        }
        else
        {
            if( (char *)0 == rv )
            {
                printf("FAIL %d: %s,%s -> null, not +%lu\n", i,
                       array[i].str ? array[i].str : "(null)",
                       array[i].chrs ? array[i].chrs : "(null)", 
                       array[i].off);
                return PR_FALSE;
            }

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

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

/* PL_strprbrk */
PRBool test_020(void)
{
    static struct
    {
        const char *str;
        const char *chrs;
        PRBool      ret;
        PRUint32    off;
    } array[] =
      {
          { (const char *)0, (const char *)0, PR_FALSE, 0 },
          { (const char *)0, "abc", PR_FALSE, 0 },
          { "abc", (const char *)0, PR_FALSE, 0 },
          { "abcdefg", "", PR_FALSE, 0 },
          { "", "aeiou", PR_FALSE, 0 },
          { "abcdefg", "ae", PR_TRUE, 4 },
          { "abcdefg", "ei", PR_TRUE, 4 },
          { "abcdefg", "io", PR_FALSE, 0 },
          { "abcdefg", "bcd", PR_TRUE, 3 },
          { "abcdefg", "cbd", PR_TRUE, 3 },
          { "abcdefg", "dbc", PR_TRUE, 3 },
          { "abcdefg", "ghi", PR_TRUE, 6 },
          { "abcdefg", "AE", PR_FALSE, 0 },
          { "abcdefg", "EI", PR_FALSE, 0 },
          { "abcdefg", "IO", PR_FALSE, 0 },
          { "abcdefg", "BCD", PR_FALSE, 0 },
          { "abcdefg", "CBD", PR_FALSE, 0 },
          { "abcdefg", "DBC", PR_FALSE, 0 },
          { "abcdefg", "GHI", PR_FALSE, 0 },
          { "abcdefgabcdefg", "ae", PR_TRUE, 11 },
          { "abcdefgabcdefg", "ei", PR_TRUE, 11 },
          { "abcdefgabcdefg", "io", PR_FALSE, 0 },
          { "abcdefgabcdefg", "bcd", PR_TRUE, 10 },
          { "abcdefgabcdefg", "cbd", PR_TRUE, 10 },
          { "abcdefgabcdefg", "dbc", PR_TRUE, 10 },
          { "abcdefgabcdefg", "ghi", PR_TRUE, 13 },
          { "abcdefgabcdefg", "AE", PR_FALSE, 0 },
          { "abcdefgabcdefg", "EI", PR_FALSE, 0 },
          { "abcdefgabcdefg", "IO", PR_FALSE, 0 },
          { "abcdefgabcdefg", "BCD", PR_FALSE, 0 },
          { "abcdefgabcdefg", "CBD", PR_FALSE, 0 },
          { "abcdefgabcdefg", "DBC", PR_FALSE, 0 },
          { "abcdefgabcdefg", "GHI", PR_FALSE, 0 }
      };

    int i;

    printf("Test 020 (PL_strprbrk)    ..."); fflush(stdout);

    for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
    {
        char *rv = PL_strprbrk(array[i].str, array[i].chrs);

        if( PR_FALSE == array[i].ret )
        {
            if( (char *)0 != rv )
            {
                printf("FAIL %d: %s,%s -> %.32s, not null\n", i, 
                       array[i].str ? array[i].str : "(null)",
                       array[i].chrs ? array[i].chrs : "(null)", 
                       rv);
                return PR_FALSE;
            }
        }
        else
        {
            if( (char *)0 == rv )
            {
                printf("FAIL %d: %s,%s -> null, not +%lu\n", i,
                       array[i].str ? array[i].str : "(null)",
                       array[i].chrs ? array[i].chrs : "(null)", 
                       array[i].off);
                return PR_FALSE;
            }

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

    printf("PASS\n");
    return PR_TRUE;
}
                       
/* PL_strnpbrk */
PRBool test_021(void)
{
    static struct
    {
        const char *str;
        const char *chrs;
        PRUint32    max;
        PRBool      ret;
        PRUint32    off;
    } array[] =
      {
          { (const char *)0, (const char *)0, 3, PR_FALSE, 0 },
          { (const char *)0, "abc", 3, PR_FALSE, 0 },
          { "abc", (const char *)0, 3, PR_FALSE, 0 },
          { "abcdefg", "", 3, PR_FALSE, 0 },
          { "", "aeiou", 3, PR_FALSE, 0 },
          { "abcdefg", "ae", 0, PR_FALSE, 0 },
          { "abcdefg", "ae", 1, PR_TRUE, 0 },
          { "abcdefg", "ae", 4, PR_TRUE, 0 },
          { "abcdefg", "ae", 5, PR_TRUE, 0 },
          { "abcdefg", "ae", 6, PR_TRUE, 0 },
          { "abcdefg", "ei", 4, PR_FALSE, 0 },
          { "abcdefg", "io", 10, PR_FALSE, 0 },
          { "abcdefg", "bcd", 2, PR_TRUE, 1 },
          { "abcdefg", "cbd", 2, PR_TRUE, 1 },
          { "abcdefg", "dbc", 2, PR_TRUE, 1 },
          { "abcdefg", "ghi", 6, PR_FALSE, 0 },
          { "abcdefg", "ghi", 7, PR_TRUE, 6 },
          { "abcdefg", "AE", 9, PR_FALSE, 0 },
          { "abcdefg", "EI", 9, PR_FALSE, 0 },
          { "abcdefg", "IO", 9, PR_FALSE, 0 },
          { "abcdefg", "BCD", 9, PR_FALSE, 0 },
          { "abcdefg", "CBD", 9, PR_FALSE, 0 },
          { "abcdefg", "DBC", 9, PR_FALSE, 0 },
          { "abcdefg", "GHI", 9, PR_FALSE, 0 },
          { "abcdefgabcdefg", "ae", 10, PR_TRUE, 0 },
          { "abcdefgabcdefg", "ei", 10, PR_TRUE, 4 },
          { "abcdefgabcdefg", "io", 10, PR_FALSE, 0 },
          { "abcdefgabcdefg", "bcd", 10, PR_TRUE, 1 },
          { "abcdefgabcdefg", "cbd", 10, PR_TRUE, 1 },
          { "abcdefgabcdefg", "dbc", 10, PR_TRUE, 1 },
          { "abcdefgabcdefg", "ghi", 10, PR_TRUE, 6 },
          { "abcdefgabcdefg", "AE", 10, PR_FALSE, 0 },
          { "abcdefgabcdefg", "EI", 10, PR_FALSE, 0 },
          { "abcdefgabcdefg", "IO", 10, PR_FALSE, 0 },
          { "abcdefgabcdefg", "BCD", 10, PR_FALSE, 0 },
          { "abcdefgabcdefg", "CBD", 10, PR_FALSE, 0 },
          { "abcdefgabcdefg", "DBC", 10, PR_FALSE, 0 },
          { "abcdefgabcdefg", "GHI", 10, PR_FALSE, 0 }
      };

    int i;

    printf("Test 021 (PL_strnpbrk)    ..."); fflush(stdout);

    for( i = 0; i < sizeof(array)/sizeof(array[0]); i++ )
    {
        char *rv = PL_strnpbrk(array[i].str, array[i].chrs, array[i].max);

        if( PR_FALSE == array[i].ret )
        {
            if( (char *)0 != rv )
            {
                printf("FAIL %d: %s,%s/%lu -> %.32s, not null\n", i, 
                       array[i].str ? array[i].str : "(null)",
                       array[i].chrs ? array[i].chrs : "(null)", 
                       array[i].max, rv);
                return PR_FALSE;
            }
        }
        else
        {
            if( (char *)0 == rv )
            {
                printf("FAIL %d: %s,%s/%lu -> null, not +%lu\n", i,
                       array[i].str ? array[i].str : "(null)",
                       array[i].chrs ? array[i].chrs : "(null)", 
                       array[i].max, array[i].off);
                return PR_FALSE;
            }

            if( &array[i].str[ array[i].off ] != rv )
            {
                printf("FAIL %d: %s,%s/%lu -> 0x%x, not 0x%x+%lu\n", i,
                       array[i].str ? array[i].str : "(null)",
                       array[i].chrs ? array[i].chrs : "(null)", 
                       array[i].max, rv, array[i].str, array[i].off);
                return PR_FALSE;
            }
        }
    }

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

/* PL_strnprbrk */
PRBool test_022(void)
{
    static struct
    {
        const char *str;
        const char *chrs;
        PRUint32    max;
        PRBool      ret;
        PRUint32    off;
    } array[] =
      {
          { (const char *)0, (const char *)0, 3, PR_FALSE, 0 },
          { (const char *)0, "abc", 3, PR_FALSE, 0 },
          { "abc", (const char *)0, 3, PR_FALSE, 0 },
          { "abcdefg", "", 3, PR_FALSE, 0 },
          { "", "aeiou", 3, PR_FALSE, 0 },
          { "abcdefg", "ae", 0, PR_FALSE, 0 },
          { "abcdefg", "ae", 1, PR_TRUE, 0 },
          { "abcdefg", "ae", 4, PR_TRUE, 0 },
          { "abcdefg", "ae", 5, PR_TRUE, 4 },
          { "abcdefg", "ae", 6, PR_TRUE,  4 },
          { "abcdefg", "ei", 4, PR_FALSE, 0 },
          { "abcdefg", "io", 10, PR_FALSE, 0 },
          { "abcdefg", "bcd", 2, PR_TRUE, 1 },
          { "abcdefg", "cbd", 2, PR_TRUE, 1 },
          { "abcdefg", "dbc", 2, PR_TRUE, 1 },
          { "abcdefg", "bcd", 3, PR_TRUE, 2 },
          { "abcdefg", "cbd", 3, PR_TRUE, 2 },
          { "abcdefg", "dbc", 3, PR_TRUE, 2 },
          { "abcdefg", "bcd", 5, PR_TRUE, 3 },
          { "abcdefg", "cbd", 5, PR_TRUE, 3 },
          { "abcdefg", "dbc", 5, PR_TRUE, 3 },
          { "abcdefg", "bcd", 15, PR_TRUE, 3 },
          { "abcdefg", "cbd", 15, PR_TRUE, 3 },
          { "abcdefg", "dbc", 15, PR_TRUE, 3 },
          { "abcdefg", "ghi", 6, PR_FALSE, 0 },
          { "abcdefg", "ghi", 7, PR_TRUE, 6 },
          { "abcdefg", "AE