Memory allocator: Clarify consistency check function
[blender-staging.git] / intern / guardedalloc / test / simpletest / memtest.c
index 7c5a8230ea74b14dd0c3cd1b878ad709f5092511..d306337d0abd568ba1e3e09ba3082607b7391455 100644 (file)
@@ -1,14 +1,10 @@
 /**
- * $Id$
- * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ * ***** 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. The Blender
- * Foundation also sells licenses for use in proprietary software under
- * the Blender License.  See http://www.blender.org/BL/ for information
- * about this.
+ * 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
@@ -17,7 +13,7 @@
  *
  * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * 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.
  *
  * Contributor(s): none yet.
  *
- * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ * ***** END GPL LICENSE BLOCK *****
  */
 
 /**
-
- * $Id$
  * Copyright (C) 2001 NaN Technologies B.V.
  * Simple test of memory.
  */
 
-
+/* To compile run:
+ * gcc -DWITH_GUARDEDALLOC -I../../ -I../../../atomic/ memtest.c  ../../intern/mallocn.c -o simpletest
+ */
 
 /* Number of chunks to test with */
 #define NUM_BLOCKS 10
 #include <stdlib.h>
 #include "MEM_guardedalloc.h"
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
+static void mem_error_cb(const char *errorStr)
+{
+       fprintf(stderr, "%s", errorStr);
+       fflush(stderr);
+}
 
-int main (int argc, char *argv[])
+int main(int argc, char *argv[])
 {
        int verbose       = 0;
        int error_status  = 0;
@@ -61,7 +59,7 @@ int main (int argc, char *argv[])
        int i = 0;
 
        /* ----------------------------------------------------------------- */
-       switch (argc) {
+       switch (argc) {
        case 2:         
                verbose = atoi(argv[1]);
                if (verbose < 0) verbose = 0;
@@ -78,12 +76,12 @@ int main (int argc, char *argv[])
        /* Round one, do a normal allocation, and free the blocks again.     */
        /* ----------------------------------------------------------------- */
        /* flush mem lib output to stderr */
-       MEM_set_error_stream(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);
+               if (verbose > 1) printf("|--* Allocating block %d\n", i);
                sprintf(tagstring,"Memblock no. %d : ", i);
                p[i]= MEM_callocN(blocksize, strdup(tagstring));
        }
@@ -92,12 +90,13 @@ int main (int argc, char *argv[])
        if (verbose > 1) MEM_printmemlist();
 
        /* memory is there: test it */
-       error_status = MEM_check_memory_integrity();
+       error_status = MEM_consistency_check();
 
        if (verbose) {
                if (error_status) {
                        fprintf(stderr, "|--* Memory test FAILED\n|\n");
-               } else {
+               }
+               else {
                        fprintf(stderr, "|--* Memory tested as good (as it should be)\n|\n");
                }
        } 
@@ -110,30 +109,31 @@ int main (int argc, char *argv[])
        /* Round two, do a normal allocation, and corrupt some blocks.       */
        /* ----------------------------------------------------------------- */
        /* switch off, because it will complain about some things.           */
-       MEM_set_error_stream(NULL);
+       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);
+               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 ;
+       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();
+       retval = MEM_consistency_check();
 
        /* the test should have failed */
        error_status |= !retval;                
        if (verbose) {
                if (retval) {
                        fprintf(stderr, "|--* Memory test failed (as it should be)\n");
-               } else {
+               }
+               else {
                        fprintf(stderr, "|--* Memory test FAILED to find corrupted blocks \n");
                }
        } 
@@ -150,7 +150,8 @@ int main (int argc, char *argv[])
        if (verbose) {
                if (error_status) {
                        fprintf(stderr,"|\n|--* Errors were detected\n");
-               } else {
+               }
+               else {
                        fprintf(stderr,"|\n|--* Test exited succesfully\n");
                }