boostorg/unordered
1
0
Fork 1
mirror of https://github.com/boostorg/unordered.git synced 2025-07-30 19:37:14 +02:00
Code Issues Packages Projects Releases Wiki Activity

Improved support for testing on older versions of gcc.

Browse Source 
Link tests.
Plus more...


[SVN r2980]
This commit is contained in:
Daniel James
2006-06-11 19:42:55 +00:00
parent 653a58f39b
commit 58dda15273
11 changed files with 222 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
doc/intro.qbk
View File

@ -1,4 +1,5 @@
[def __tr1__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2009.pdf
[def __tr1__
[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2009.pdf
C++ Standard Library Technical Report]]
[def __draft__
[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2009.pdf

1
test/container/Jamfile.v2
View File

@ -15,4 +15,5 @@ test-suite container-tests
[ run set_compile.cpp ]
[ run map_compile.cpp ]
[ run simple_tests.cpp ]
[ run link_test_1.cpp link_test_2.cpp ]
;

22
test/container/link_test_1.cpp Normal file
View File

@ -0,0 +1,22 @@
// Copyright Daniel James 2006. Use, modification, and distribution are
// subject to the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/unordered_set.hpp>
#include <boost/unordered_map.hpp>
void foo(boost::unordered_set<int>&,
boost::unordered_map<int, int>&,
boost::unordered_multiset<int>&,
boost::unordered_multimap<int, int>&);
int main()
{
boost::unordered_set<int> x1;
boost::unordered_map<int, int> x2;
boost::unordered_multiset<int> x3;
boost::unordered_multimap<int, int> x4;
foo(x1, x2, x3, x4);
}

18
test/container/link_test_2.cpp Normal file
View File

@ -0,0 +1,18 @@
// Copyright Daniel James 2006. Use, modification, and distribution are
// subject to the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/unordered_set.hpp>
#include <boost/unordered_map.hpp>
void foo(boost::unordered_set<int>& x1,
boost::unordered_map<int, int>& x2,
boost::unordered_multiset<int>& x3,
boost::unordered_multimap<int, int>& x4)
{
x1.insert(1);
x2[2] = 2;
x3.insert(3);
x4.insert(std::make_pair(4, 5));
}

10
test/exception/containers.hpp
View File

@ -6,23 +6,23 @@ typedef boost::unordered_set<
test::exception::object,
test::exception::hash,
test::exception::equal_to,
test::exception::allocator<test::exception::object> > set;
test::exception::allocator<test::exception::object> > test_set;
typedef boost::unordered_multiset<
test::exception::object,
test::exception::hash,
test::exception::equal_to,
test::exception::allocator<test::exception::object> > multiset;
test::exception::allocator<test::exception::object> > test_multiset;
typedef boost::unordered_map<
test::exception::object,
test::exception::object,
test::exception::hash,
test::exception::equal_to,
test::exception::allocator<test::exception::object> > map;
test::exception::allocator<test::exception::object> > test_map;
typedef boost::unordered_multimap<
test::exception::object,
test::exception::object,
test::exception::hash,
test::exception::equal_to,
test::exception::allocator<test::exception::object> > multimap;
test::exception::allocator<test::exception::object> > test_multimap;
#define CONTAINER_SEQ (set)(multiset)(map)(multimap)
#define CONTAINER_SEQ (test_set)(test_multiset)(test_map)(test_multimap)

4
test/helpers/equivalent.hpp
View File

@ -14,8 +14,8 @@
namespace test
{
template <class T>
bool equivalent_impl(T const& x, T const& y) {
template <class T1, class T2>
bool equivalent_impl(T1 const& x, T2 const& y) {
return x == y;
}

2
test/helpers/fwd.hpp
View File

@ -6,6 +6,8 @@
#if !defined(BOOST_UNORDERED_TEST_HELPERS_FWD_HEADER)
#define BOOST_UNORDERED_TEST_HELPERS_FWD_HEADER
#include <string>
namespace test
{
int generate(int const*);

12
test/helpers/generators.hpp
View File

@ -36,15 +36,19 @@ namespace test
inline int generate(int const*)
{
integer_generator_type gen;
boost::uniform_int<> dist(0, 1000);
static boost::variate_generator<integer_generator_type, boost::uniform_int<> >
vg((integer_generator_type()), boost::uniform_int<>(0, 1000));
vg(gen, dist);
return vg();
}
inline char generate(char const*)
{
integer_generator_type gen;
boost::uniform_int<char> dist(32, 128);
static boost::variate_generator<integer_generator_type, boost::uniform_int<char> >
vg((integer_generator_type()), boost::uniform_int<char>(32, 128));
vg(gen, dist);
return vg();
}
@ -70,8 +74,10 @@ namespace test
float generate(float const*)
{
real_generator_type gen;
boost::uniform_real<float> dist;
static boost::variate_generator<real_generator_type, boost::uniform_real<float> >
vg((real_generator_type()), boost::uniform_real<float>());
vg(gen, dist);
return vg();
}

2
test/helpers/invariants.hpp
View File

@ -80,7 +80,7 @@ namespace test
// Finally, check that size matches up.
if(x1.size() != size)
BOOST_ERROR("x1.size() doesn't match actual size.");
if(static_cast<float>(size) / x1.bucket_count() != x1.load_factor())
if(static_cast<float>(size) / static_cast<float>(x1.bucket_count()) != x1.load_factor())
BOOST_ERROR("x1.load_factor() doesn't match actual load_factor.");
}
}

7
test/helpers/tracker.hpp
View File

@ -19,6 +19,7 @@
#include "../objects/fwd.hpp"
#include "./metafunctions.hpp"
#include "./helpers.hpp"
#include "./equivalent.hpp"
namespace test
{
@ -45,7 +46,8 @@ namespace test
std::copy(x2.begin(), x2.end(), std::back_inserter(values2));
std::sort(values1.begin(), values1.end());
std::sort(values2.begin(), values2.end());
BOOST_TEST(values1 == values2);
BOOST_TEST(values1.size() == values2.size() &&
std::equal(values1.begin(), values1.end(), values2.begin(), test::equivalent));
}
template <class X1, class X2, class T>
@ -58,7 +60,8 @@ namespace test
std::copy(x2.first, x2.second, std::back_inserter(values2));
std::sort(values1.begin(), values1.end());
std::sort(values2.begin(), values2.end());
BOOST_TEST(values1 == values2);
BOOST_TEST(values1.size() == values2.size() &&
std::equal(values1.begin(), values1.end(), values2.begin(), test::equivalent));
}
template <class X>

164
test/objects/test.hpp
View File

@ -6,9 +6,12 @@
#if !defined(BOOST_UNORDERED_TEST_OBJECTS_HEADER)
#define BOOST_UNORDERED_TEST_OBJECTS_HEADER
#include <boost/config.hpp>
#include <boost/limits.hpp>
#include <cstddef>
#include "../helpers/fwd.hpp"
#include <ostream>
#include <iostream>
#include <map>
namespace test
{
@ -144,6 +147,136 @@ namespace test
}
};
namespace detail
{
namespace {
struct memory_area {
void const* start;
void const* end;
memory_area(void const* s, void const* e)
: start(s), end(e)
{
}
// This is a bit dodgy as it defines overlapping
// areas as 'equal', so this isn't a total ordering.
// But it is for non-overlapping memory regions - which
// is what'll be stored.
//
// All searches will be for areas entirely contained by
// a member of the set - so it should find the area that contains
// the region that is searched for.
bool operator<(memory_area const& other) const {
return end < other.start;
}
};
struct memory_track {
explicit memory_track(int tag = -1) :
constructed_(0),
tag_(tag) {}
int constructed_;
int tag_;
};
std::map<memory_area, memory_track> allocated_memory;
unsigned int count_allocators = 0;
unsigned int count_allocations = 0;
unsigned int count_constructions = 0;
}
void allocator_ref()
{
if(count_allocators == 0) {
count_allocations = 0;
count_constructions = 0;
allocated_memory.clear();
}
++count_allocators;
}
void allocator_unref()
{
BOOST_TEST(count_allocators > 0);
if(count_allocators > 0) {
--count_allocators;
if(count_allocators == 0) {
bool no_allocations_left = (count_allocations == 0);
bool no_constructions_left = (count_constructions == 0);
bool allocated_memory_empty = allocated_memory.empty();
// Clearing the data before the checks terminate the tests.
count_allocations = 0;
count_constructions = 0;
allocated_memory.clear();
BOOST_TEST(no_allocations_left);
BOOST_TEST(no_constructions_left);
BOOST_TEST(allocated_memory_empty);
}
}
}
void track_allocate(void *ptr, std::size_t n, std::size_t size, int tag)
{
if(n == 0) {
// TODO: This is unspecified - not undefined, so what to do?
}
else {
++count_allocations;
allocated_memory[memory_area(ptr, (char*) ptr + n * size)] =
memory_track(tag);
}
}
void track_deallocate(void* ptr, std::size_t n, std::size_t size, int tag)
{
std::map<memory_area, memory_track>::iterator pos
= allocated_memory.find(memory_area(ptr, ptr));
if(pos == allocated_memory.end()) {
BOOST_ERROR("Deallocating unknown pointer.");
} else {
// TODO: Not exception safe.
BOOST_TEST(pos->first.start == ptr);
BOOST_TEST(pos->first.end == (char*) ptr + n * size);
BOOST_TEST(pos->second.tag_ == tag);
BOOST_TEST(pos->second.constructed_ == 0);
allocated_memory.erase(pos);
}
BOOST_TEST(count_allocations > 0);
if(count_allocations > 0) --count_allocations;
}
void track_construct(void* ptr, std::size_t size, int tag)
{
std::map<memory_area, memory_track>::iterator pos
= allocated_memory.find(memory_area(ptr, ptr));
if(pos == allocated_memory.end())
BOOST_ERROR("Constructing unknown pointer.");
BOOST_TEST(pos->second.tag_ == tag);
//TODO: Track the number of allocations, and make sure the number
// of constructions doesn't exceed it. If you're feeling keen,
// perhaps track the individual objects in the array.
++count_constructions;
++pos->second.constructed_;
}
void track_destroy(void* ptr, std::size_t size, int tag)
{
std::map<memory_area, memory_track>::iterator pos
= allocated_memory.find(memory_area(ptr, ptr));
if(pos == allocated_memory.end())
BOOST_ERROR("Destroying unknown pointer.");
BOOST_TEST(count_constructions > 0);
BOOST_TEST(pos->second.tag_ == tag);
BOOST_TEST(pos->second.constructed_ > 0);
if(count_constructions > 0) --count_constructions;
if(pos->second.constructed_ > 0) --pos->second.constructed_;
}
}
template <class T>
class allocator
{
@ -164,30 +297,43 @@ namespace test
template <class U> struct rebind { typedef allocator<U> other; };
explicit allocator(int t = 0) : tag_(t) {}
template <class Y> allocator(allocator<Y> const& x) : tag_(x.tag_) {}
allocator(allocator const& x) : tag_(x.tag_) {}
~allocator() {}
explicit allocator(int t = 0) : tag_(t) { detail::allocator_ref(); }
template <class Y> allocator(allocator<Y> const& x) : tag_(x.tag_) { detail::allocator_ref(); }
allocator(allocator const& x) : tag_(x.tag_) { detail::allocator_ref(); }
~allocator() { detail::allocator_unref(); }
// TODO: Shall I check these?
pointer address(reference r) { return pointer(&r); }
const_pointer address(const_reference r) { return const_pointer(&r); }
pointer allocate(size_type n) {
return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
detail::track_allocate((void*) ptr, n, sizeof(T), tag_);
return ptr;
}
pointer allocate(size_type n, const_pointer u)
{
return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
detail::track_allocate((void*) ptr, n, sizeof(T), tag_);
return ptr;
}
void deallocate(pointer p, size_type n)
{
detail::track_deallocate((void*) p, n, sizeof(T), tag_);
::operator delete((void*) p);
}
void construct(pointer p, T const& t) { new(p) T(t); }
void destroy(pointer p) { p->~T(); }
void construct(pointer p, T const& t) {
detail::track_construct((void*) p, sizeof(T), tag_);
new(p) T(t);
}
void destroy(pointer p) {
detail::track_destroy((void*) p, sizeof(T), tag_);
p->~T();
}
size_type max_size() const {
return (std::numeric_limits<size_type>::max)();