test-alloc-util: add a "test" for bool casts

[elogind.git] / src / test / test-alloc-util.c

diff --git a/src/test/test-alloc-util.c b/src/test/test-alloc-util.c
index cc4821eaf57d3bbedf5a22f24346517bcd819388..324f786c37149af129dfa083b381faa02ffab7d1 100644 (file)
--- a/src/test/test-alloc-util.c
+++ b/src/test/test-alloc-util.c
@@ -1,22 +1,12 @@
+/* SPDX-License-Identifier: LGPL-2.1+ */
 /***
   This file is part of systemd.
 
   Copyright 2010 Lennart Poettering
-
-  systemd is free software; you can redistribute it and/or modify it
-  under the terms of the GNU Lesser General Public License as published by
-  the Free Software Foundation; either version 2.1 of the License, or
-  (at your option) any later version.
-
-  systemd is distributed in the hope that it will be useful, but
-  WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of the GNU Lesser General Public License
-  along with systemd; If not, see <http://www.gnu.org/licenses/>.
 ***/
 
+//#include <stdint.h>
+
 #include "alloc-util.h"
 #include "macro.h"
 #include "util.h"
@@ -34,22 +24,59 @@ static void test_alloca(void) {
         assert_se(!memcmp(t, zero, 997));
 }
 
-static void test_memdup_multiply(void) {
+static void test_memdup_multiply_and_greedy_realloc(void) {
         int org[] = {1, 2, 3};
-        int *dup;
-
-        dup = (int*)memdup_multiply(org, sizeof(int), 3);
+        _cleanup_free_ int *dup;
+        int *p;
+        size_t i, allocated = 3;
 
+        dup = (int*) memdup_suffix0_multiply(org, sizeof(int), 3);
         assert_se(dup);
         assert_se(dup[0] == 1);
         assert_se(dup[1] == 2);
         assert_se(dup[2] == 3);
+        assert_se(*(uint8_t*) (dup + 3) == (uint8_t) 0);
         free(dup);
+
+        dup = (int*) memdup_multiply(org, sizeof(int), 3);
+        assert_se(dup);
+        assert_se(dup[0] == 1);
+        assert_se(dup[1] == 2);
+        assert_se(dup[2] == 3);
+
+        p = dup;
+        assert_se(greedy_realloc0((void**) &dup, &allocated, 2, sizeof(int)) == p);
+
+        p = (int *) greedy_realloc0((void**) &dup, &allocated, 10, sizeof(int));
+        assert_se(p == dup);
+        assert_se(allocated >= 10);
+        assert_se(p[0] == 1);
+        assert_se(p[1] == 2);
+        assert_se(p[2] == 3);
+        for (i = 3; i < allocated; i++)
+                assert_se(p[i] == 0);
+}
+
+static void test_bool_assign(void) {
+        bool b, c, *cp = &c, d, e, f;
+
+        b = 123;
+        *cp = -11;
+        d = 0xF & 0xFF;
+        e = b & d;
+        f = 0x0;
+
+        assert(b);
+        assert(c);
+        assert(d);
+        assert(e);
+        assert(!f);
 }
 
 int main(int argc, char *argv[]) {
         test_alloca();
-        test_memdup_multiply();
+        test_memdup_multiply_and_greedy_realloc();
+        test_bool_assign();
 
         return 0;
 }