gecko-dev/nsprpub/pr/tests/dbmalloc.c

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/***********************************************************************
**
** Name: dbmalloc.c
**
** Description: Testing malloc (OBSOLETE)
**
** Modification History:
** 14-May-97 AGarcia- Converted the test to accomodate the debug_mode flag.
**	         The debug mode will print all of the printfs associated with this test.
**			 The regress mode will be the default mode. Since the regress tool limits
**           the output to a one line status:PASS or FAIL,all of the printf statements
**			 have been handled with an if (debug_mode) statement. 
***********************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include "nspr.h"

void
usage
(
    void
)
{
    fprintf(stderr, "Usage: dbmalloc ('-m'|'-s') '-f' num_fails ('-d'|'-n') filename [...]\n");
    exit(0);
}

typedef struct node_struct
{
    struct node_struct *next, *prev;
    int line;
    char value[4];
}
    node_t,
   *node_pt;

node_pt get_node(const char *line)
{
    node_pt rv;
    int l = strlen(line);
    rv = (node_pt)PR_MALLOC(sizeof(node_t) + l + 1 - 4);
    if( (node_pt)0 == rv ) return (node_pt)0;
    memcpy(&rv->value[0], line, l+1);
    rv->next = rv->prev = (node_pt)0;
    return rv;
}

void
dump
(
    const char *name,
    node_pt     node,
    int         mf,
    int         debug
)
{
    if( (node_pt)0 != node->prev ) dump(name, node->prev, mf, debug);
    if( 0 != debug ) printf("[%s]: %6d: %s", name, node->line, node->value);
    if( node->line == mf ) fprintf(stderr, "[%s]: Line %d was allocated!\n", name, node->line);
    if( (node_pt)0 != node->next ) dump(name, node->next, mf, debug);
    return;
}

void
release
(
    node_pt node
)
{
    if( (node_pt)0 != node->prev ) release(node->prev);
    if( (node_pt)0 != node->next ) release(node->next);
    PR_DELETE(node);
}

int
t2
(
    const char *name,
    int         mf,
    int         debug
)
{
    int rv;
    FILE *fp;
    int l = 0;
    node_pt head = (node_pt)0;
    char buffer[ BUFSIZ ];

    fp = fopen(name, "r");
    if( (FILE *)0 == fp )
    {
        fprintf(stderr, "[%s]: Cannot open \"%s.\"\n", name, name);
        return -1;
    }

    /* fgets mallocs a buffer, first time through. */
    if( (char *)0 == fgets(buffer, BUFSIZ, fp) )
    {
        fprintf(stderr, "[%s]: \"%s\" is empty.\n", name, name);
        (void)fclose(fp);
        return -1;
    }

    rewind(fp);

    if( PR_SUCCESS != PR_ClearMallocCount() )
    {
        fprintf(stderr, "[%s]: Cannot clear malloc count.\n", name);
        (void)fclose(fp);
        return -1;
    }

    if( PR_SUCCESS != PR_SetMallocCountdown(mf) )
    {
        fprintf(stderr, "[%s]: Cannot set malloc countdown to %d\n", name, mf);
        (void)fclose(fp);
        return -1;
    }

    while( fgets(buffer, BUFSIZ, fp) )
    {
        node_pt n;
        node_pt *w = &head;

        if( (strlen(buffer) == (BUFSIZ-1)) && (buffer[BUFSIZ-2] != '\n') )
            buffer[BUFSIZ-2] == '\n';

        l++;

        n = get_node(buffer);
        if( (node_pt)0 == n ) 
        {
            printf("[%s]: Line %d: malloc failure!\n", name, l);
            continue;
        }

        n->line = l;

        while( 1 )
        {
            int comp;

            if( (node_pt)0 == *w )
            {
                *w = n;
                break;
            }

            comp = strcmp((*w)->value, n->value);
            if( comp < 0 ) w = &(*w)->next;
            else w = &(*w)->prev;
        }
    }

    (void)fclose(fp);

    dump(name, head, mf, debug);

    rv = PR_GetMallocCount();
    PR_ClearMallocCountdown();

    release(head);

    return rv;
}

int nf = 0;
int debug = 0;

void
test
(
    const char *name
)
{
    int n, i;

    extern int nf, debug;

    printf("[%s]: starting test 0\n", name);
    n = t2(name, 0, debug);
    if( -1 == n ) return;
    printf("[%s]: test 0 had %ld allocations.\n", name, n);

    if( 0 >= n ) return;

    for( i = 0; i < nf; i++ )
    {
        int which = rand() % n;
        if( 0 == which ) printf("[%s]: starting test %d -- no allocation should fail\n", name, i+1);
        else printf("[%s]: starting test %d -- allocation %d should fail\n", name, i+1, which);
        (void)t2(name, which, debug);
        printf("[%s]: test %d done.\n", name, i+1);
    }

    return;
}

int main(int argc, char **argv)
{
    int okay = 0;
    int multithread = 0;

    struct threadlist
    {
        struct threadlist *next;
        PRThread *thread;
    }
        *threadhead = (struct threadlist *)0;

    extern int nf, debug;

    srand(time(0));

    PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
    PR_STDIO_INIT();

    printf("[main]: We %s using the debugging malloc.\n",
           PR_IsDebuggingMalloc() ? "ARE" : "ARE NOT");

    while( argv++, --argc )
    {
        if( '-' == argv[0][0] )
        {
            switch( argv[0][1] )
            {
                case 'f':
                    nf = atoi(argv[0][2] ? &argv[0][2] :
                              --argc ? *++argv : "0");
                    break;
                case 'd':
                    debug = 1;
                    break;
                case 'n':
                    debug = 0;
                    break;
                case 'm':
                    multithread = 1;
                    break;
                case 's':
                    multithread = 0;
                    break;
                default:
                    usage();
                    break;
            }
        }
        else
        {
            FILE *fp = fopen(*argv, "r");
            if( (FILE *)0 == fp )
            {
                fprintf(stderr, "Cannot open \"%s.\"\n", *argv);
                continue;
            }

            okay++;
            (void)fclose(fp);
            if( multithread )
            {
                struct threadlist *n;

                n = (struct threadlist *)malloc(sizeof(struct threadlist));
                if( (struct threadlist *)0 == n ) 
                {
                    fprintf(stderr, "This is getting tedious. \"%s\"\n", *argv);
                    continue;
                }

                n->next = threadhead;
                n->thread = PR_CreateThread(PR_USER_THREAD, (void (*)(void *))test, 
                                            *argv, PR_PRIORITY_NORMAL, 
                                            PR_LOCAL_THREAD, PR_JOINABLE_THREAD,
                                            0);
                if( (PRThread *)0 == n->thread )
                {
                    fprintf(stderr, "Can't create thread for \"%s.\"\n", *argv);
                    continue;
                }
                else
                {
                    threadhead = n;
                }
            }
            else
            {
                test(*argv);
            }
        }
    }

    if( okay == 0 ) usage();
    else while( (struct threadlist *)0 != threadhead )
    {
        struct threadlist *x = threadhead->next;
        (void)PR_JoinThread(threadhead->thread);
        PR_DELETE(threadhead);
        threadhead = x;
    }

    return 0;
}