src/test/test-alloc-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <stdint.h>
   4
   5 #include "alloc-util.h"
   6 #include "macro.h"
   7 #include "util.h"
   8
   9 static void test_alloca(void) {
  10         static const uint8_t zero[997] = { };
  11         char *t;
  12
  13         t = alloca_align(17, 512);
  14         assert_se(!((uintptr_t)t & 0xff));
  15         memzero(t, 17);
  16
  17         t = alloca0_align(997, 1024);
  18         assert_se(!((uintptr_t)t & 0x1ff));
  19         assert_se(!memcmp(t, zero, 997));
  20 }
  21
  22 static void test_memdup_multiply_and_greedy_realloc(void) {
  23         int org[] = {1, 2, 3};
  24         _cleanup_free_ int *dup;
  25         int *p;
  26         size_t i, allocated = 3;
  27
  28         dup = (int*) memdup_suffix0_multiply(org, sizeof(int), 3);
  29         assert_se(dup);
  30         assert_se(dup[0] == 1);
  31         assert_se(dup[1] == 2);
  32         assert_se(dup[2] == 3);
  33         assert_se(*(uint8_t*) (dup + 3) == (uint8_t) 0);
  34         free(dup);
  35
  36         dup = (int*) memdup_multiply(org, sizeof(int), 3);
  37         assert_se(dup);
  38         assert_se(dup[0] == 1);
  39         assert_se(dup[1] == 2);
  40         assert_se(dup[2] == 3);
  41
  42         p = dup;
  43         assert_se(greedy_realloc0((void**) &dup, &allocated, 2, sizeof(int)) == p);
  44
  45         p = (int *) greedy_realloc0((void**) &dup, &allocated, 10, sizeof(int));
  46         assert_se(p == dup);
  47         assert_se(allocated >= 10);
  48         assert_se(p[0] == 1);
  49         assert_se(p[1] == 2);
  50         assert_se(p[2] == 3);
  51         for (i = 3; i < allocated; i++)
  52                 assert_se(p[i] == 0);
  53 }
  54
  55 static void test_bool_assign(void) {
  56         bool b, c, *cp = &c, d, e, f, g, h;
  57
  58         b = 123;
  59         *cp = -11;
  60         d = 0xF & 0xFF;
  61         e = b & d;
  62         f = 0x0;
  63         g = cp;    /* cast from pointer */
  64         h = NULL;  /* cast from pointer */
  65
  66         assert(b);
  67         assert(c);
  68         assert(d);
  69         assert(e);
  70         assert(!f);
  71         assert(g);
  72         assert(!h);
  73 }
  74
  75 int main(int argc, char *argv[]) {
  76         test_alloca();
  77         test_memdup_multiply_and_greedy_realloc();
  78         test_bool_assign();
  79
  80         return 0;
  81 }