/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include <malloc.h>
#include <stdint.h>

#include "alloc-util.h"
#include "macro.h"
#include "memory-util.h"
#include "random-util.h"
#include "tests.h"

TEST(alloca) {
        static const uint8_t zero[997] = { };
        char *t;

        t = alloca_align(17, 512);
        assert_se(!((uintptr_t)t & 0xff));
        memzero(t, 17);

        t = alloca0_align(997, 1024);
        assert_se(!((uintptr_t)t & 0x1ff));
        assert_se(!memcmp(t, zero, 997));
}

TEST(GREEDY_REALLOC) {
        _cleanup_free_ int *a = NULL, *b = NULL, *c = NULL;
        size_t i, j, n_c = 0;

        /* Give valgrind a chance to verify our realloc() operations */

        for (i = 0; i < 20480; i++) {
                assert_se(GREEDY_REALLOC(a, i + 1));
                assert_se(MALLOC_ELEMENTSOF(a) >= i + 1);
                assert_se(MALLOC_SIZEOF_SAFE(a) >= (i + 1) * sizeof(int));
                a[i] = (int) i;
                assert_se(GREEDY_REALLOC(a, i / 2));
                assert_se(MALLOC_ELEMENTSOF(a) >= i / 2);
                assert_se(MALLOC_SIZEOF_SAFE(a) >= (i / 2) * sizeof(int));
        }

        for (j = 0; j < i / 2; j++)
                assert_se(a[j] == (int) j);

        for (i = 30; i < 20480; i += 7) {
                assert_se(GREEDY_REALLOC(b, i + 1));
                assert_se(MALLOC_ELEMENTSOF(b) >= i + 1);
                assert_se(MALLOC_SIZEOF_SAFE(b) >= (i + 1) * sizeof(int));
                b[i] = (int) i;
                assert_se(GREEDY_REALLOC(b, i / 2));
                assert_se(MALLOC_ELEMENTSOF(b) >= i / 2);
                assert_se(MALLOC_SIZEOF_SAFE(b) >= (i / 2) * sizeof(int));
        }

        for (j = 30; j < i / 2; j += 7)
                assert_se(b[j] == (int) j);

        size_t n_from = 10;
        int from[n_from];
        for (i = 0; i < 2048; i++) {
                for (j = 0; j < n_from; j++)
                        from[j] = n_from * i + j;

                _cleanup_free_ int *before = NULL;
                size_t n_before = 0;
                assert_se(GREEDY_REALLOC_APPEND(before, n_before, c, n_c));
                assert_se(before);
                assert_se(n_before == n_c);
                assert_se(memcmp_safe(c, before, n_c) == 0);

                assert_se(GREEDY_REALLOC_APPEND(c, n_c, from, n_from));
                assert_se(n_c == n_before + n_from);
                assert_se(MALLOC_ELEMENTSOF(c) >= n_c);
                assert_se(MALLOC_SIZEOF_SAFE(c) >= n_c * sizeof(int));
                assert_se(memcmp_safe(c, before, n_before) == 0);
                assert_se(memcmp_safe(&c[n_before], from, n_from) == 0);

                before = mfree(before);
                assert_se(!before);
                n_before = 0;
                assert_se(GREEDY_REALLOC_APPEND(before, n_before, c, n_c));
                assert_se(before);
                assert_se(n_before == n_c);
                assert_se(memcmp_safe(c, before, n_c) == 0);

                assert_se(GREEDY_REALLOC_APPEND(c, n_c, NULL, 0));
                assert_se(c);
                assert_se(n_c == n_before);
                assert_se(MALLOC_ELEMENTSOF(c) >= n_c);
                assert_se(MALLOC_SIZEOF_SAFE(c) >= n_c * sizeof(int));
                assert_se(memcmp_safe(c, before, n_c) == 0);
        }

        for (j = 0; j < i * n_from; j++)
                assert_se(c[j] == (int) j);
}

TEST(memdup_multiply_and_greedy_realloc) {
        static const int org[] = { 1, 2, 3 };
        _cleanup_free_ int *dup;
        size_t i;
        int *p;

        dup = memdup_suffix0_multiply(org, 3, sizeof(int));
        assert_se(dup);
        assert_se(dup[0] == 1);
        assert_se(dup[1] == 2);
        assert_se(dup[2] == 3);
        assert_se(((uint8_t*) dup)[sizeof(int) * 3] == 0);
        free(dup);

        dup = memdup_multiply(org, 3, sizeof(int));
        assert_se(dup);
        assert_se(dup[0] == 1);
        assert_se(dup[1] == 2);
        assert_se(dup[2] == 3);

        memzero(dup + 3, malloc_usable_size(dup) - sizeof(int) * 3);

        p = dup;
        assert_se(GREEDY_REALLOC0(dup, 2) == p);

        p = GREEDY_REALLOC0(dup, 10);
        assert_se(p == dup);
        assert_se(MALLOC_ELEMENTSOF(p) >= 10);
        assert_se(p[0] == 1);
        assert_se(p[1] == 2);
        assert_se(p[2] == 3);
        for (i = 3; i < MALLOC_ELEMENTSOF(p); i++)
                assert_se(p[i] == 0);
}

TEST(bool_assign) {
        bool b, c, *cp = &c, d, e, f, g, h;

        b = 123;
        *cp = -11;
        d = 0xF & 0xFF;
        e = b & d;
        f = 0x0;
        g = cp;    /* cast from pointer */
        h = NULL;  /* cast from pointer */

        assert_se(b);
        assert_se(c);
        assert_se(d);
        assert_se(e);
        assert_se(!f);
        assert_se(g);
        assert_se(!h);
}

static int cleanup_counter = 0;

static void cleanup1(void *a) {
        log_info("%s(%p)", __func__, a);
        assert_se(++cleanup_counter == *(int*) a);
}
static void cleanup2(void *a) {
        log_info("%s(%p)", __func__, a);
        assert_se(++cleanup_counter == *(int*) a);
}
static void cleanup3(void *a) {
        log_info("%s(%p)", __func__, a);
        assert_se(++cleanup_counter == *(int*) a);
}

TEST(cleanup_order) {
        _cleanup_(cleanup1) int x1 = 4, x2 = 3;
        _cleanup_(cleanup3) int z = 2;
        _cleanup_(cleanup2) int y = 1;
        log_debug("x1: %p", &x1);
        log_debug("x2: %p", &x2);
        log_debug("y: %p", &y);
        log_debug("z: %p", &z);
}

TEST(auto_erase_memory) {
        _cleanup_(erase_and_freep) uint8_t *p1, *p2;

        /* print address of p2, else e.g. clang-11 will optimize it out */
        log_debug("p1: %p p2: %p", &p1, &p2);

        assert_se(p1 = new(uint8_t, 4703)); /* use prime size, to ensure that there will be free space at the
                                             * end of the allocation, since malloc() enforces alignment */
        assert_se(p2 = new(uint8_t, 4703));

        assert_se(crypto_random_bytes(p1, 4703) == 0);

        /* before we exit the scope, do something with this data, so that the compiler won't optimize this away */
        memcpy(p2, p1, 4703);
        for (size_t i = 0; i < 4703; i++)
                assert_se(p1[i] == p2[i]);
}

#define TEST_SIZES(f, n)                                                \
        do {                                                            \
                log_debug("requested=%zu vs. malloc_size=%zu vs. gcc_size=%zu", \
                          n * sizeof(*f),                               \
                          malloc_usable_size(f),                        \
                          __builtin_object_size(f, 0));                 \
                assert_se(MALLOC_ELEMENTSOF(f) >= n);                   \
                assert_se(MALLOC_SIZEOF_SAFE(f) >= sizeof(*f) * n);     \
                assert_se(malloc_usable_size(f) >= sizeof(*f) * n);     \
                assert_se(__builtin_object_size(f, 0) >= sizeof(*f) * n); \
        } while (false)

TEST(malloc_size_safe) {
        _cleanup_free_ uint32_t *f = NULL;
        size_t n = 4711;

        /* Let's check the macros and built-ins work on NULL and return the expected values */
        assert_se(MALLOC_ELEMENTSOF((float*) NULL) == 0);
        assert_se(MALLOC_SIZEOF_SAFE((float*) NULL) == 0);
        assert_se(malloc_usable_size(NULL) == 0); /* as per man page, this is safe and defined */
        assert_se(__builtin_object_size(NULL, 0) == SIZE_MAX); /* as per docs SIZE_MAX is returned for pointers where the size isn't known */

        /* Then, let's try these macros once with constant size values, so that __builtin_object_size()
         * definitely can work (as long as -O2 is used when compiling) */
        assert_se(f = new(uint32_t, n));
        TEST_SIZES(f, n);

        /* Finally, let's use some dynamically sized allocations, to make sure this doesn't deteriorate */
        for (unsigned i = 0; i < 50; i++) {
                _cleanup_free_ uint64_t *g = NULL;
                size_t m;

                m = random_u64_range(16*1024);
                assert_se(g = new(uint64_t, m));
                TEST_SIZES(g, m);
        }
}

DEFINE_TEST_MAIN(LOG_DEBUG);
