blender/intern/guardedalloc/test/simpletest/memtest.c
Campbell Barton a6b505ef0b style cleanup
2013-06-06 06:02:46 +00:00

163 lines
4.0 KiB
C

/**
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): none yet.
*
* ***** END GPL LICENSE BLOCK *****
*/
/**
* Copyright (C) 2001 NaN Technologies B.V.
* Simple test of memory.
*/
/* Number of chunks to test with */
#define NUM_BLOCKS 10
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "MEM_guardedalloc.h"
static void mem_error_cb(const char *errorStr)
{
fprintf(stderr, "%s", errorStr);
fflush(stderr);
}
int main(int argc, char *argv[])
{
int verbose = 0;
int error_status = 0;
int retval = 0;
int *ip;
void *p[NUM_BLOCKS];
int i = 0;
/* ----------------------------------------------------------------- */
switch (argc) {
case 2:
verbose = atoi(argv[1]);
if (verbose < 0) verbose = 0;
break;
case 1:
default:
verbose = 0;
}
if (verbose) {
fprintf(stderr,"\n*** Simple memory test\n|\n");
}
/* ----------------------------------------------------------------- */
/* Round one, do a normal allocation, and free the blocks again. */
/* ----------------------------------------------------------------- */
/* flush mem lib output to stderr */
MEM_set_error_callback(mem_error_cb);
for (i = 0; i < NUM_BLOCKS; i++) {
int blocksize = 10000;
char tagstring[1000];
if (verbose > 1) printf("|--* Allocating block %d\n", i);
sprintf(tagstring,"Memblock no. %d : ", i);
p[i]= MEM_callocN(blocksize, strdup(tagstring));
}
/* report on that */
if (verbose > 1) MEM_printmemlist();
/* memory is there: test it */
error_status = MEM_check_memory_integrity();
if (verbose) {
if (error_status) {
fprintf(stderr, "|--* Memory test FAILED\n|\n");
}
else {
fprintf(stderr, "|--* Memory tested as good (as it should be)\n|\n");
}
}
for (i = 0; i < NUM_BLOCKS; i++) {
MEM_freeN(p[i]);
}
/* ----------------------------------------------------------------- */
/* Round two, do a normal allocation, and corrupt some blocks. */
/* ----------------------------------------------------------------- */
/* switch off, because it will complain about some things. */
MEM_set_error_callback(NULL);
for (i = 0; i < NUM_BLOCKS; i++) {
int blocksize = 10000;
char tagstring[1000];
if (verbose > 1) printf("|--* Allocating block %d\n", i);
sprintf(tagstring,"Memblock no. %d : ", i);
p[i]= MEM_callocN(blocksize, strdup(tagstring));
}
/* now corrupt a few blocks...*/
ip = (int*) p[5] - 50;
for (i = 0; i< 1000; i++,ip++) *ip = i+1;
ip = (int*) p[6];
*(ip+10005) = 0;
retval = MEM_check_memory_integrity();
/* the test should have failed */
error_status |= !retval;
if (verbose) {
if (retval) {
fprintf(stderr, "|--* Memory test failed (as it should be)\n");
}
else {
fprintf(stderr, "|--* Memory test FAILED to find corrupted blocks \n");
}
}
for (i = 0; i < NUM_BLOCKS; i++) {
MEM_freeN(p[i]);
}
if (verbose && error_status) {
fprintf(stderr,"|--* Memory was corrupted\n");
}
/* ----------------------------------------------------------------- */
if (verbose) {
if (error_status) {
fprintf(stderr,"|\n|--* Errors were detected\n");
}
else {
fprintf(stderr,"|\n|--* Test exited succesfully\n");
}
fprintf(stderr,"|\n*** Finished test\n\n");
}
return error_status;
}