The Tor Browser: comparison nsprpub/pr/tests/dbmalloc.c

--1:000000000000
+:890d0713870b
+/* -*- 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;
+}

The Tor Browser / file comparison

comparison: nsprpub/pr/tests/dbmalloc.c

nsprpub/pr/tests/dbmalloc.c