1.1 --- a/tests/util_allocator.cpp Wed Dec 27 14:54:04 2023 +0100
1.2 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000
1.3 @@ -1,167 +0,0 @@
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 -}
