intern/guardedalloc/test/simpletest/memtest.c

   1 /**
   2  * $Id$
   3  * ***** BEGIN GPL LICENSE BLOCK *****
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  *
  19  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  20  * All rights reserved.
  21  *
  22  * The Original Code is: all of this file.
  23  *
  24  * Contributor(s): none yet.
  25  *
  26  * ***** END GPL LICENSE BLOCK *****
  27  */
  28
  29 /**
  30
  31  * $Id$
  32  * Copyright (C) 2001 NaN Technologies B.V.
  33  * Simple test of memory.
  34  */
  35
  36
  37
  38 /* Number of chunks to test with */
  39 #define NUM_BLOCKS 10
  40
  41 #include <stdio.h>
  42 #include <string.h>
  43 #include <stdlib.h>
  44 #include "MEM_guardedalloc.h"
  45
  46 #ifdef HAVE_CONFIG_H
  47 #include <config.h>
  48 #endif
  49
  50 int main (int argc, char *argv[])
  51 {
  52         int verbose       = 0;
  53         int error_status  = 0;
  54         int retval        = 0;
  55         int *ip;
  56
  57         void *p[NUM_BLOCKS];
  58         int i = 0;
  59
  60         /* ----------------------------------------------------------------- */
  61         switch (argc) {
  62         case 2:
  63                 verbose = atoi(argv[1]);
  64                 if (verbose < 0) verbose = 0;
  65                 break;
  66         case 1:
  67         default:
  68                 verbose = 0;
  69         }
  70         if (verbose) {
  71                 fprintf(stderr,"\n*** Simple memory test\n|\n");
  72         }
  73
  74         /* ----------------------------------------------------------------- */
  75         /* Round one, do a normal allocation, and free the blocks again.     */
  76         /* ----------------------------------------------------------------- */
  77         /* flush mem lib output to stderr */
  78         MEM_set_error_callback(stderr);
  79
  80         for (i = 0; i < NUM_BLOCKS; i++) {
  81                 int blocksize = 10000;
  82                 char tagstring[1000];
  83                 if (verbose >1) printf("|--* Allocating block %d\n", i);
  84                 sprintf(tagstring,"Memblock no. %d : ", i);
  85                 p[i]= MEM_callocN(blocksize, strdup(tagstring));
  86         }
  87
  88         /* report on that */
  89         if (verbose > 1) MEM_printmemlist();
  90
  91         /* memory is there: test it */
  92         error_status = MEM_check_memory_integrity();
  93
  94         if (verbose) {
  95                 if (error_status) {
  96                         fprintf(stderr, "|--* Memory test FAILED\n|\n");
  97                 } else {
  98                         fprintf(stderr, "|--* Memory tested as good (as it should be)\n|\n");
  99                 }
 100         }
 101
 102         for (i = 0; i < NUM_BLOCKS; i++) {
 103                 MEM_freeN(p[i]);
 104         }
 105
 106         /* ----------------------------------------------------------------- */
 107         /* Round two, do a normal allocation, and corrupt some blocks.       */
 108         /* ----------------------------------------------------------------- */
 109         /* switch off, because it will complain about some things.           */
 110         MEM_set_error_callback(NULL);
 111
 112         for (i = 0; i < NUM_BLOCKS; i++) {
 113                 int blocksize = 10000;
 114                 char tagstring[1000];
 115                 if (verbose >1) printf("|--* Allocating block %d\n", i);
 116                 sprintf(tagstring,"Memblock no. %d : ", i);
 117                 p[i]= MEM_callocN(blocksize, strdup(tagstring));
 118         }
 119
 120         /* now corrupt a few blocks...*/
 121         ip = (int*) p[5] - 50 ;
 122         for (i = 0; i< 1000; i++,ip++) *ip = i+1;
 123         ip = (int*) p[6];
 124         *(ip+10005) = 0;
 125
 126         retval = MEM_check_memory_integrity();
 127
 128         /* the test should have failed */
 129         error_status |= !retval;
 130         if (verbose) {
 131                 if (retval) {
 132                         fprintf(stderr, "|--* Memory test failed (as it should be)\n");
 133                 } else {
 134                         fprintf(stderr, "|--* Memory test FAILED to find corrupted blocks \n");
 135                 }
 136         }
 137
 138         for (i = 0; i < NUM_BLOCKS; i++) {
 139                 MEM_freeN(p[i]);
 140         }
 141
 142
 143         if (verbose && error_status) {
 144                 fprintf(stderr,"|--* Memory was corrupted\n");
 145         }
 146         /* ----------------------------------------------------------------- */
 147         if (verbose) {
 148                 if (error_status) {
 149                         fprintf(stderr,"|\n|--* Errors were detected\n");
 150                 } else {
 151                         fprintf(stderr,"|\n|--* Test exited succesfully\n");
 152                 }
 153
 154                 fprintf(stderr,"|\n*** Finished test\n\n");
 155         }
 156         return error_status;
 157 }
 158
 159