src/test/test-alloc-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <malloc.h>
   4 #include <stdint.h>
   5
   6 #include "alloc-util.h"
   7 #include "macro.h"
   8 #include "memory-util.h"
   9
  10 static void test_alloca(void) {
  11         static const uint8_t zero[997] = { };
  12         char *t;
  13
  14         t = alloca_align(17, 512);
  15         assert_se(!((uintptr_t)t & 0xff));
  16         memzero(t, 17);
  17
  18         t = alloca0_align(997, 1024);
  19         assert_se(!((uintptr_t)t & 0x1ff));
  20         assert_se(!memcmp(t, zero, 997));
  21 }
  22
  23 static void test_GREEDY_REALLOC(void) {
  24         _cleanup_free_ int *a = NULL, *b = NULL;
  25         size_t n_allocated = 0, i, j;
  26
  27         /* Give valgrind a chance to verify our realloc() operations */
  28
  29         for (i = 0; i < 20480; i++) {
  30                 assert_se(GREEDY_REALLOC(a, n_allocated, i + 1));
  31                 assert_se(n_allocated >= i + 1);
  32                 assert_se(malloc_usable_size(a) >= (i + 1) * sizeof(int));
  33                 a[i] = (int) i;
  34                 assert_se(GREEDY_REALLOC(a, n_allocated, i / 2));
  35                 assert_se(n_allocated >= i / 2);
  36                 assert_se(malloc_usable_size(a) >= (i / 2) * sizeof(int));
  37         }
  38
  39         for (j = 0; j < i / 2; j++)
  40                 assert_se(a[j] == (int) j);
  41
  42         for (i = 30, n_allocated = 0; i < 20480; i += 7) {
  43                 assert_se(GREEDY_REALLOC(b, n_allocated, i + 1));
  44                 assert_se(n_allocated >= i + 1);
  45                 assert_se(malloc_usable_size(b) >= (i + 1) * sizeof(int));
  46                 b[i] = (int) i;
  47                 assert_se(GREEDY_REALLOC(b, n_allocated, i / 2));
  48                 assert_se(n_allocated >= i / 2);
  49                 assert_se(malloc_usable_size(b) >= (i / 2) * sizeof(int));
  50         }
  51
  52         for (j = 30; j < i / 2; j += 7)
  53                 assert_se(b[j] == (int) j);
  54 }
  55
  56 static void test_memdup_multiply_and_greedy_realloc(void) {
  57         int org[] = {1, 2, 3};
  58         _cleanup_free_ int *dup;
  59         int *p;
  60         size_t i, allocated = 3;
  61
  62         dup = (int*) memdup_suffix0_multiply(org, sizeof(int), 3);
  63         assert_se(dup);
  64         assert_se(dup[0] == 1);
  65         assert_se(dup[1] == 2);
  66         assert_se(dup[2] == 3);
  67         assert_se(*(uint8_t*) (dup + 3) == (uint8_t) 0);
  68         free(dup);
  69
  70         dup = (int*) memdup_multiply(org, sizeof(int), 3);
  71         assert_se(dup);
  72         assert_se(dup[0] == 1);
  73         assert_se(dup[1] == 2);
  74         assert_se(dup[2] == 3);
  75
  76         p = dup;
  77         assert_se(greedy_realloc0((void**) &dup, &allocated, 2, sizeof(int)) == p);
  78
  79         p = (int *) greedy_realloc0((void**) &dup, &allocated, 10, sizeof(int));
  80         assert_se(p == dup);
  81         assert_se(allocated >= 10);
  82         assert_se(p[0] == 1);
  83         assert_se(p[1] == 2);
  84         assert_se(p[2] == 3);
  85         for (i = 3; i < allocated; i++)
  86                 assert_se(p[i] == 0);
  87 }
  88
  89 static void test_bool_assign(void) {
  90         bool b, c, *cp = &c, d, e, f, g, h;
  91
  92         b = 123;
  93         *cp = -11;
  94         d = 0xF & 0xFF;
  95         e = b & d;
  96         f = 0x0;
  97         g = cp;    /* cast from pointer */
  98         h = NULL;  /* cast from pointer */
  99
 100         assert(b);
 101         assert(c);
 102         assert(d);
 103         assert(e);
 104         assert(!f);
 105         assert(g);
 106         assert(!h);
 107 }
 108
 109 int main(int argc, char *argv[]) {
 110         test_alloca();
 111         test_GREEDY_REALLOC();
 112         test_memdup_multiply_and_greedy_realloc();
 113         test_bool_assign();
 114
 115         return 0;
 116 }