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   *pt  = mem_get_zero( len );
  49
  50     for ( i = 0; i <= len; i++ ) {
  51         assert( pt[ i ] == '\0' );
  52     }
  53
  54     mem_free( ( void * ) &pt );
  55
  56     fprintf( stderr, "OK\n" );
  57 }
  58
  59
  60 void test_mem_resize()
  61 {
  62     fprintf( stderr, "   Testing mem_resize ... " );
  63
  64     char *pt0 = "foo";
  65     char *pt1 = NULL;
  66
  67     pt1 = mem_get( 3 + 1 );
  68
  69     memcpy( pt1, pt0, 3 );
  70
  71     pt1 = mem_resize( pt1, 1 );
  72
  73     mem_free( ( void * ) &pt1 );
  74
  75     fprintf( stderr, "OK\n" );
  76 }
  77
  78
  79 void test_mem_resize_zero()
  80 {
  81     fprintf( stderr, "   Testing mem_resize_zero ... " );
  82
  83     size_t i;
  84     size_t size_before = 10;
  85     size_t size_after  = 100000;
  86
  87     char *pt = NULL;
  88
  89     pt = mem_get( size_before );
  90
  91     memset( pt, '1', size_before );
  92
  93     assert( strlen( pt ) == size_before );
  94
  95     pt = mem_resize_zero( pt, size_before, size_after );
  96
  97     assert( strlen( pt ) == size_before );
  98
  99     for ( i = size_before; i <= size_after; i++ ) {
 100         assert( pt[ i ] == '\0' );
 101     }
 102
 103     mem_free( ( void * ) &pt );
 104
 105     fprintf( stderr, "OK\n" );
 106 }
 107
 108
 109 void test_mem_clone()
 110 {
 111     fprintf( stderr, "   Testing mem_clone ... " );
 112
 113     char   *pt;
 114     char   *pt_clone;
 115     size_t  pt_size = 10000;
 116     size_t  i;
 117
 118     pt = mem_get( pt_size );
 119
 120     memset( pt, 'X', pt_size );
 121
 122     pt_clone = mem_clone( pt, pt_size );
 123
 124     assert( pt_clone != pt );
 125     assert( &pt_clone != &pt );
 126
 127     for ( i = 0; i < pt_size; i++ ) {
 128         assert( pt[ i ] == pt_clone[ i ] );
 129     }
 130
 131     mem_free( ( void * ) &pt );
 132     mem_free( ( void * ) &pt_clone );
 133
 134     fprintf( stderr, "OK\n" );
 135 }
 136
 137
 138 void test_mem_free()
 139 {
 140     fprintf( stderr, "   Testing mem_free ... " );
 141
 142     char *pt0 = "foo";
 143     void *pt1 = NULL;
 144     char *pt2 = NULL;
 145
 146     assert( pt0 != NULL );
 147     assert( pt1 == NULL );
 148     assert( pt2 == NULL );
 149
 150     pt1 = mem_get( 100 );
 151     pt2 = mem_get( 100 );
 152
 153     assert( pt1 != NULL );
 154     assert( pt2 != NULL );
 155
 156     memcpy( pt2, pt0, 3 );
 157
 158     mem_free( &pt1 );
 159     mem_free( &pt1 );
 160     mem_free( ( void * ) &pt1 );
 161     mem_free( ( void * ) &pt2 );
 162
 163     assert( pt1 == NULL );
 164     assert( pt2 == NULL );
 165
 166     fprintf( stderr, "OK\n" );
 167 }