testsuite_allocator.h [plain text]
#ifndef _GLIBCXX_TESTSUITE_ALLOCATOR_H
#define _GLIBCXX_TESTSUITE_ALLOCATOR_H
#include <cstddef>
#include <limits>
namespace
{
bool new_called = false;
bool delete_called = false;
};
namespace __gnu_test
{
class allocation_tracker
{
public:
typedef std::size_t size_type;
static void*
allocate(size_type blocksize)
{
allocationTotal_ += blocksize;
return ::operator new(blocksize);
}
static void
construct() { constructCount_++; }
static void
destroy() { destructCount_++; }
static void
deallocate(void* p, size_type blocksize)
{
::operator delete(p);
deallocationTotal_ += blocksize;
}
static size_type
allocationTotal() { return allocationTotal_; }
static size_type
deallocationTotal() { return deallocationTotal_; }
static int
constructCount() { return constructCount_; }
static int
destructCount() { return destructCount_; }
static void
resetCounts()
{
allocationTotal_ = 0;
deallocationTotal_ = 0;
constructCount_ = 0;
destructCount_ = 0;
}
private:
static size_type allocationTotal_;
static size_type deallocationTotal_;
static int constructCount_;
static int destructCount_;
};
template<class T>
class tracker_alloc
{
public:
typedef T value_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef T& reference;
typedef const T& const_reference;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
template<class U> struct rebind { typedef tracker_alloc<U> other; };
pointer
address(reference value) const
{ return &value; }
const_pointer
address(const_reference value) const
{ return &value; }
tracker_alloc() throw()
{ }
tracker_alloc(const tracker_alloc&) throw()
{ }
template<class U>
tracker_alloc(const tracker_alloc<U>&) throw()
{ }
~tracker_alloc() throw()
{ }
size_type
max_size() const throw()
{ return std::numeric_limits<std::size_t>::max() / sizeof(T); }
pointer
allocate(size_type n, const void* = 0)
{
return static_cast<pointer>(allocation_tracker::allocate(n * sizeof(T)));
}
void
construct(pointer p, const T& value)
{
new (p) T(value);
allocation_tracker::construct();
}
void
destroy(pointer p)
{
p->~T();
allocation_tracker::destroy();
}
void
deallocate(pointer p, size_type num)
{ allocation_tracker::deallocate(p, num * sizeof(T)); }
};
template<class T1, class T2>
bool
operator==(const tracker_alloc<T1>&, const tracker_alloc<T2>&) throw()
{ return true; }
template<class T1, class T2>
bool
operator!=(const tracker_alloc<T1>&, const tracker_alloc<T2>&) throw()
{ return false; }
bool
check_construct_destroy(const char* tag, int expected_c, int expected_d);
template<typename Alloc, bool uses_global_new>
bool
check_new(Alloc a = Alloc())
{
bool test __attribute__((unused)) = true;
typename Alloc::pointer p = a.allocate(10);
test &= ( new_called == uses_global_new );
return test;
}
template<typename Alloc, bool uses_global_delete>
bool
check_delete(Alloc a = Alloc())
{
bool test __attribute__((unused)) = true;
typename Alloc::pointer p = a.allocate(10);
a.deallocate(p, 10);
test &= ( delete_called == uses_global_delete );
return test;
}
template<typename Alloc>
bool
check_deallocate_null()
{
Alloc a;
a.deallocate(NULL, 1);
a.deallocate(NULL, 10);
}
template<typename Alloc>
bool
check_allocate_max_size()
{
Alloc a;
try
{
a.allocate(a.max_size() + 1);
}
catch(std::bad_alloc&)
{
return true;
}
catch(...)
{
throw;
}
throw;
}
};
#endif // _GLIBCXX_TESTSUITE_ALLOCATOR_H