blob: 6b1b3a82364ccf54a206585ac0a6b12a4de07c98 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
//
// Copyright (C) 2007-2023 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <exception>
#include <stdexcept>
#include <cstdlib>
#include <cstdio>
#include <testsuite_hooks.h>
namespace __gnu_test
{
struct counter_error : public std::exception { };
struct counter
{
std::size_t _M_count;
std::size_t _M_increments, _M_decrements;
bool _M_throw;
counter() : _M_count(0), _M_throw(true) { }
~counter() THROW (counter_error)
{
if (_M_throw && _M_count != 0)
throw counter_error();
}
static void
increment()
{
counter& cntr = get();
cntr._M_count++;
cntr._M_increments++;
}
static void
decrement()
{
counter& cntr = get();
cntr._M_count--;
cntr._M_decrements++;
}
static counter&
get()
{
static counter g;
return g;
}
static std::size_t
count() { return get()._M_count; }
static void
exceptions(bool __b) { get()._M_throw = __b; }
static void
reset()
{
counter& cntr = get();
cntr._M_increments = cntr._M_decrements = 0;
}
};
template<typename Alloc, bool uses_global_new>
bool
check_new(Alloc a = Alloc())
{
__gnu_test::counter::exceptions(false);
(void) a.allocate(10);
const bool __b((__gnu_test::counter::count() > 0) == uses_global_new);
if (!__b)
throw std::logic_error("counter not incremented");
return __b;
}
template<typename Alloc, bool uses_global_delete>
bool
check_delete(Alloc a = Alloc())
{
__gnu_test::counter::exceptions(false);
#if __cplusplus >= 201103L
auto p = a.allocate(10);
#else
typename Alloc::pointer p = a.allocate(10);
#endif
const std::size_t count1 = __gnu_test::counter::count();
a.deallocate(p, 10);
const std::size_t count2 = __gnu_test::counter::count();
const bool __b((count2 < count1) == uses_global_delete);
if (!__b)
throw std::logic_error("counter not decremented");
return __b;
}
} // namespace __gnu_test
void* operator new(std::size_t size) THROW(std::bad_alloc)
{
std::printf("operator new is called \n");
void* p = std::malloc(size);
if (!p)
throw std::bad_alloc();
__gnu_test::counter::increment();
return p;
}
void operator delete(void* p) throw()
{
std::printf("operator delete is called \n");
if (p)
{
std::free(p);
__gnu_test::counter::decrement();
std::size_t count = __gnu_test::counter::count();
if (count == 0)
std::printf("All memory released \n");
else
std::printf("%lu allocations to be released \n", (unsigned long)count);
}
}
#if __cpp_sized_deallocation
void operator delete(void* p, std::size_t) throw() { ::operator delete(p); }
#endif
|
