1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/tests/util_allocator.cpp Tue Feb 07 21:55:37 2023 +0100
1.3 @@ -0,0 +1,167 @@
1.4 +/*
1.5 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
1.6 + *
1.7 + * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved.
1.8 + *
1.9 + * Redistribution and use in source and binary forms, with or without
1.10 + * modification, are permitted provided that the following conditions are met:
1.11 + *
1.12 + * 1. Redistributions of source code must retain the above copyright
1.13 + * notice, this list of conditions and the following disclaimer.
1.14 + *
1.15 + * 2. Redistributions in binary form must reproduce the above copyright
1.16 + * notice, this list of conditions and the following disclaimer in the
1.17 + * documentation and/or other materials provided with the distribution.
1.18 + *
1.19 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
1.20 + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1.21 + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1.22 + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
1.23 + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
1.24 + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
1.25 + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
1.26 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
1.27 + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
1.28 + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
1.29 + * POSSIBILITY OF SUCH DAMAGE.
1.30 + */
1.31 +
1.32 +#include "util_allocator.h"
1.33 +
1.34 +void *cx_malloc_testing(void *d, size_t n) {
1.35 + auto data = reinterpret_cast<CxTestingAllocator *>(d);
1.36 + void *ptr = malloc(n);
1.37 + data->alloc_total++;
1.38 + if (ptr == nullptr) {
1.39 + data->alloc_failed++;
1.40 + } else {
1.41 + data->tracked.insert(ptr);
1.42 + }
1.43 + return ptr;
1.44 +}
1.45 +
1.46 +void *cx_realloc_testing(void *d, void *mem, size_t n) {
1.47 + auto data = reinterpret_cast<CxTestingAllocator *>(d);
1.48 + void *ptr = realloc(mem, n);
1.49 + if (ptr == mem) {
1.50 + return ptr;
1.51 + } else {
1.52 + data->alloc_total++;
1.53 + if (ptr == nullptr) {
1.54 + data->alloc_failed++;
1.55 + } else {
1.56 + data->free_total++;
1.57 + if (data->tracked.erase(mem) == 0) {
1.58 + data->free_failed++;
1.59 + }
1.60 + data->tracked.insert(ptr);
1.61 + }
1.62 + return ptr;
1.63 + }
1.64 +}
1.65 +
1.66 +void *cx_calloc_testing(void *d, size_t nelem, size_t n) {
1.67 + auto data = reinterpret_cast<CxTestingAllocator *>(d);
1.68 + void *ptr = calloc(nelem, n);
1.69 + data->alloc_total++;
1.70 + if (ptr == nullptr) {
1.71 + data->alloc_failed++;
1.72 + } else {
1.73 + data->tracked.insert(ptr);
1.74 + }
1.75 + return ptr;
1.76 +}
1.77 +
1.78 +void cx_free_testing(void *d, void *mem) {
1.79 + auto data = reinterpret_cast<CxTestingAllocator *>(d);
1.80 + data->free_total++;
1.81 + if (data->tracked.erase(mem) == 0) {
1.82 + data->free_failed++;
1.83 + // do not even attempt to free mem, because it is likely to segfault
1.84 + } else {
1.85 + free(mem);
1.86 + }
1.87 +}
1.88 +
1.89 +cx_allocator_class cx_testing_allocator_class = {
1.90 + cx_malloc_testing,
1.91 + cx_realloc_testing,
1.92 + cx_calloc_testing,
1.93 + cx_free_testing
1.94 +};
1.95 +
1.96 +CxTestingAllocator::CxTestingAllocator() : CxAllocator() {
1.97 + cl = &cx_testing_allocator_class;
1.98 + data = this;
1.99 +}
1.100 +
1.101 +bool CxTestingAllocator::used() const {
1.102 + return alloc_total > 0;
1.103 +}
1.104 +
1.105 +bool CxTestingAllocator::verify() const {
1.106 + return tracked.empty() && alloc_failed == 0 && free_failed == 0 && alloc_total == free_total;
1.107 +}
1.108 +
1.109 +// SELF-TEST
1.110 +
1.111 +#include <gtest/gtest.h>
1.112 +
1.113 +TEST(TestingAllocator, ExpectFree) {
1.114 + CxTestingAllocator allocator;
1.115 +
1.116 + ASSERT_TRUE(allocator.verify());
1.117 + EXPECT_FALSE(allocator.used());
1.118 + auto ptr = cxMalloc(&allocator, 16);
1.119 + EXPECT_TRUE(allocator.used());
1.120 + ASSERT_NE(ptr, nullptr);
1.121 + EXPECT_FALSE(allocator.verify());
1.122 +
1.123 + cxFree(&allocator, ptr);
1.124 + EXPECT_TRUE(allocator.verify());
1.125 +}
1.126 +
1.127 +TEST(TestingAllocator, DetectDoubleFree) {
1.128 + CxTestingAllocator allocator;
1.129 +
1.130 + ASSERT_TRUE(allocator.verify());
1.131 + auto ptr = cxMalloc(&allocator, 16);
1.132 + ASSERT_NE(ptr, nullptr);
1.133 +
1.134 + cxFree(&allocator, ptr);
1.135 + EXPECT_TRUE(allocator.verify());
1.136 + ASSERT_NO_FATAL_FAILURE(cxFree(&allocator, ptr));
1.137 + EXPECT_FALSE(allocator.verify());
1.138 +}
1.139 +
1.140 +TEST(TestingAllocator, FreeUntracked) {
1.141 + CxTestingAllocator allocator;
1.142 +
1.143 + auto ptr = malloc(16);
1.144 + ASSERT_TRUE(allocator.verify());
1.145 + ASSERT_NO_FATAL_FAILURE(cxFree(&allocator, ptr));
1.146 + EXPECT_FALSE(allocator.verify());
1.147 + ASSERT_NO_FATAL_FAILURE(free(ptr));
1.148 +}
1.149 +
1.150 +TEST(TestingAllocator, FullLifecycleWithRealloc) {
1.151 + CxTestingAllocator allocator;
1.152 + ASSERT_TRUE(allocator.verify());
1.153 + auto ptr = cxMalloc(&allocator, 16);
1.154 + ASSERT_NE(ptr, nullptr);
1.155 + EXPECT_EQ(allocator.tracked.size(), 1);
1.156 + ptr = cxRealloc(&allocator, ptr, 256);
1.157 + ASSERT_NE(ptr, nullptr);
1.158 + EXPECT_EQ(allocator.tracked.size(), 1);
1.159 + cxFree(&allocator, ptr);
1.160 + EXPECT_TRUE(allocator.verify());
1.161 +}
1.162 +
1.163 +TEST(TestingAllocator, CallocInitializes) {
1.164 + CxTestingAllocator allocator;
1.165 + const char zeros[16] = {0};
1.166 + auto ptr = cxCalloc(&allocator, 16, 1);
1.167 + EXPECT_EQ(memcmp(ptr, zeros, 16), 0);
1.168 + cxFree(&allocator, ptr);
1.169 + EXPECT_TRUE(allocator.verify());
1.170 +}
