1.1 --- a/test/util_allocator.cpp Tue Feb 07 21:53:06 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 -}