boostorg/unordered
1
0
Fork 1
mirror of https://github.com/boostorg/unordered.git synced 2025-07-31 11:57:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge in support for equality operators for the unordered containers and

Browse Source 
hopefully better cross-platform support.

Merged revisions 44778-44835,44837-44918 via svnmerge from 
https://svn.boost.org/svn/boost/branches/unordered/trunk

........
  r44778 | danieljames | 2008-04-26 17:15:44 +0100 (Sat, 26 Apr 2008) | 2 lines
  
  Remove a trailing comma.
........
  r44779 | danieljames | 2008-04-26 17:23:51 +0100 (Sat, 26 Apr 2008) | 1 line
  
  Merge in support for equality operators.
........
  r44780 | danieljames | 2008-04-26 17:28:44 +0100 (Sat, 26 Apr 2008) | 1 line
  
  Use my own list container to avoid working around STL container bugs.
........
  r44833 | danieljames | 2008-04-28 08:03:43 +0100 (Mon, 28 Apr 2008) | 1 line
  
  Better equality tests.
........
  r44834 | danieljames | 2008-04-28 08:04:03 +0100 (Mon, 28 Apr 2008) | 1 line
  
  Remove a superfluous check.
........
  r44835 | danieljames | 2008-04-28 08:04:21 +0100 (Mon, 28 Apr 2008) | 1 line
  
  Add equality reference documentation.
........
  r44916 | danieljames | 2008-04-30 08:16:52 +0100 (Wed, 30 Apr 2008) | 1 line
  
  New version of list.hpp
........
  r44917 | danieljames | 2008-04-30 08:18:31 +0100 (Wed, 30 Apr 2008) | 1 line
  
  Support compilers without ADL in the compile tests.
........
  r44918 | danieljames | 2008-04-30 08:25:20 +0100 (Wed, 30 Apr 2008) | 7 lines
  
  Change the typedef of buffered functions as it was confusing MSVC 6.5
  
  get_allocator wasn't compiling when the allocator workaround is used because it
  couldn't cast from the wrapped allocator to an allocator of another type. So
  use value_alloc_ when it's available (it's only unavailable on compilers with
  C++0x support, which don't require the workaround).
........


[SVN r44919]
This commit is contained in:
Daniel James
2008-04-30 07:57:04 +00:00
parent 94932ae026
commit b5db48b6a4
21 changed files with 745 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

272
doc/ref.xml
View File

@ -657,6 +657,71 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
</throws> </throws>
</method> </method>
</method-group> </method-group>
<free-function-group name="Equality Comparisons">
<function name="operator==">
<template>
<template-type-parameter name="Value">
</template-type-parameter>
<template-type-parameter name="Hash">
</template-type-parameter>
<template-type-parameter name="Pred">
</template-type-parameter>
<template-type-parameter name="Alloc">
</template-type-parameter>
</template>
<parameter name="x">
<paramtype>unordered_set&lt;Value, Hash, Pred, Alloc&gt; const&amp;</paramtype>
</parameter>
<parameter name="y">
<paramtype>unordered_set&lt;Value, Hash, Pred, Alloc&gt; const&amp;</paramtype>
</parameter>
<type>bool</type>
<notes>
<para>This is a boost extension.</para>
</notes>
</function>
<function name="operator!=">
<template>
<template-type-parameter name="Value">
</template-type-parameter>
<template-type-parameter name="Hash">
</template-type-parameter>
<template-type-parameter name="Pred">
</template-type-parameter>
<template-type-parameter name="Alloc">
</template-type-parameter>
</template>
<parameter name="x">
<paramtype>unordered_set&lt;Value, Hash, Pred, Alloc&gt; const&amp;</paramtype>
</parameter>
<parameter name="y">
<paramtype>unordered_set&lt;Value, Hash, Pred, Alloc&gt; const&amp;</paramtype>
</parameter>
<type>bool</type>
<notes>
<para>This is a boost extension.</para>
</notes>
</function>
<function name="hash_value">
<template>
<template-type-parameter name="Value">
</template-type-parameter>
<template-type-parameter name="Hash">
</template-type-parameter>
<template-type-parameter name="Pred">
</template-type-parameter>
<template-type-parameter name="Alloc">
</template-type-parameter>
</template>
<parameter name="x">
<paramtype>unordered_set&lt;Value, Hash, Pred, Alloc&gt; const&amp;</paramtype>
</parameter>
<type>std::size_t</type>
<notes>
<para>This is a boost extension.</para>
</notes>
</function>
</free-function-group>
<free-function-group name="swap"> <free-function-group name="swap">
<function name="swap"> <function name="swap">
<template> <template>
@ -1339,6 +1404,71 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
</throws> </throws>
</method> </method>
</method-group> </method-group>
<free-function-group name="Equality Comparisons">
<function name="operator==">
<template>
<template-type-parameter name="Value">
</template-type-parameter>
<template-type-parameter name="Hash">
</template-type-parameter>
<template-type-parameter name="Pred">
</template-type-parameter>
<template-type-parameter name="Alloc">
</template-type-parameter>
</template>
<parameter name="x">
<paramtype>unordered_multiset&lt;Value, Hash, Pred, Alloc&gt; const&amp;</paramtype>
</parameter>
<parameter name="y">
<paramtype>unordered_multiset&lt;Value, Hash, Pred, Alloc&gt; const&amp;</paramtype>
</parameter>
<type>bool</type>
<notes>
<para>This is a boost extension.</para>
</notes>
</function>
<function name="operator!=">
<template>
<template-type-parameter name="Value">
</template-type-parameter>
<template-type-parameter name="Hash">
</template-type-parameter>
<template-type-parameter name="Pred">
</template-type-parameter>
<template-type-parameter name="Alloc">
</template-type-parameter>
</template>
<parameter name="x">
<paramtype>unordered_multiset&lt;Value, Hash, Pred, Alloc&gt; const&amp;</paramtype>
</parameter>
<parameter name="y">
<paramtype>unordered_multiset&lt;Value, Hash, Pred, Alloc&gt; const&amp;</paramtype>
</parameter>
<type>bool</type>
<notes>
<para>This is a boost extension.</para>
</notes>
</function>
<function name="hash_value">
<template>
<template-type-parameter name="Value">
</template-type-parameter>
<template-type-parameter name="Hash">
</template-type-parameter>
<template-type-parameter name="Pred">
</template-type-parameter>
<template-type-parameter name="Alloc">
</template-type-parameter>
</template>
<parameter name="x">
<paramtype>unordered_multiset&lt;Value, Hash, Pred, Alloc&gt; const&amp;</paramtype>
</parameter>
<type>std::size_t</type>
<notes>
<para>This is a boost extension.</para>
</notes>
</function>
</free-function-group>
<free-function-group name="swap"> <free-function-group name="swap">
<function name="swap"> <function name="swap">
<template> <template>
@ -2070,6 +2200,77 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
</throws> </throws>
</method> </method>
</method-group> </method-group>
<free-function-group name="Equality Comparisons">
<function name="operator==">
<template>
<template-type-parameter name="Key">
</template-type-parameter>
<template-type-parameter name="Mapped">
</template-type-parameter>
<template-type-parameter name="Hash">
</template-type-parameter>
<template-type-parameter name="Pred">
</template-type-parameter>
<template-type-parameter name="Alloc">
</template-type-parameter>
</template>
<parameter name="x">
<paramtype>unordered_map&lt;Key, Mapped, Hash, Pred, Alloc&gt; const&amp;</paramtype>
</parameter>
<parameter name="y">
<paramtype>unordered_map&lt;Key, Mapped, Hash, Pred, Alloc&gt; const&amp;</paramtype>
</parameter>
<type>bool</type>
<notes>
<para>This is a boost extension.</para>
</notes>
</function>
<function name="operator!=">
<template>
<template-type-parameter name="Key">
</template-type-parameter>
<template-type-parameter name="Mapped">
</template-type-parameter>
<template-type-parameter name="Hash">
</template-type-parameter>
<template-type-parameter name="Pred">
</template-type-parameter>
<template-type-parameter name="Alloc">
</template-type-parameter>
</template>
<parameter name="x">
<paramtype>unordered_map&lt;Key, Mapped, Hash, Pred, Alloc&gt; const&amp;</paramtype>
</parameter>
<parameter name="y">
<paramtype>unordered_map&lt;Key, Mapped, Hash, Pred, Alloc&gt; const&amp;</paramtype>
</parameter>
<type>bool</type>
<notes>
<para>This is a boost extension.</para>
</notes>
</function>
<function name="hash_value">
<template>
<template-type-parameter name="Key">
</template-type-parameter>
<template-type-parameter name="Mapped">
</template-type-parameter>
<template-type-parameter name="Hash">
</template-type-parameter>
<template-type-parameter name="Pred">
</template-type-parameter>
<template-type-parameter name="Alloc">
</template-type-parameter>
</template>
<parameter name="x">
<paramtype>unordered_map&lt;Key, Mapped, Hash, Pred, Alloc&gt; const&amp;</paramtype>
</parameter>
<type>std::size_t</type>
<notes>
<para>This is a boost extension.</para>
</notes>
</function>
</free-function-group>
<free-function-group name="swap"> <free-function-group name="swap">
<function name="swap"> <function name="swap">
<template> <template>
@ -2762,6 +2963,77 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
</throws> </throws>
</method> </method>
</method-group> </method-group>
<free-function-group name="Equality Comparisons">
<function name="operator==">
<template>
<template-type-parameter name="Key">
</template-type-parameter>
<template-type-parameter name="Mapped">
</template-type-parameter>
<template-type-parameter name="Hash">
</template-type-parameter>
<template-type-parameter name="Pred">
</template-type-parameter>
<template-type-parameter name="Alloc">
</template-type-parameter>
</template>
<parameter name="x">
<paramtype>unordered_multimap&lt;Key, Mapped, Hash, Pred, Alloc&gt; const&amp;</paramtype>
</parameter>
<parameter name="y">
<paramtype>unordered_multimap&lt;Key, Mapped, Hash, Pred, Alloc&gt; const&amp;</paramtype>
</parameter>
<type>bool</type>
<notes>
<para>This is a boost extension.</para>
</notes>
</function>
<function name="operator!=">
<template>
<template-type-parameter name="Key">
</template-type-parameter>
<template-type-parameter name="Mapped">
</template-type-parameter>
<template-type-parameter name="Hash">
</template-type-parameter>
<template-type-parameter name="Pred">
</template-type-parameter>
<template-type-parameter name="Alloc">
</template-type-parameter>
</template>
<parameter name="x">
<paramtype>unordered_multimap&lt;Key, Mapped, Hash, Pred, Alloc&gt; const&amp;</paramtype>
</parameter>
<parameter name="y">
<paramtype>unordered_multimap&lt;Key, Mapped, Hash, Pred, Alloc&gt; const&amp;</paramtype>
</parameter>
<type>bool</type>
<notes>
<para>This is a boost extension.</para>
</notes>
</function>
<function name="hash_value">
<template>
<template-type-parameter name="Key">
</template-type-parameter>
<template-type-parameter name="Mapped">
</template-type-parameter>
<template-type-parameter name="Hash">
</template-type-parameter>
<template-type-parameter name="Pred">
</template-type-parameter>
<template-type-parameter name="Alloc">
</template-type-parameter>
</template>
<parameter name="x">
<paramtype>unordered_multimap&lt;Key, Mapped, Hash, Pred, Alloc&gt; const&amp;</paramtype>
</parameter>
<type>std::size_t</type>
<notes>
<para>This is a boost extension.</para>
</notes>
</function>
</free-function-group>
<free-function-group name="swap"> <free-function-group name="swap">
<function name="swap"> <function name="swap">
<template> <template>

109
include/boost/unordered/detail/hash_table_impl.hpp
View File

@ -1128,11 +1128,13 @@ namespace boost {
private: private:
typedef boost::unordered_detail::buffered_functions<Hash, Pred> buffered_functions; typedef boost::unordered_detail::buffered_functions<Hash, Pred>
typedef BOOST_DEDUCED_TYPENAME buffered_functions::functions functions; function_store;
typedef BOOST_DEDUCED_TYPENAME buffered_functions::functions_ptr functions_ptr; typedef BOOST_DEDUCED_TYPENAME function_store::functions functions;
typedef BOOST_DEDUCED_TYPENAME function_store::functions_ptr
functions_ptr;
buffered_functions functions_; function_store functions_;
float mlf_; float mlf_;
size_type max_load_; size_type max_load_;
@ -1376,10 +1378,17 @@ namespace boost {
// accessors // accessors
// no throw // no throw
#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
node_allocator get_allocator() const node_allocator get_allocator() const
{ {
return data_.allocators_.node_alloc_; return data_.allocators_.node_alloc_;
} }
#else
value_allocator get_allocator() const
{
return data_.allocators_.value_alloc_;
}
#endif
// no throw // no throw
hasher const& hash_function() const hasher const& hash_function() const
@ -2136,6 +2145,98 @@ namespace boost {
} }
} }
//
// equals
//
private:
#if BOOST_UNORDERED_EQUIVALENT_KEYS
static inline bool group_equals(link_ptr it1, link_ptr it2,
type_wrapper<key_type>*)
{
return data::group_count(it1) == data::group_count(it2);
}
static inline bool group_equals(link_ptr it1, link_ptr it2, void*)
{
link_ptr end1 = data::next_group(it1);
link_ptr end2 = data::next_group(it2);
do {
if(data::get_value(it1).second != data::get_value(it2).second) return false;
it1 = it1->next_;
it2 = it2->next_;
} while(it1 != end1 && it2 != end2);
return it1 == end1 && it2 == end2;
}
#else
static inline bool group_equals(link_ptr it1, link_ptr it2,
type_wrapper<key_type>*)
{
return true;
}
static inline bool group_equals(link_ptr it1, link_ptr it2, void*)
{
return data::get_value(it1).second == data::get_value(it2).second;
}
#endif
public:
bool equals(BOOST_UNORDERED_TABLE const& other) const
{
if(size() != other.size()) return false;
for(bucket_ptr i = data_.cached_begin_bucket_,
j = data_.buckets_end(); i != j; ++i)
{
for(link_ptr it(i->next_); BOOST_UNORDERED_BORLAND_BOOL(it); it = data::next_group(it))
{
link_ptr other_pos = other.find_iterator(other.extract_key(data::get_value(it)));
if(!BOOST_UNORDERED_BORLAND_BOOL(other_pos) ||
!group_equals(it, other_pos, (type_wrapper<value_type>*)0))
return false;
}
}
return true;
}
inline std::size_t group_hash(link_ptr it, type_wrapper<key_type>*) const
{
std::size_t seed = data::group_count(it);
std::size_t hashed_key = hash_function()(data::get_value(it));
boost::hash_combine(seed, hashed_key);
return seed;
}
inline std::size_t group_hash(link_ptr it, void*) const
{
std::size_t seed = hash_function()(data::get_value(it).first);
link_ptr end = data::next_group(it);
do {
boost::hash_combine(seed, data::get_value(it).second);
it = it->next_;
} while(it != end);
return seed;
}
std::size_t hash_value() const
{
std::size_t seed = 0;
for(bucket_ptr i = data_.cached_begin_bucket_,
j = data_.buckets_end(); i != j; ++i)
{
for(link_ptr it(i->next_); BOOST_UNORDERED_BORLAND_BOOL(it); it = data::next_group(it))
seed ^= group_hash(it, (type_wrapper<value_type>*)0);
}
return seed;
}
private: private:
// strong exception safety, no side effects // strong exception safety, no side effects

32
include/boost/unordered_map.hpp
View File

@ -18,8 +18,8 @@
#include <functional> #include <functional>
#include <memory> #include <memory>
#include <boost/unordered/detail/hash_table.hpp>
#include <boost/functional/hash.hpp> #include <boost/functional/hash.hpp>
#include <boost/unordered/detail/hash_table.hpp>
#if !defined(BOOST_HAS_RVALUE_REFS) #if !defined(BOOST_HAS_RVALUE_REFS)
#include <boost/unordered/detail/move.hpp> #include <boost/unordered/detail/move.hpp>
@ -387,6 +387,21 @@ namespace boost
{ {
base.rehash(n); base.rehash(n);
} }
friend bool operator==(unordered_map const& m1, unordered_map const& m2)
{
return m1.base.equals(m2.base);
}
friend bool operator!=(unordered_map const& m1, unordered_map const& m2)
{
return !m1.base.equals(m2.base);
}
friend std::size_t hash_value(unordered_map const& m)
{
return m.base.hash_value();
}
}; // class template unordered_map }; // class template unordered_map
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
@ -739,6 +754,21 @@ namespace boost
{ {
base.rehash(n); base.rehash(n);
} }
friend bool operator==(unordered_multimap const& m1, unordered_multimap const& m2)
{
return m1.base.equals(m2.base);
}
friend bool operator!=(unordered_multimap const& m1, unordered_multimap const& m2)
{
return !m1.base.equals(m2.base);
}
friend std::size_t hash_value(unordered_multimap const& m)
{
return m.base.hash_value();
}
}; // class template unordered_multimap }; // class template unordered_multimap
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>

32
include/boost/unordered_set.hpp
View File

@ -18,8 +18,8 @@
#include <functional> #include <functional>
#include <memory> #include <memory>
#include <boost/unordered/detail/hash_table.hpp>
#include <boost/functional/hash.hpp> #include <boost/functional/hash.hpp>
#include <boost/unordered/detail/hash_table.hpp>
#if !defined(BOOST_HAS_RVALUE_REFS) #if !defined(BOOST_HAS_RVALUE_REFS)
#include <boost/unordered/detail/move.hpp> #include <boost/unordered/detail/move.hpp>
@ -358,6 +358,21 @@ namespace boost
{ {
base.rehash(n); base.rehash(n);
} }
friend bool operator==(unordered_set const& m1, unordered_set const& m2)
{
return m1.base.equals(m2.base);
}
friend bool operator!=(unordered_set const& m1, unordered_set const& m2)
{
return !m1.base.equals(m2.base);
}
friend std::size_t hash_value(unordered_set const& m)
{
return m.base.hash_value();
}
}; // class template unordered_set }; // class template unordered_set
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
@ -695,6 +710,21 @@ namespace boost
{ {
base.rehash(n); base.rehash(n);
} }
friend bool operator==(unordered_multiset const& m1, unordered_multiset const& m2)
{
return m1.base.equals(m2.base);
}
friend bool operator!=(unordered_multiset const& m1, unordered_multiset const& m2)
{
return !m1.base.equals(m2.base);
}
friend std::size_t hash_value(unordered_multiset const& m)
{
return m.base.hash_value();
}
}; // class template unordered_multiset }; // class template unordered_multiset
template <class T, class H, class P, class A> template <class T, class H, class P, class A>

23
test/helpers/equivalent.hpp
View File

@ -8,10 +8,10 @@
#include <boost/unordered_map.hpp> #include <boost/unordered_map.hpp>
#include <boost/unordered_set.hpp> #include <boost/unordered_set.hpp>
#include <vector>
#include <algorithm> #include <algorithm>
#include "./metafunctions.hpp" #include "./metafunctions.hpp"
#include "./fwd.hpp" #include "./fwd.hpp"
#include "./list.hpp"
namespace test namespace test
{ {
@ -56,20 +56,17 @@ namespace test
BOOST_DEDUCED_TYPENAME Container::key_equal key_equal_; BOOST_DEDUCED_TYPENAME Container::key_equal key_equal_;
float max_load_factor_; float max_load_factor_;
typedef BOOST_DEDUCED_TYPENAME non_const_value_type<Container>::type value_type; typedef test::list<BOOST_DEDUCED_TYPENAME Container::value_type>
std::vector<value_type> values_; value_list;
value_list values_;
public: public:
unordered_equivalence_tester(Container const &x) unordered_equivalence_tester(Container const &x)
: size_(x.size()), : size_(x.size()),
hasher_(x.hash_function()), key_equal_(x.key_eq()), hasher_(x.hash_function()), key_equal_(x.key_eq()),
max_load_factor_(x.max_load_factor()), max_load_factor_(x.max_load_factor()),
values_() values_(x.begin(), x.end())
{ {
// Can't initialise values_ straight from x because of Visual C++ 6 values_.sort();
values_.reserve(x.size());
std::copy(x.begin(), x.end(), std::back_inserter(values_));
std::sort(values_.begin(), values_.end());
} }
bool operator()(Container const& x) const bool operator()(Container const& x) const
@ -80,11 +77,9 @@ namespace test
(max_load_factor_ == x.max_load_factor()) && (max_load_factor_ == x.max_load_factor()) &&
(values_.size() == x.size()))) return false; (values_.size() == x.size()))) return false;
std::vector<value_type> copy; value_list copy(x.begin(), x.end());
copy.reserve(x.size()); copy.sort();
std::copy(x.begin(), x.end(), std::back_inserter(copy)); return values_ == copy;
std::sort(copy.begin(), copy.end());
return(std::equal(values_.begin(), values_.end(), copy.begin()));
} }
private: private:
unordered_equivalence_tester(); unordered_equivalence_tester();

29
test/helpers/metafunctions.hpp
View File

@ -75,35 +75,6 @@ namespace test
sizeof(has_unique_key_impl((Container const*)0)) sizeof(has_unique_key_impl((Container const*)0))
== sizeof(no_type)); == sizeof(no_type));
}; };
// Non Const Value Type
template <bool IsMap>
struct non_const_value_type_impl
{
template <class Container>
struct apply {
typedef std::pair<
BOOST_DEDUCED_TYPENAME Container::key_type,
BOOST_DEDUCED_TYPENAME Container::mapped_type> type;
};
};
template<>
struct non_const_value_type_impl<false>
{
template <class Container>
struct apply {
typedef BOOST_DEDUCED_TYPENAME Container::value_type type;
};
};
template <class Container>
struct non_const_value_type
: non_const_value_type_impl< ::test::is_map<Container>::value>::
BOOST_NESTED_TEMPLATE apply<Container>
{
};
} }
#endif #endif

4
test/helpers/random_values.hpp
View File

@ -6,7 +6,7 @@
#if !defined(BOOST_UNORDERED_TEST_HELPERS_RANDOM_VALUES_HEADER) #if !defined(BOOST_UNORDERED_TEST_HELPERS_RANDOM_VALUES_HEADER)
#define BOOST_UNORDERED_TEST_HELPERS_RANDOM_VALUES_HEADER #define BOOST_UNORDERED_TEST_HELPERS_RANDOM_VALUES_HEADER
#include <list> #include "./list.hpp"
#include <algorithm> #include <algorithm>
#include <boost/mpl/if.hpp> #include <boost/mpl/if.hpp>
#include "./generators.hpp" #include "./generators.hpp"
@ -97,7 +97,7 @@ namespace test
template <class X> template <class X>
struct random_values struct random_values
: public std::list<BOOST_DEDUCED_TYPENAME X::value_type> : public test::list<BOOST_DEDUCED_TYPENAME X::value_type>
{ {
random_values(int count, test::random_generator const& generator = random_values(int count, test::random_generator const& generator =
test::default_generator) test::default_generator)

10
test/helpers/strong.hpp
View File

@ -7,10 +7,10 @@
#define BOOST_UNORDERED_TEST_HELPERS_STRONG_HEADER #define BOOST_UNORDERED_TEST_HELPERS_STRONG_HEADER
#include <boost/config.hpp> #include <boost/config.hpp>
#include <vector>
#include <iterator> #include <iterator>
#include "./metafunctions.hpp" #include "./metafunctions.hpp"
#include "./equivalent.hpp" #include "./equivalent.hpp"
#include "./list.hpp"
#include "../objects/exception.hpp" #include "../objects/exception.hpp"
namespace test namespace test
@ -18,19 +18,19 @@ namespace test
template <class X> template <class X>
class strong class strong
{ {
typedef std::vector<BOOST_DEDUCED_TYPENAME non_const_value_type<X>::type> values_type; typedef test::list<BOOST_DEDUCED_TYPENAME X::value_type> values_type;
values_type values_; values_type values_;
public: public:
void store(X const& x) { void store(X const& x) {
DISABLE_EXCEPTIONS; DISABLE_EXCEPTIONS;
values_.clear(); values_.clear();
values_.reserve(x.size()); values_.insert(x.cbegin(), x.cend());
std::copy(x.cbegin(), x.cend(), std::back_inserter(values_));
} }
void test(X const& x) const { void test(X const& x) const {
if(!(x.size() == values_.size() && if(!(x.size() == values_.size() &&
std::equal(x.cbegin(), x.cend(), values_.begin(), test::equivalent))) std::equal(x.cbegin(), x.cend(), values_.begin(),
test::equivalent)))
BOOST_ERROR("Strong exception safety failure."); BOOST_ERROR("Strong exception safety failure.");
} }
}; };

2
test/helpers/test.hpp
View File

@ -61,7 +61,7 @@ namespace test {
for(registered_test_base* i = first(); i; i = i->next) for(registered_test_base* i = first(); i; i = i->next)
i->run(); i->run();
} }
}; }
} }
#endif #endif

31
test/helpers/tracker.hpp
View File

@ -11,7 +11,6 @@
#include <set> #include <set>
#include <map> #include <map>
#include <vector>
#include <iterator> #include <iterator>
#include <algorithm> #include <algorithm>
#include <boost/mpl/if.hpp> #include <boost/mpl/if.hpp>
@ -22,6 +21,7 @@
#include "./metafunctions.hpp" #include "./metafunctions.hpp"
#include "./helpers.hpp" #include "./helpers.hpp"
#include "./equivalent.hpp" #include "./equivalent.hpp"
#include "./list.hpp"
namespace test namespace test
{ {
@ -44,27 +44,23 @@ namespace test
template <class X1, class X2> template <class X1, class X2>
void compare_range(X1 const& x1, X2 const& x2) void compare_range(X1 const& x1, X2 const& x2)
{ {
std::vector<BOOST_DEDUCED_TYPENAME non_const_value_type<X1>::type> values1, values2; typedef test::list<BOOST_DEDUCED_TYPENAME X1::value_type> value_list;
values1.reserve(x1.size()); value_list values1(x1.begin(), x1.end());
values2.reserve(x2.size()); value_list values2(x2.begin(), x2.end());
std::copy(x1.begin(), x1.end(), std::back_inserter(values1)); values1.sort();
std::copy(x2.begin(), x2.end(), std::back_inserter(values2)); values2.sort();
std::sort(values1.begin(), values1.end());
std::sort(values2.begin(), values2.end());
BOOST_CHECK(values1.size() == values2.size() && BOOST_CHECK(values1.size() == values2.size() &&
std::equal(values1.begin(), values1.end(), values2.begin(), test::equivalent)); std::equal(values1.begin(), values1.end(), values2.begin(),
test::equivalent));
} }
template <class X1, class X2, class T> template <class X1, class X2, class T>
void compare_pairs(X1 const& x1, X2 const& x2, T*) void compare_pairs(X1 const& x1, X2 const& x2, T*)
{ {
std::vector<T> values1, values2; test::list<T> values1(x1.first, x1.second);
values1.reserve(std::distance(x1.first, x1.second)); test::list<T> values2(x2.first, x2.second);
values2.reserve(std::distance(x2.first, x2.second)); values1.sort();
std::copy(x1.first, x1.second, std::back_inserter(values1)); values2.sort();
std::copy(x2.first, x2.second, std::back_inserter(values2));
std::sort(values1.begin(), values1.end());
std::sort(values2.begin(), values2.end());
BOOST_CHECK(values1.size() == values2.size() && BOOST_CHECK(values1.size() == values2.size() &&
std::equal(values1.begin(), values1.end(), values2.begin(), test::equivalent)); std::equal(values1.begin(), values1.end(), values2.begin(), test::equivalent));
} }
@ -123,8 +119,7 @@ namespace test
compare_pairs( compare_pairs(
x.equal_range(get_key<X>(val)), x.equal_range(get_key<X>(val)),
this->equal_range(get_key<X>(val)), this->equal_range(get_key<X>(val)),
(BOOST_DEDUCED_TYPENAME non_const_value_type<X>::type*) 0 (BOOST_DEDUCED_TYPENAME X::value_type*) 0);
);
} }
template <class It> template <class It>

36
test/objects/minimal.hpp
View File

@ -22,6 +22,7 @@ namespace test
namespace minimal namespace minimal
{ {
class copy_constructible; class copy_constructible;
class copy_constructible_equality_comparable;
class default_copy_constructible; class default_copy_constructible;
class assignable; class assignable;
@ -42,6 +43,25 @@ namespace minimal
copy_constructible() {} copy_constructible() {}
}; };
class copy_constructible_equality_comparable
{
public:
static copy_constructible_equality_comparable create() { return copy_constructible_equality_comparable(); }
copy_constructible_equality_comparable(copy_constructible_equality_comparable const&) {}
~copy_constructible_equality_comparable() {}
private:
copy_constructible_equality_comparable& operator=(copy_constructible_equality_comparable const&);
copy_constructible_equality_comparable() {}
};
bool operator==(copy_constructible_equality_comparable, copy_constructible_equality_comparable) {
return true;
}
bool operator!=(copy_constructible_equality_comparable, copy_constructible_equality_comparable) {
return false;
}
class default_copy_constructible class default_copy_constructible
{ {
public: public:
@ -246,6 +266,22 @@ namespace minimal
} }
} }
#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
namespace boost {
#else
namespace test {
namespace minimal {
#endif
std::size_t hash_value(test::minimal::copy_constructible_equality_comparable) {
return 1;
}
#if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
}}
#else
}
#endif
#if defined(BOOST_MSVC) #if defined(BOOST_MSVC)
#pragma warning(pop) #pragma warning(pop)
#endif #endif

1
test/unordered/Jamfile.v2
View File

@ -33,5 +33,6 @@ test-suite unordered
[ run bucket_tests.cpp ] [ run bucket_tests.cpp ]
[ run load_factor_tests.cpp ] [ run load_factor_tests.cpp ]
[ run rehash_tests.cpp ] [ run rehash_tests.cpp ]
[ run equality_tests.cpp ]
[ run swap_tests.cpp : : : <define>BOOST_UNORDERED_SWAP_METHOD=2 ] [ run swap_tests.cpp : : : <define>BOOST_UNORDERED_SWAP_METHOD=2 ]
; ;

37
test/unordered/compile_map.cpp
View File

@ -22,6 +22,9 @@ UNORDERED_AUTO_TEST(test0)
test::minimal::copy_constructible::create()); test::minimal::copy_constructible::create());
std::cout<<"Test unordered_map.\n"; std::cout<<"Test unordered_map.\n";
boost::unordered_map<int, int> int_map;
boost::unordered_map< boost::unordered_map<
test::minimal::assignable, test::minimal::assignable,
test::minimal::copy_constructible, test::minimal::copy_constructible,
@ -29,9 +32,13 @@ UNORDERED_AUTO_TEST(test0)
test::minimal::equal_to<test::minimal::assignable>, test::minimal::equal_to<test::minimal::assignable>,
test::minimal::allocator<value_type> > map; test::minimal::allocator<value_type> > map;
container_test(int_map, std::pair<int const, int>(0, 0));
container_test(map, value); container_test(map, value);
std::cout<<"Test unordered_multimap.\n"; std::cout<<"Test unordered_multimap.\n";
boost::unordered_multimap<int, int> int_multimap;
boost::unordered_multimap< boost::unordered_multimap<
test::minimal::assignable, test::minimal::assignable,
test::minimal::copy_constructible, test::minimal::copy_constructible,
@ -39,9 +46,39 @@ UNORDERED_AUTO_TEST(test0)
test::minimal::equal_to<test::minimal::assignable>, test::minimal::equal_to<test::minimal::assignable>,
test::minimal::allocator<value_type> > multimap; test::minimal::allocator<value_type> > multimap;
container_test(int_multimap, std::pair<int const, int>(0, 0));
container_test(multimap, value); container_test(multimap, value);
} }
UNORDERED_AUTO_TEST(equality_tests) {
typedef std::pair<test::minimal::assignable const,
test::minimal::copy_constructible> value_type;
boost::unordered_map<int, int> int_map;
boost::unordered_map<
test::minimal::assignable,
test::minimal::copy_constructible_equality_comparable,
test::minimal::hash<test::minimal::assignable>,
test::minimal::equal_to<test::minimal::assignable>,
test::minimal::allocator<value_type> > map;
equality_test(int_map);
equality_test(map);
boost::unordered_multimap<int, int> int_multimap;
boost::unordered_multimap<
test::minimal::assignable,
test::minimal::copy_constructible_equality_comparable,
test::minimal::hash<test::minimal::assignable>,
test::minimal::equal_to<test::minimal::assignable>,
test::minimal::allocator<value_type> > multimap;
equality_test(int_multimap);
equality_test(multimap);
}
UNORDERED_AUTO_TEST(test1) { UNORDERED_AUTO_TEST(test1) {
boost::hash<int> hash; boost::hash<int> hash;
std::equal_to<int> equal_to; std::equal_to<int> equal_to;

30
test/unordered/compile_set.cpp
View File

@ -18,24 +18,54 @@ UNORDERED_AUTO_TEST(test0)
test::minimal::assignable assignable = test::minimal::assignable::create(); test::minimal::assignable assignable = test::minimal::assignable::create();
std::cout<<"Test unordered_set.\n"; std::cout<<"Test unordered_set.\n";
boost::unordered_set<int> int_set;
boost::unordered_set< boost::unordered_set<
test::minimal::assignable, test::minimal::assignable,
test::minimal::hash<test::minimal::assignable>, test::minimal::hash<test::minimal::assignable>,
test::minimal::equal_to<test::minimal::assignable>, test::minimal::equal_to<test::minimal::assignable>,
test::minimal::allocator<test::minimal::assignable> > set; test::minimal::allocator<test::minimal::assignable> > set;
container_test(int_set, 0);
container_test(set, assignable); container_test(set, assignable);
std::cout<<"Test unordered_multiset.\n"; std::cout<<"Test unordered_multiset.\n";
boost::unordered_multiset<int> int_multiset;
boost::unordered_multiset< boost::unordered_multiset<
test::minimal::assignable, test::minimal::assignable,
test::minimal::hash<test::minimal::assignable>, test::minimal::hash<test::minimal::assignable>,
test::minimal::equal_to<test::minimal::assignable>, test::minimal::equal_to<test::minimal::assignable>,
test::minimal::allocator<test::minimal::assignable> > multiset; test::minimal::allocator<test::minimal::assignable> > multiset;
container_test(int_multiset, 0);
container_test(multiset, assignable); container_test(multiset, assignable);
} }
UNORDERED_AUTO_TEST(equality_tests) {
typedef test::minimal::assignable value_type;
boost::unordered_set<int> int_set;
boost::unordered_set<
test::minimal::assignable,
test::minimal::hash<test::minimal::assignable>,
test::minimal::equal_to<test::minimal::assignable>,
test::minimal::allocator<value_type> > set;
equality_test(int_set);
equality_test(set);
boost::unordered_multiset<int> int_multiset;
boost::unordered_multiset<
test::minimal::assignable,
test::minimal::hash<test::minimal::assignable>,
test::minimal::equal_to<test::minimal::assignable>,
test::minimal::allocator<value_type> > multiset;
equality_test(int_multiset);
equality_test(multiset);
}
UNORDERED_AUTO_TEST(test1) UNORDERED_AUTO_TEST(test1)
{ {
boost::hash<int> hash; boost::hash<int> hash;

18
test/unordered/compile_tests.hpp
View File

@ -28,7 +28,7 @@ template <class T> void sink(T const&) {}
template <class T> T rvalue(T const& v) { return v; } template <class T> T rvalue(T const& v) { return v; }
template <class X, class T> template <class X, class T>
void container_test(X& r, T&) void container_test(X& r, T const&)
{ {
typedef BOOST_DEDUCED_TYPENAME X::iterator iterator; typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator; typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
@ -121,8 +121,6 @@ void container_test(X& r, T&)
test::check_return_type<const_iterator>::equals(a.cend()); test::check_return_type<const_iterator>::equals(a.cend());
test::check_return_type<const_iterator>::equals(a_const.cend()); test::check_return_type<const_iterator>::equals(a_const.cend());
// No tests for ==, != since they're not required for unordered containers.
a.swap(b); a.swap(b);
test::check_return_type<X>::equals_ref(r = a); test::check_return_type<X>::equals_ref(r = a);
test::check_return_type<size_type>::equals(a.size()); test::check_return_type<size_type>::equals(a.size());
@ -161,6 +159,20 @@ void unordered_map_test(X& r, Key const& k, T const& v)
#endif #endif
} }
template <class X>
void equality_test(X& r)
{
X const a = r, b = r;
test::check_return_type<bool>::equals(a == b);
test::check_return_type<bool>::equals(a != b);
#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
test::check_return_type<std::size_t>::equals(boost::hash_value(a));
#else
test::check_return_type<std::size_t>::equals(hash_value(a));
#endif
}
template <class X, class T> template <class X, class T>
void unordered_unique_test(X& r, T const& t) void unordered_unique_test(X& r, T const& t)
{ {

6
test/unordered/constructor_tests.cpp
View File

@ -257,11 +257,9 @@ void map_constructor_test(T* = 0)
{ {
std::cerr<<"map_constructor_test\n"; std::cerr<<"map_constructor_test\n";
typedef std::list<std::pair<BOOST_DEDUCED_TYPENAME T::key_type, BOOST_DEDUCED_TYPENAME T::mapped_type> > list; typedef test::list<std::pair<BOOST_DEDUCED_TYPENAME T::key_type, BOOST_DEDUCED_TYPENAME T::mapped_type> > list;
test::random_values<T> v(1000); test::random_values<T> v(1000);
list l; list l(v.begin(), v.end());
std::copy(v.begin(), v.end(), std::back_inserter(l));
T x(l.begin(), l.end()); T x(l.begin(), l.end());
test::check_container(x, v); test::check_container(x, v);

143
test/unordered/equality_tests.cpp Normal file
View File

@ -0,0 +1,143 @@
// Copyright 2008 Daniel James.
// Distributed under 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>
#include <boost/preprocessor/seq.hpp>
#include <list>
#include "../helpers/test.hpp"
namespace equality_tests
{
struct mod_compare
{
bool operator()(int x, int y) const
{
return x % 1000 == y % 1000;
}
int operator()(int x) const
{
return x % 250;
}
};
#define UNORDERED_EQUALITY_SET_TEST(seq1, op, seq2) \
do { \
boost::unordered_set<int, mod_compare, mod_compare> set1, set2; \
BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1) \
BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2) \
BOOST_CHECK(set1 op set2); \
} while(false)
#define UNORDERED_EQUALITY_MULTISET_TEST(seq1, op, seq2) \
do { \
boost::unordered_multiset<int, mod_compare, mod_compare> set1, set2; \
BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1) \
BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2) \
BOOST_CHECK(set1 op set2); \
} while(false)
#define UNORDERED_EQUALITY_MAP_TEST(seq1, op, seq2) \
do { \
boost::unordered_map<int, int, mod_compare, mod_compare> map1, map2; \
BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1) \
BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2) \
BOOST_CHECK(map1 op map2); \
} while(false)
#define UNORDERED_EQUALITY_MULTIMAP_TEST(seq1, op, seq2) \
do { \
boost::unordered_multimap<int, int, mod_compare, mod_compare> map1, map2; \
BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1) \
BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2) \
BOOST_CHECK(map1 op map2); \
} while(false)
#define UNORDERED_SET_INSERT(r, set, item) set.insert(item);
#define UNORDERED_MAP_INSERT(r, map, item) \
map.insert(std::pair<int const, int> BOOST_PP_SEQ_TO_TUPLE(item));
UNORDERED_AUTO_TEST(equality_size_tests)
{
boost::unordered_set<int> x1, x2;
BOOST_CHECK(x1 == x2);
BOOST_CHECK(!(x1 != x2));
x1.insert(1);
BOOST_CHECK(x1 != x2);
BOOST_CHECK(!(x1 == x2));
BOOST_CHECK(x2 != x1);
BOOST_CHECK(!(x2 == x1));
x2.insert(1);
BOOST_CHECK(x1 == x2);
BOOST_CHECK(!(x1 != x2));
x2.insert(2);
BOOST_CHECK(x1 != x2);
BOOST_CHECK(!(x1 == x2));
BOOST_CHECK(x2 != x1);
BOOST_CHECK(!(x2 == x1));
}
UNORDERED_AUTO_TEST(equality_key_value_tests)
{
UNORDERED_EQUALITY_MULTISET_TEST((1), !=, (2));
UNORDERED_EQUALITY_SET_TEST((2), ==, (2));
UNORDERED_EQUALITY_MAP_TEST(((1)(1))((2)(1)), !=, ((1)(1))((3)(1)));
}
UNORDERED_AUTO_TEST(equality_collision_test)
{
UNORDERED_EQUALITY_MULTISET_TEST(
(1), !=, (501));
UNORDERED_EQUALITY_MULTISET_TEST(
(1)(251), !=, (1)(501));
UNORDERED_EQUALITY_MULTIMAP_TEST(
((251)(1))((1)(1)), !=, ((501)(1))((1)(1)));
UNORDERED_EQUALITY_MULTISET_TEST(
(1)(501), ==, (1)(501));
UNORDERED_EQUALITY_SET_TEST(
(1)(501), ==, (501)(1));
}
UNORDERED_AUTO_TEST(equality_group_size_test)
{
UNORDERED_EQUALITY_MULTISET_TEST(
(10)(20)(20), !=, (10)(10)(20));
UNORDERED_EQUALITY_MULTIMAP_TEST(
((10)(1))((20)(1))((20)(1)), !=,
((10)(1))((20)(1))((10)(1)));
UNORDERED_EQUALITY_MULTIMAP_TEST(
((20)(1))((10)(1))((10)(1)), ==,
((10)(1))((20)(1))((10)(1)));
}
UNORDERED_AUTO_TEST(equality_map_value_test)
{
UNORDERED_EQUALITY_MAP_TEST(
((1)(1)), !=, ((1)(2)));
UNORDERED_EQUALITY_MAP_TEST(
((1)(1)), ==, ((1)(1)));
UNORDERED_EQUALITY_MULTIMAP_TEST(
((1)(1)), !=, ((1)(2)));
UNORDERED_EQUALITY_MULTIMAP_TEST(
((1)(1))((1)(1)), !=, ((1)(1))((1)(2)));
UNORDERED_EQUALITY_MULTIMAP_TEST(
((1)(2))((1)(1)), !=, ((1)(1))((1)(2)));
}
UNORDERED_AUTO_TEST(equality_predicate_test)
{
UNORDERED_EQUALITY_SET_TEST(
(1), ==, (1001));
UNORDERED_EQUALITY_MAP_TEST(
((1)(2))((1001)(1)), ==, ((1001)(2))((1)(1)));
}
}
RUN_TESTS()

4
test/unordered/equivalent_keys_tests.cpp
View File

@ -8,7 +8,7 @@
#include "../helpers/test.hpp" #include "../helpers/test.hpp"
#include <algorithm> #include <algorithm>
#include <map> #include <map>
#include <list> #include "../helpers/list.hpp"
#include "../helpers/tracker.hpp" #include "../helpers/tracker.hpp"
#include "../helpers/invariants.hpp" #include "../helpers/invariants.hpp"
@ -57,7 +57,7 @@ UNORDERED_AUTO_TEST(set_tests)
UNORDERED_AUTO_TEST(map_tests) UNORDERED_AUTO_TEST(map_tests)
{ {
typedef std::list<std::pair<int const, int> > values_type; typedef test::list<std::pair<int const, int> > values_type;
values_type v[5]; values_type v[5];
v[0].push_back(std::pair<int const, int>(1,1)); v[0].push_back(std::pair<int const, int>(1,1));
v[1].push_back(std::pair<int const, int>(28,34)); v[1].push_back(std::pair<int const, int>(28,34));

16
test/unordered/erase_equiv_tests.cpp
View File

@ -8,7 +8,7 @@
#include <boost/unordered_map.hpp> #include <boost/unordered_map.hpp>
#include "../helpers/test.hpp" #include "../helpers/test.hpp"
#include <list> #include "../helpers/list.hpp"
#include <set> #include <set>
#include <iostream> #include <iostream>
#include <iterator> #include <iterator>
@ -50,7 +50,7 @@ typedef boost::unordered_multimap<int, int,
collision2_hash, std::equal_to<int>, collision2_hash, std::equal_to<int>,
test::allocator<std::pair<int const, int> > > collide_map2; test::allocator<std::pair<int const, int> > > collide_map2;
typedef collide_map::value_type collide_value; typedef collide_map::value_type collide_value;
typedef std::list<collide_value> collide_list; typedef test::list<collide_value> collide_list;
UNORDERED_AUTO_TEST(empty_range_tests) UNORDERED_AUTO_TEST(empty_range_tests)
{ {
@ -108,10 +108,8 @@ UNORDERED_AUTO_TEST(two_equivalent_item_tests)
template<class Range1, class Range2> template<class Range1, class Range2>
bool compare(Range1 const& x, Range2 const& y) bool compare(Range1 const& x, Range2 const& y)
{ {
collide_list a; collide_list a(x.begin(), x.end());
collide_list b; collide_list b(y.begin(), y.end());
std::copy(x.begin(), x.end(), std::back_inserter(a));
std::copy(y.begin(), y.end(), std::back_inserter(b));
a.sort(); a.sort();
b.sort(); b.sort();
return a == b; return a == b;
@ -120,8 +118,7 @@ bool compare(Range1 const& x, Range2 const& y)
template <class Container> template <class Container>
bool general_erase_range_test(Container& x, int start, int end) bool general_erase_range_test(Container& x, int start, int end)
{ {
collide_list l; collide_list l(x.begin(), x.end());
std::copy(x.begin(), x.end(), std::back_inserter(l));
l.erase(boost::next(l.begin(), start), boost::next(l.begin(), end)); l.erase(boost::next(l.begin(), start), boost::next(l.begin(), end));
x.erase(boost::next(x.begin(), start), boost::next(x.begin(), end)); x.erase(boost::next(x.begin(), start), boost::next(x.begin(), end));
return compare(l, x); return compare(l, x);
@ -133,8 +130,7 @@ void erase_subrange_tests(Container const& x)
for(std::size_t length = 0; length < x.size(); ++length) { for(std::size_t length = 0; length < x.size(); ++length) {
for(std::size_t position = 0; position < x.size() - length; ++position) { for(std::size_t position = 0; position < x.size() - length; ++position) {
Container y(x); Container y(x);
collide_list init; collide_list init(y.begin(), y.end());
std::copy(y.begin(), y.end(), std::back_inserter(init));
if(!general_erase_range_test(y, position, position + length)) { if(!general_erase_range_test(y, position, position + length)) {
BOOST_ERROR("general_erase_range_test failed."); BOOST_ERROR("general_erase_range_test failed.");
std::cout<<"Erase: ["<<position<<","<<position + length<<")\n"; std::cout<<"Erase: ["<<position<<","<<position + length<<")\n";

4
test/unordered/find_tests.cpp
View File

@ -43,10 +43,10 @@ void find_tests1(X*, test::random_generator generator = test::default_generator)
test::compare_pairs(x.equal_range(key), test::compare_pairs(x.equal_range(key),
tracker.equal_range(key), tracker.equal_range(key),
(BOOST_DEDUCED_TYPENAME test::non_const_value_type<X>::type*) 0); (BOOST_DEDUCED_TYPENAME X::value_type*) 0);
test::compare_pairs(x_const.equal_range(key), test::compare_pairs(x_const.equal_range(key),
tracker.equal_range(key), tracker.equal_range(key),
(BOOST_DEDUCED_TYPENAME test::non_const_value_type<X>::type*) 0); (BOOST_DEDUCED_TYPENAME X::value_type*) 0);
} }
test::random_values<X> v2(500, generator); test::random_values<X> v2(500, generator);

5
test/unordered/insert_tests.cpp
View File

@ -318,10 +318,9 @@ void associative_insert_range_test(X*, test::random_generator generator = test::
{ {
std::cerr<<"associative_insert_range_test\n"; std::cerr<<"associative_insert_range_test\n";
typedef std::list<std::pair<BOOST_DEDUCED_TYPENAME X::key_type, BOOST_DEDUCED_TYPENAME X::mapped_type> > list; typedef test::list<std::pair<BOOST_DEDUCED_TYPENAME X::key_type, BOOST_DEDUCED_TYPENAME X::mapped_type> > list;
test::random_values<X> v(1000, generator); test::random_values<X> v(1000, generator);
list l; list l(v.begin(), v.end());
std::copy(v.begin(), v.end(), std::back_inserter(l));
X x; x.insert(l.begin(), l.end()); X x; x.insert(l.begin(), l.end());