test_mem.c

00001 #include "test_mem.h"
00002 
00003 #include "lwip/mem.h"
00004 #include "lwip/stats.h"
00005 
00006 #if !LWIP_STATS || !MEM_STATS
00007 #error "This tests needs MEM-statistics enabled"
00008 #endif
00009 #if LWIP_DNS
00010 #error "This test needs DNS turned off (as it mallocs on init)"
00011 #endif
00012 
00013 /* Setups/teardown functions */
00014 
00015 static void
00016 mem_setup(void)
00017 {
00018   lwip_check_ensure_no_alloc(SKIP_POOL(MEMP_SYS_TIMEOUT));
00019 }
00020 
00021 static void
00022 mem_teardown(void)
00023 {
00024   lwip_check_ensure_no_alloc(SKIP_POOL(MEMP_SYS_TIMEOUT));
00025 }
00026 
00027 
00028 /* Test functions */
00029 
00030 /** Call mem_malloc, mem_free and mem_trim and check stats */
00031 START_TEST(test_mem_one)
00032 {
00033 #define SIZE1   16
00034 #define SIZE1_2 12
00035 #define SIZE2   16
00036   void *p1, *p2;
00037   mem_size_t s1, s2;
00038   LWIP_UNUSED_ARG(_i);
00039 
00040   fail_unless(lwip_stats.mem.used == 0);
00041 
00042   p1 = mem_malloc(SIZE1);
00043   fail_unless(p1 != NULL);
00044   fail_unless(lwip_stats.mem.used >= SIZE1);
00045   s1 = lwip_stats.mem.used;
00046 
00047   p2 = mem_malloc(SIZE2);
00048   fail_unless(p2 != NULL);
00049   fail_unless(lwip_stats.mem.used >= SIZE2 + s1);
00050   s2 = lwip_stats.mem.used;
00051 
00052   mem_trim(p1, SIZE1_2);
00053 
00054   mem_free(p2);
00055   fail_unless(lwip_stats.mem.used <= s2 - SIZE2);
00056 
00057   mem_free(p1);
00058   fail_unless(lwip_stats.mem.used == 0);
00059 }
00060 END_TEST
00061 
00062 static void malloc_keep_x(int x, int num, int size, int freestep)
00063 {
00064    int i;
00065    void* p[16];
00066    LWIP_ASSERT("invalid size", size >= 0 && size < (mem_size_t)-1);
00067    memset(p, 0, sizeof(p));
00068    for(i = 0; i < num && i < 16; i++) {
00069       p[i] = mem_malloc((mem_size_t)size);
00070       fail_unless(p[i] != NULL);
00071    }
00072    for(i = 0; i < num && i < 16; i += freestep) {
00073       if (i == x) {
00074          continue;
00075       }
00076       mem_free(p[i]);
00077       p[i] = NULL;
00078    }
00079    for(i = 0; i < num && i < 16; i++) {
00080       if (i == x) {
00081          continue;
00082       }
00083       if (p[i] != NULL) {
00084          mem_free(p[i]);
00085          p[i] = NULL;
00086       }
00087    }
00088    fail_unless(p[x] != NULL);
00089    mem_free(p[x]);
00090 }
00091 
00092 START_TEST(test_mem_random)
00093 {
00094   const int num = 16;
00095   int x;
00096   int size;
00097   int freestep;
00098   LWIP_UNUSED_ARG(_i);
00099 
00100   fail_unless(lwip_stats.mem.used == 0);
00101 
00102   for (x = 0; x < num; x++) {
00103      for (size = 1; size < 32; size++) {
00104         for (freestep = 1; freestep <= 3; freestep++) {
00105           fail_unless(lwip_stats.mem.used == 0);
00106           malloc_keep_x(x, num, size, freestep);
00107           fail_unless(lwip_stats.mem.used == 0);
00108         }
00109      }
00110   }
00111 }
00112 END_TEST
00113 
00114 START_TEST(test_mem_invalid_free)
00115 {
00116   u8_t *ptr, *ptr_low, *ptr_high;
00117   LWIP_UNUSED_ARG(_i);
00118 
00119   fail_unless(lwip_stats.mem.used == 0);
00120   fail_unless(lwip_stats.mem.illegal == 0);
00121 
00122   ptr = (u8_t *)mem_malloc(1);
00123   fail_unless(ptr != NULL);
00124   fail_unless(lwip_stats.mem.used != 0);
00125 
00126   ptr_low = ptr - 0x10;
00127   mem_free(ptr_low);
00128   fail_unless(lwip_stats.mem.illegal == 1);
00129   lwip_stats.mem.illegal = 0;
00130 
00131   ptr_high = ptr + (MEM_SIZE * 2);
00132   mem_free(ptr_high);
00133   fail_unless(lwip_stats.mem.illegal == 1);
00134   lwip_stats.mem.illegal = 0;
00135 
00136   mem_free(ptr);
00137   fail_unless(lwip_stats.mem.illegal == 0);
00138   fail_unless(lwip_stats.mem.used == 0);
00139 }
00140 END_TEST
00141 
00142 START_TEST(test_mem_double_free)
00143 {
00144   u8_t *ptr1b, *ptr1, *ptr2, *ptr3;
00145   LWIP_UNUSED_ARG(_i);
00146 
00147   fail_unless(lwip_stats.mem.used == 0);
00148   fail_unless(lwip_stats.mem.illegal == 0);
00149 
00150   ptr1 = (u8_t *)mem_malloc(1);
00151   fail_unless(ptr1 != NULL);
00152   fail_unless(lwip_stats.mem.used != 0);
00153 
00154   ptr2 = (u8_t *)mem_malloc(1);
00155   fail_unless(ptr2 != NULL);
00156   fail_unless(lwip_stats.mem.used != 0);
00157 
00158   ptr3 = (u8_t *)mem_malloc(1);
00159   fail_unless(ptr3 != NULL);
00160   fail_unless(lwip_stats.mem.used != 0);
00161 
00162   /* free the middle mem */
00163   mem_free(ptr2);
00164   fail_unless(lwip_stats.mem.illegal == 0);
00165 
00166   /* double-free of middle mem: should fail */
00167   mem_free(ptr2);
00168   fail_unless(lwip_stats.mem.illegal == 1);
00169   lwip_stats.mem.illegal = 0;
00170 
00171   /* free upper memory and try again */
00172   mem_free(ptr3);
00173   fail_unless(lwip_stats.mem.illegal == 0);
00174 
00175   mem_free(ptr2);
00176   fail_unless(lwip_stats.mem.illegal == 1);
00177   lwip_stats.mem.illegal = 0;
00178 
00179   /* free lower memory and try again */
00180   mem_free(ptr1);
00181   fail_unless(lwip_stats.mem.illegal == 0);
00182   fail_unless(lwip_stats.mem.used == 0);
00183 
00184   mem_free(ptr2);
00185   fail_unless(lwip_stats.mem.illegal == 1);
00186   fail_unless(lwip_stats.mem.used == 0);
00187   lwip_stats.mem.illegal = 0;
00188 
00189   /* reallocate lowest memory, now overlapping already freed ptr2 */
00190 #ifndef MIN_SIZE
00191 #define MIN_SIZE 12
00192 #endif
00193   ptr1b = (u8_t *)mem_malloc(MIN_SIZE * 2);
00194   fail_unless(ptr1b != NULL);
00195   fail_unless(lwip_stats.mem.used != 0);
00196 
00197   mem_free(ptr2);
00198   fail_unless(lwip_stats.mem.illegal == 1);
00199   lwip_stats.mem.illegal = 0;
00200 
00201   memset(ptr1b, 1, MIN_SIZE * 2);
00202 
00203   mem_free(ptr2);
00204   fail_unless(lwip_stats.mem.illegal == 1);
00205   lwip_stats.mem.illegal = 0;
00206 
00207   mem_free(ptr1b);
00208   fail_unless(lwip_stats.mem.illegal == 0);
00209   fail_unless(lwip_stats.mem.used == 0);
00210 }
00211 END_TEST
00212 
00213 /** Create the suite including all tests for this module */
00214 Suite *
00215 mem_suite(void)
00216 {
00217   testfunc tests[] = {
00218     TESTFUNC(test_mem_one),
00219     TESTFUNC(test_mem_random),
00220     TESTFUNC(test_mem_invalid_free),
00221     TESTFUNC(test_mem_double_free)
00222   };
00223   return create_suite("MEM", tests, sizeof(tests)/sizeof(testfunc), mem_setup, mem_teardown);
00224 }