git.ozlabs.org Git - ccan/blob - ccan/alloc/test/run-testsize.c

   1 #include <ccan/alloc/alloc.h>
   2 #include <ccan/tap/tap.h>
   3 #include <ccan/alloc/alloc.c>
   4 #include <ccan/alloc/bitops.c>
   5 #include <ccan/alloc/tiny.c>
   6 #include <stdlib.h>
   7 #include <stdbool.h>
   8 #include <err.h>
   9
  10 static void invert_bytes(unsigned char *p, unsigned long size)
  11 {
  12         unsigned int i;
  13
  14         for (i = 0; i < size; i++)
  15                 p[i] ^= 0xFF;
  16 }
  17
  18 static bool sizes_ok(void *mem, unsigned long poolsize, void *p[], unsigned num)
  19 {
  20         unsigned int i;
  21
  22         for (i = 0; i < num; i++)
  23                 if (p[i] && alloc_size(mem, poolsize, p[i]) < i)
  24                         return false;
  25         return true;
  26 }
  27
  28 static void test_pool(unsigned long pool_size)
  29 {
  30         unsigned int i, j, num;
  31         void *mem;
  32         void **p;
  33         bool flip = false;
  34
  35         p = calloc(pool_size, sizeof(void *));
  36         mem = malloc(pool_size);
  37
  38         alloc_init(mem, pool_size);
  39
  40         /* Check that alloc_size() gives reasonable answers. */
  41         for (i = 0; i < pool_size; i = i * 3 / 2 + 1) {
  42                 p[i] = alloc_get(mem, pool_size, i, 1);
  43                 if (!p[i])
  44                         break;
  45                 invert_bytes(p[i], alloc_size(mem, pool_size, p[i]));
  46         }
  47         ok1(i < pool_size);
  48         num = i;
  49         ok1(alloc_check(mem, pool_size));
  50         ok1(sizes_ok(mem, pool_size, p, num));
  51
  52         /* Free every second one. */
  53         for (i = j = 0; i < num; i = i * 3 / 2 + 1) {
  54                 flip = !flip;
  55                 if (flip) {
  56                         /* Compact. */
  57                         p[j++] = p[i];
  58                         invert_bytes(p[i], alloc_size(mem,pool_size,p[i]));
  59                         continue;
  60                 }
  61                 alloc_free(mem, pool_size, p[i]);
  62         }
  63         num /= 2;
  64         ok1(alloc_check(mem, pool_size));
  65         ok1(sizes_ok(mem, pool_size, p, num));
  66         free(p);
  67         free(mem);
  68 }
  69
  70 int main(int argc, char *argv[])
  71 {
  72         plan_tests(10);
  73
  74         /* Large test. */
  75         test_pool(MIN_USEFUL_SIZE * 2);
  76
  77         /* Small test. */
  78         test_pool(MIN_USEFUL_SIZE / 2);
  79
  80         return exit_status();
  81 }