code_c/Maasha/src/test/test_mem.c

   1 #include "common.h"
   2 #include "mem.h"
   3
   4 static void test_mem_get();
   5 static void test_mem_get_zero();
   6 static void test_mem_resize();
   7 static void test_mem_resize_zero();
   8 static void test_mem_clone();
   9 static void test_mem_free();
  10
  11
  12 int main()
  13 {
  14     fprintf( stderr, "Running all tests for mem.c\n" );
  15
  16     test_mem_get();
  17     test_mem_get_zero();
  18     test_mem_resize();
  19     test_mem_resize_zero();
  20     test_mem_clone();
  21     test_mem_free();
  22
  23     fprintf( stderr, "Done\n\n" );
  24
  25     return EXIT_SUCCESS;
  26 }
  27
  28
  29 void test_mem_get()
  30 {
  31     fprintf( stderr, "   Testing mem_get ... " );
  32
  33     size_t  len = 1000000000;
  34     char   *pt  = mem_get( len );
  35
  36     mem_free( ( void * ) &pt );
  37
  38     fprintf( stderr, "OK\n" );
  39 }
  40
  41
  42 void test_mem_get_zero()
  43 {
  44     fprintf( stderr, "   Testing mem_get_zero ... " );
  45
  46     size_t  i    = 0;
  47     size_t  len  = 5555;
  48     char   *pt1  = mem_get_zero( sizeof( char ) * len );
  49     uint   *pt2  = mem_get_zero( sizeof( uint ) * len );
  50
  51     for ( i = 0; i <= ( sizeof( char ) * len ); i++ ) {
  52         assert( pt1[ i ] == '\0' );
  53     }
  54
  55     for ( i = 0; i <= ( sizeof( char ) * len ); i++ ) {
  56         assert( pt2[ i ] == '\0' );
  57     }
  58
  59     mem_free( ( void * ) &pt1 );
  60     mem_free( ( void * ) &pt2 );
  61
  62     fprintf( stderr, "OK\n" );
  63 }
  64
  65
  66 void test_mem_resize()
  67 {
  68     fprintf( stderr, "   Testing mem_resize ... " );
  69
  70     char *pt0 = "foo";
  71     char *pt1 = NULL;
  72
  73     pt1 = mem_get( 3 + 1 );
  74
  75     memcpy( pt1, pt0, 3 );
  76
  77     pt1 = mem_resize( pt1, 1 );
  78
  79     mem_free( ( void * ) &pt1 );
  80
  81     fprintf( stderr, "OK\n" );
  82 }
  83
  84
  85 void test_mem_resize_zero()
  86 {
  87     fprintf( stderr, "   Testing mem_resize_zero ... " );
  88
  89     size_t i;
  90     size_t size_before = 10;
  91     size_t size_after  = 100000;
  92
  93     char *pt = NULL;
  94
  95     pt = mem_get( size_before );
  96
  97     memset( pt, '1', size_before );
  98
  99     pt = mem_resize_zero( pt, size_before, size_after );
 100
 101     assert( strlen( pt ) == size_before );
 102
 103     for ( i = size_before; i <= size_after; i++ ) {
 104         assert( pt[ i ] == '\0' );
 105     }
 106
 107     mem_free( ( void * ) &pt );
 108
 109     fprintf( stderr, "OK\n" );
 110 }
 111
 112
 113 void test_mem_clone()
 114 {
 115     fprintf( stderr, "   Testing mem_clone ... " );
 116
 117     char   *pt;
 118     char   *pt_clone;
 119     size_t  pt_size = 10000;
 120     size_t  i;
 121
 122     pt = mem_get( pt_size );
 123
 124     memset( pt, 'X', pt_size );
 125
 126     pt_clone = mem_clone( pt, pt_size );
 127
 128     assert( pt_clone != pt );
 129     assert( &pt_clone != &pt );
 130
 131     for ( i = 0; i < pt_size; i++ ) {
 132         assert( pt[ i ] == pt_clone[ i ] );
 133     }
 134
 135     mem_free( ( void * ) &pt );
 136     mem_free( ( void * ) &pt_clone );
 137
 138     fprintf( stderr, "OK\n" );
 139 }
 140
 141
 142 void test_mem_free()
 143 {
 144     fprintf( stderr, "   Testing mem_free ... " );
 145
 146     uint   mem = 500000000;
 147     int   i    = 0;
 148     char *pt   = NULL;
 149
 150     pt = mem_get( mem );
 151
 152     for ( i = 0; i < mem; i++ )
 153     {
 154
 155     }
 156
 157     assert( pt != NULL );
 158
 159     mem_free( &pt );
 160
 161     assert( pt == NULL );
 162
 163     fprintf( stderr, "OK\n" );
 164 }
 165
 166