feedc0de/boost_intrusive
1
0
Fork 0
forked from boostorg/intrusive
Code Pull Requests Activity

Changes to correct regression tests for intel-win-9.1 & cw-9.4

Browse Source 
[SVN r37675]
This commit is contained in:
Ion Gaztañaga
2007-05-12 12:34:55 +00:00
parent b039088719
commit 4c784f8c28
32 changed files with 861 additions and 1005 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
doc/intrusive.qbk
View File

@@ -2410,7 +2410,7 @@ helpful discussions.
* [*Jaap Suter] for the initial hint, which eventually leads to the member value_traits.
[*Ion Gaztañaga] would like to thank:
[*Ion Gaztanaga] would like to thank:
* [*Olaf Krzikalla] for the permission to continue his great work.

2
example/doc_advanced_value_traits.cpp
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007
// (C) Copyright Ion Gaztanaga 2006-2007
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at

2
example/doc_assoc_optimized_code.cpp
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007
// (C) Copyright Ion Gaztanaga 2006-2007
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at

2
example/doc_auto_unlink.cpp
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007
// (C) Copyright Ion Gaztanaga 2006-2007
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at

2
example/doc_clone_from.cpp
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007
// (C) Copyright Ion Gaztanaga 2006-2007
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at

2
example/doc_entity.cpp
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007
// (C) Copyright Ion Gaztanaga 2006-2007
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at

2
example/doc_erasing_and_destroying.cpp
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007
// (C) Copyright Ion Gaztanaga 2006-2007
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at

2
example/doc_how_to_use.cpp
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007
// (C) Copyright Ion Gaztanaga 2006-2007
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at

2
example/doc_iterator_from_value.cpp
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007
// (C) Copyright Ion Gaztanaga 2006-2007
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at

2
example/doc_list.cpp
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007
// (C) Copyright Ion Gaztanaga 2006-2007
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at

2
example/doc_list_algorithms.cpp
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007
// (C) Copyright Ion Gaztanaga 2006-2007
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at

2
example/doc_offset_ptr.cpp
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007
// (C) Copyright Ion Gaztanaga 2006-2007
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at

2
example/doc_rbtree_algorithms.cpp
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007
// (C) Copyright Ion Gaztanaga 2006-2007
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at

4
example/doc_set.cpp
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007
// (C) Copyright Ion Gaztanaga 2006-2007
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
@@ -34,6 +34,8 @@ class MyClass : public set_base_hook<>
{ return a.get() < b.get(); }
friend bool operator> (const MyClass &a, const MyClass &b)
{ return a.get() > b.get(); }
friend bool operator== (const MyClass &a, const MyClass &b)
{ return a.get() < b.get(); }
};
//Define an set that will store MyClass

2
example/doc_slist.cpp
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007
// (C) Copyright Ion Gaztanaga 2006-2007
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at

2
example/doc_slist_algorithms.cpp
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007
// (C) Copyright Ion Gaztanaga 2006-2007
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at

3
example/doc_unordered_set.cpp
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007
// (C) Copyright Ion Gaztanaga 2006-2007
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
@@ -107,4 +107,3 @@ int main()
return 0;
}
//]

2
example/doc_value_traits.cpp
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007
// (C) Copyright Ion Gaztanaga 2006-2007
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at

2
example/doc_window.cpp
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007
// (C) Copyright Ion Gaztanaga 2006-2007
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at

2
perf/perf_list.cpp
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2007
// (C) Copyright Ion Gaztanaga 2007
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at

5
proj/vc7ide/_intrusivelib/_intrusivelib.vcproj
View File

@@ -172,7 +172,7 @@
RelativePath="..\..\..\..\..\boost\intrusive\detail\hashtable_node.hpp">
</File>
<File
RelativePath="..\..\..\..\..\boost\intrusive\detail\pointed_node.hpp">
RelativePath="..\..\..\..\..\boost\intrusive\detail\list_node.hpp">
</File>
<File
RelativePath="..\..\..\..\..\boost\intrusive\detail\parent_from_member.hpp">
@@ -277,6 +277,9 @@
<File
RelativePath="..\..\..\example\doc_window.cpp">
</File>
<File
RelativePath="..\..\..\example\Jamfile.v2">
</File>
</Filter>
<Filter
Name="perf"

7
test/common_functors.hpp
View File

@@ -1,6 +1,6 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007
// (C) Copyright Ion Gaztanaga 2006-2007
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
@@ -13,6 +13,8 @@
#ifndef BOOST_INTRUSIVE_TEST_COMMON_FUNCTORS_HPP
#define BOOST_INTRUSIVE_TEST_COMMON_FUNCTORS_HPP
#include<boost/intrusive/detail/utilities.hpp>
namespace boost {
namespace intrusive {
namespace test {
@@ -23,8 +25,7 @@ public:
template <class Pointer>
void operator()(Pointer p)
{
using boost::get_pointer;
delete get_pointer(p);
delete detail::get_pointer(p);
}
};

203
test/itestvalue.hpp
View File

@@ -1,7 +1,7 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Olaf Krzikalla 2004-2006.
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007.
// (C) Copyright Ion Gaztanaga 2006-2007.
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
@@ -13,17 +13,11 @@
#ifndef BOOST_INTRUSIVE_ITESTVALUE
#define BOOST_INTRUSIVE_ITESTVALUE
#ifdef _MSC_VER
//#pragma warning(disable : 4584)
#endif
#include <iostream>
#include <boost/intrusive/set.hpp>
#include <boost/intrusive/list.hpp>
#include <boost/intrusive/slist.hpp>
#include <boost/intrusive/unordered_set.hpp>
#include <boost/intrusive/detail/pointer_to_other.hpp>
#include <boost/functional/hash.hpp>
#include <boost/intrusive/set_hook.hpp>
#include <boost/intrusive/list_hook.hpp>
#include <boost/intrusive/slist_hook.hpp>
#include <boost/intrusive/unordered_set_hook.hpp>
#include "smart_ptr.hpp"
namespace boost{
@@ -40,46 +34,39 @@ struct testvalue
, slist_base_hook<tag, safe_link, VoidPointer>
, slist_base_hook<tag, auto_unlink, VoidPointer>
{
typedef set_base_hook<tag, auto_unlink, VoidPointer> set_auto_base_hook;
typedef set_base_hook<tag, safe_link, VoidPointer>set_base_hook;
typedef set_member_hook<auto_unlink, VoidPointer> set_auto_member_hook;
typedef set_member_hook<safe_link, VoidPointer> set_member_hook;
typedef set_base_hook<tag, auto_unlink, VoidPointer> set_auto_base_hook_t;
typedef set_base_hook<tag, safe_link, VoidPointer> set_base_hook_t;
typedef set_member_hook<auto_unlink, VoidPointer> set_auto_member_hook_t;
typedef set_member_hook<safe_link, VoidPointer> set_member_hook_t;
typedef unordered_set_base_hook<tag, auto_unlink, VoidPointer> unordered_set_auto_base_hook;
typedef unordered_set_base_hook<tag, safe_link, VoidPointer> unordered_set_base_hook;
typedef unordered_set_member_hook<auto_unlink, VoidPointer> unordered_set_auto_member_hook;
typedef unordered_set_member_hook<safe_link, VoidPointer> unordered_set_member_hook;
typedef unordered_set_base_hook<tag, auto_unlink, VoidPointer> unordered_set_auto_base_hook_t;
typedef unordered_set_base_hook<tag, safe_link, VoidPointer> unordered_set_base_hook_t;
typedef unordered_set_member_hook<auto_unlink, VoidPointer> unordered_set_auto_member_hook_t;
typedef unordered_set_member_hook<safe_link, VoidPointer> unordered_set_member_hook_t;
typedef list_base_hook<tag, auto_unlink, VoidPointer> list_auto_base_hook;
typedef list_base_hook<tag, safe_link, VoidPointer> list_base_hook;
typedef list_member_hook<auto_unlink, VoidPointer> list_auto_member_hook;
typedef list_member_hook<safe_link, VoidPointer> list_member_hook;
typedef list_base_hook<tag, auto_unlink, VoidPointer> list_auto_base_hook_t;
typedef list_base_hook<tag, safe_link, VoidPointer> list_base_hook_t;
typedef list_member_hook<auto_unlink, VoidPointer> list_auto_member_hook_t;
typedef list_member_hook<safe_link, VoidPointer> list_member_hook_t;
typedef slist_base_hook<tag, auto_unlink, VoidPointer> slist_auto_base_hook;
typedef slist_base_hook<tag, safe_link, VoidPointer> slist_base_hook;
typedef slist_member_hook<auto_unlink, VoidPointer> slist_auto_member_hook;
typedef slist_member_hook<safe_link, VoidPointer> slist_member_hook;
typedef typename boost::pointer_to_other
<VoidPointer, testvalue>::type pointer;
typedef slist_base_hook<tag, auto_unlink, VoidPointer> slist_auto_base_hook_t;
typedef slist_base_hook<tag, safe_link, VoidPointer> slist_base_hook_t;
typedef slist_member_hook<auto_unlink, VoidPointer> slist_auto_member_hook_t;
typedef slist_member_hook<safe_link, VoidPointer> slist_member_hook_t;
//Set members
//pointer set_parent_, set_left_, set_right_;
//int set_color_;
set_member_hook set_node_;
set_auto_member_hook set_auto_node_;
unordered_set_member_hook unordered_set_node_;
unordered_set_auto_member_hook unordered_set_auto_node_;
set_member_hook_t set_node_;
set_auto_member_hook_t set_auto_node_;
unordered_set_member_hook_t unordered_set_node_;
unordered_set_auto_member_hook_t unordered_set_auto_node_;
//List members
//pointer list_next_, list_prev_;
list_member_hook list_node_;
list_auto_member_hook list_auto_node_;
list_member_hook_t list_node_;
list_auto_member_hook_t list_auto_node_;
//Slist members
//pointer slist_next_;
slist_member_hook slist_node_;
slist_auto_member_hook slist_auto_node_;
slist_member_hook_t slist_node_;
slist_auto_member_hook_t slist_auto_node_;
int value_;
@@ -101,24 +88,24 @@ struct testvalue
testvalue & operator= (const testvalue& src)
{
set_base_hook::operator=(src);
set_base_hook_t::operator=(src);
this->set_node_ = src.set_node_;
set_auto_base_hook::operator=(src);
set_auto_base_hook_t::operator=(src);
this->set_auto_node_ = src.set_auto_node_;
unordered_set_base_hook::operator=(src);
unordered_set_base_hook_t::operator=(src);
this->unordered_set_node_ = src.unordered_set_node_;
unordered_set_auto_base_hook::operator=(src);
unordered_set_auto_base_hook_t::operator=(src);
this->unordered_set_auto_node_ = src.unordered_set_auto_node_;
list_base_hook::operator=(src);
list_base_hook_t::operator=(src);
this->list_node_ = src.list_node_;
list_auto_base_hook::operator=(src);
list_auto_base_hook_t::operator=(src);
this->list_auto_node_ = src.list_auto_node_;
slist_base_hook::operator=(src);
slist_base_hook_t::operator=(src);
this->slist_node_ = src.slist_node_;
slist_auto_base_hook::operator=(src);
slist_auto_base_hook_t::operator=(src);
this->slist_auto_node_ = src.slist_auto_node_;
value_ = src.value_;
return *this;
@@ -131,15 +118,15 @@ struct testvalue
//...
//List
list_base_hook::swap_nodes(other);
list_base_hook_t::swap_nodes(other);
list_node_.swap_nodes(other.list_node_);
list_auto_base_hook::swap_nodes(other);
list_auto_base_hook_t::swap_nodes(other);
list_auto_node_.swap_nodes(other.list_auto_node_);
//Slist
slist_base_hook::swap_nodes(other);
slist_base_hook_t::swap_nodes(other);
slist_node_.swap_nodes(other.slist_node_);
slist_auto_base_hook::swap_nodes(other);
slist_auto_base_hook_t::swap_nodes(other);
slist_auto_node_.swap_nodes(other.slist_auto_node_);
}
@@ -151,6 +138,18 @@ struct testvalue
bool operator==(const testvalue &other) const
{ return value_ == other.value_; }
friend bool operator< (int other1, const testvalue &other2)
{ return other1 < other2.value_; }
friend bool operator< (const testvalue &other1, int other2)
{ return other1.value_ < other2; }
friend bool operator== (int other1, const testvalue &other2)
{ return other1 == other2.value_; }
friend bool operator== (const testvalue &other1, int other2)
{ return other1.value_ == other2; }
};
template<class VoidPointer, bool ConstantTimeSize>
@@ -185,151 +184,151 @@ typedef testvalue<void *, true> value_r_t;
typedef testvalue<smart_ptr<void>, true> value_s_t;
//Typedefs
typedef value_r_f::set_base_hook::
typedef value_r_f::set_base_hook_t::
value_traits<value_r_f > set_base_raw;
typedef value_r_f::set_member_hook::
typedef value_r_f::set_member_hook_t::
value_traits<value_r_f, &value_r_f::set_node_> set_member_raw;
typedef value_r_f::set_auto_base_hook::
typedef value_r_f::set_auto_base_hook_t::
value_traits<value_r_f> set_auto_base_raw;
typedef value_r_f::set_auto_member_hook::
typedef value_r_f::set_auto_member_hook_t::
value_traits<value_r_f, &value_r_f::set_auto_node_> set_auto_member_raw;
typedef value_s_f::set_base_hook::
typedef value_s_f::set_base_hook_t::
value_traits<value_s_f > set_base_smart;
typedef value_s_f::set_member_hook::
typedef value_s_f::set_member_hook_t::
value_traits<value_s_f, &value_s_f::set_node_> set_member_smart;
typedef value_s_f::set_auto_base_hook::
typedef value_s_f::set_auto_base_hook_t::
value_traits<value_s_f> set_auto_base_smart;
typedef value_s_f::set_auto_member_hook::
typedef value_s_f::set_auto_member_hook_t::
value_traits<value_s_f, &value_s_f::set_auto_node_> set_auto_member_smart;
typedef value_r_t::set_base_hook::
typedef value_r_t::set_base_hook_t::
value_traits<value_r_t > set_base_raw_t;
typedef value_r_t::set_member_hook::
typedef value_r_t::set_member_hook_t::
value_traits<value_r_t, &value_r_t::set_node_> set_member_raw_t;
typedef value_s_t::set_base_hook::
typedef value_s_t::set_base_hook_t::
value_traits<value_s_t > set_base_smart_t;
typedef value_s_t::set_member_hook::
typedef value_s_t::set_member_hook_t::
value_traits<value_s_t, &value_s_t::set_node_> set_member_smart_t;
//Typedefs
typedef value_r_f::unordered_set_base_hook::
typedef value_r_f::unordered_set_base_hook_t::
value_traits<value_r_f > unordered_set_base_raw;
typedef value_r_f::unordered_set_member_hook::
typedef value_r_f::unordered_set_member_hook_t::
value_traits<value_r_f, &value_r_f::unordered_set_node_> unordered_set_member_raw;
typedef value_r_f::unordered_set_auto_base_hook::
typedef value_r_f::unordered_set_auto_base_hook_t::
value_traits<value_r_f> unordered_set_auto_base_raw;
typedef value_r_f::unordered_set_auto_member_hook::
typedef value_r_f::unordered_set_auto_member_hook_t::
value_traits<value_r_f, &value_r_f::unordered_set_auto_node_> unordered_set_auto_member_raw;
typedef value_s_f::unordered_set_base_hook::
typedef value_s_f::unordered_set_base_hook_t::
value_traits<value_s_f > unordered_set_base_smart;
typedef value_s_f::unordered_set_member_hook::
typedef value_s_f::unordered_set_member_hook_t::
value_traits<value_s_f, &value_s_f::unordered_set_node_> unordered_set_member_smart;
typedef value_s_f::unordered_set_auto_base_hook::
typedef value_s_f::unordered_set_auto_base_hook_t::
value_traits<value_s_f> unordered_set_auto_base_smart;
typedef value_s_f::unordered_set_auto_member_hook::
typedef value_s_f::unordered_set_auto_member_hook_t::
value_traits<value_s_f, &value_s_f::unordered_set_auto_node_> unordered_set_auto_member_smart;
typedef value_r_t::unordered_set_base_hook::
typedef value_r_t::unordered_set_base_hook_t::
value_traits<value_r_t > unordered_set_base_raw_t;
typedef value_r_t::unordered_set_member_hook::
typedef value_r_t::unordered_set_member_hook_t::
value_traits<value_r_t, &value_r_t::unordered_set_node_> unordered_set_member_raw_t;
typedef value_s_t::unordered_set_base_hook::
typedef value_s_t::unordered_set_base_hook_t::
value_traits<value_s_t > unordered_set_base_smart_t;
typedef value_s_t::unordered_set_member_hook::
typedef value_s_t::unordered_set_member_hook_t::
value_traits<value_s_t, &value_s_t::unordered_set_node_> unordered_set_member_smart_t;
//Explicit instantiations
typedef value_r_f::list_base_hook::
typedef value_r_f::list_base_hook_t::
value_traits<value_r_f> list_base_raw;
typedef value_r_f::list_member_hook::
typedef value_r_f::list_member_hook_t::
value_traits<value_r_f, &value_r_f::list_node_> list_member_raw;
typedef value_r_f::list_auto_base_hook::
typedef value_r_f::list_auto_base_hook_t::
value_traits<value_r_f> list_auto_base_raw;
typedef value_r_f::list_auto_member_hook::
typedef value_r_f::list_auto_member_hook_t::
value_traits<value_r_f, &value_r_f::list_auto_node_> list_auto_member_raw;
typedef value_s_f::list_base_hook::
typedef value_s_f::list_base_hook_t::
value_traits<value_s_f> list_base_smart;
typedef value_s_f::list_member_hook::
typedef value_s_f::list_member_hook_t::
value_traits<value_s_f, &value_s_f::list_node_> list_member_smart;
typedef value_s_f::list_auto_base_hook::
typedef value_s_f::list_auto_base_hook_t::
value_traits<value_s_f> list_auto_base_smart;
typedef value_s_f::list_auto_member_hook::
typedef value_s_f::list_auto_member_hook_t::
value_traits<value_s_f, &value_s_f::list_auto_node_> list_auto_member_smart;
typedef value_r_t::list_base_hook::
typedef value_r_t::list_base_hook_t::
value_traits<value_r_t> list_base_raw_t;
typedef value_r_t::list_member_hook::
typedef value_r_t::list_member_hook_t::
value_traits<value_r_t, &value_r_t::list_node_> list_member_raw_t;
typedef value_s_t::list_base_hook::
typedef value_s_t::list_base_hook_t::
value_traits<value_s_t> list_base_smart_t;
typedef value_s_t::list_member_hook::
typedef value_s_t::list_member_hook_t::
value_traits<value_s_t, &value_s_t::list_node_> list_member_smart_t;
typedef value_r_f::slist_base_hook::
typedef value_r_f::slist_base_hook_t::
value_traits<value_r_f> slist_base_raw;
typedef value_r_f::slist_member_hook::
typedef value_r_f::slist_member_hook_t::
value_traits<value_r_f, &value_r_f::slist_node_> slist_member_raw;
typedef value_r_f::slist_auto_base_hook::
typedef value_r_f::slist_auto_base_hook_t::
value_traits<value_r_f> slist_auto_base_raw;
typedef value_r_f::slist_auto_member_hook::
typedef value_r_f::slist_auto_member_hook_t::
value_traits<value_r_f, &value_r_f::slist_auto_node_> slist_auto_member_raw;
typedef value_s_f::slist_base_hook::
typedef value_s_f::slist_base_hook_t::
value_traits<value_s_f> slist_base_smart;
typedef value_s_f::slist_member_hook::
typedef value_s_f::slist_member_hook_t::
value_traits<value_s_f, &value_s_f::slist_node_> slist_member_smart;
typedef value_s_f::slist_auto_base_hook::
typedef value_s_f::slist_auto_base_hook_t::
value_traits<value_s_f> slist_auto_base_smart;
typedef value_s_f::slist_auto_member_hook::
typedef value_s_f::slist_auto_member_hook_t::
value_traits<value_s_f, &value_s_f::slist_auto_node_> slist_auto_member_smart;
typedef value_r_t::slist_base_hook::
typedef value_r_t::slist_base_hook_t::
value_traits<value_r_t> slist_base_raw_t;
typedef value_r_t::slist_member_hook::
typedef value_r_t::slist_member_hook_t::
value_traits<value_r_t, &value_r_t::slist_node_> slist_member_raw_t;
typedef value_s_t::slist_base_hook::
typedef value_s_t::slist_base_hook_t::
value_traits<value_s_t> slist_base_smart_t;
typedef value_s_t::slist_member_hook::
typedef value_s_t::slist_member_hook_t::
value_traits<value_s_t, &value_s_t::slist_node_> slist_member_smart_t;
} //namespace boost{

188
test/list_test.cpp
View File

@@ -1,7 +1,7 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Olaf Krzikalla 2004-2006.
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007.
// (C) Copyright Ion Gaztanaga 2006-2007.
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
@@ -16,10 +16,8 @@
#include "smart_ptr.hpp"
#include "common_functors.hpp"
#include <vector>
#include <boost/intrusive/linking_policy.hpp>
// Boost.Test
#include "boost/test/included/test_exec_monitor.hpp"
#include <boost/detail/lightweight_test.hpp>
#include "test_macros.hpp"
using namespace boost::intrusive;
@@ -66,26 +64,26 @@ void test_list<ValueTraits>
, std::size_t
> list_type;
list_type testlist;
BOOST_CHECK (testlist.empty());
BOOST_TEST (testlist.empty());
testlist.push_back (values[0]);
BOOST_CHECK (testlist.size() == 1);
BOOST_CHECK (&testlist.front() == &values[0]);
BOOST_CHECK (&testlist.back() == &values[0]);
BOOST_TEST (testlist.size() == 1);
BOOST_TEST (&testlist.front() == &values[0]);
BOOST_TEST (&testlist.back() == &values[0]);
testlist.push_front (values[1]);
BOOST_CHECK (testlist.size() == 2);
BOOST_CHECK (&testlist.front() == &values[1]);
BOOST_CHECK (&testlist.back() == &values[0]);
BOOST_TEST (testlist.size() == 2);
BOOST_TEST (&testlist.front() == &values[1]);
BOOST_TEST (&testlist.back() == &values[0]);
testlist.pop_back();
BOOST_CHECK (testlist.size() == 1);
BOOST_TEST (testlist.size() == 1);
const list_type &const_testlist = testlist;
BOOST_CHECK (&const_testlist.front() == &values[1]);
BOOST_CHECK (&const_testlist.back() == &values[1]);
BOOST_TEST (&const_testlist.front() == &values[1]);
BOOST_TEST (&const_testlist.back() == &values[1]);
testlist.pop_front();
BOOST_CHECK (testlist.empty());
BOOST_TEST (testlist.empty());
}
@@ -95,7 +93,7 @@ void test_list<ValueTraits>
::test_sort(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
std::vector<int> expected;
typedef boost::intrusive::list
< ValueTraits
, ValueTraits::value_type::constant_time_size
@@ -103,21 +101,16 @@ void test_list<ValueTraits>
> list_type;
list_type testlist(values.begin(), values.end());
std::copy (testlist.begin(), testlist.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("12345"));
{ int init_values [] = { 1, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist.begin() ); }
testlist.sort (even_odd());
std::copy (testlist.rbegin(), testlist.rend(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("53142"));
{ int init_values [] = { 5, 3, 1, 4, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist.rbegin() ); }
testlist.reverse();
//test postincrement:
for (BOOST_DEDUCED_TYPENAME list_type::iterator i =
testlist.begin(), e = testlist.end(); i != e; i++)
test_seq << *i;
BOOST_CHECK (test_seq.is_equal ("53142"));
{ int init_values [] = { 5, 3, 1, 4, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist.begin() ); }
}
//test: assign, insert, const_iterator, const_reverse_iterator, erase, iterator_to:
@@ -126,7 +119,7 @@ void test_list<ValueTraits>
::test_insert(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
std::vector<int> expected;
typedef boost::intrusive::list
< ValueTraits
, ValueTraits::value_type::constant_time_size
@@ -136,29 +129,29 @@ void test_list<ValueTraits>
testlist.assign (&values[0] + 2, &values[0] + 5);
const list_type& const_testlist = testlist;
std::copy (const_testlist.begin(), const_testlist.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("345"));
{ int init_values [] = { 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, const_testlist.begin() ); }
BOOST_DEDUCED_TYPENAME list_type::iterator i = ++testlist.begin();
BOOST_CHECK (i->value_ == 4);
typename list_type::iterator i = ++testlist.begin();
BOOST_TEST (i->value_ == 4);
{
typename list_type::const_iterator ci = typename list_type::iterator();
//typename list_type::iterator i = typename list_type::const_iterator();
}
testlist.insert (i, values[0]);
std::copy (const_testlist.rbegin(), const_testlist.rend(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("5413"));
{ int init_values [] = { 5, 4, 1, 3 };
TEST_INTRUSIVE_SEQUENCE( init_values, const_testlist.rbegin() ); }
i = testlist.iterator_to (values[4]);
BOOST_CHECK (&*i == &values[4]);
BOOST_TEST (&*i == &values[4]);
i = testlist.erase (i);
BOOST_CHECK (i == testlist.end());
BOOST_TEST (i == testlist.end());
//test postincrement:
for (BOOST_DEDUCED_TYPENAME list_type::const_iterator i =
const_testlist.begin(), e = const_testlist.end(); i != e; i++)
test_seq << *i;
BOOST_CHECK (test_seq.is_equal ("314"));
{ int init_values [] = { 3, 1, 4 };
TEST_INTRUSIVE_SEQUENCE( init_values, const_testlist.begin() ); }
}
template<class ValueTraits>
@@ -166,13 +159,13 @@ void test_list<ValueTraits>
::test_shift(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::list
< ValueTraits
, ValueTraits::value_type::constant_time_size
, std::size_t
> list_type;
list_type testlist;
std::vector<int> expected;
const int num_values = (int)values.size();
std::vector<int> expected_values(num_values);
@@ -184,13 +177,7 @@ void test_list<ValueTraits>
for(int j = 0; j < num_values; ++j){
expected_values[(j + num_values - i%num_values) % num_values] = (j + 1);
}
std::copy (testlist.begin(), testlist.end(),
std::ostream_iterator<testvalue_t> (test_seq));
std::stringstream stream;
std::copy (expected_values.begin(), expected_values.end(),
std::ostream_iterator<testvalue_t> (stream));
stream << std::ends;
BOOST_CHECK (test_seq.is_equal (stream.str().c_str()));
TEST_INTRUSIVE_SEQUENCE_EXPECTED(expected_values, testlist.begin());
testlist.clear();
}
@@ -201,13 +188,7 @@ void test_list<ValueTraits>
for(int j = 0; j < num_values; ++j){
expected_values[(j + i) % num_values] = (j + 1);
}
std::copy (testlist.begin(), testlist.end(),
std::ostream_iterator<testvalue_t> (test_seq));
std::stringstream stream;
std::copy (expected_values.begin(), expected_values.end(),
std::ostream_iterator<testvalue_t> (stream));
stream << std::ends;
BOOST_CHECK (test_seq.is_equal (stream.str().c_str()));
TEST_INTRUSIVE_SEQUENCE_EXPECTED(expected_values, testlist.begin());
testlist.clear();
}
}
@@ -218,68 +199,59 @@ void test_list<ValueTraits>
::test_swap(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::list
<ValueTraits
,ValueTraits::value_type::constant_time_size, std::size_t
> list_type;
std::vector<int> expected;
{
list_type testlist1 (&values[0], &values[0] + 2);
list_type testlist2;
testlist2.insert (testlist2.end(), &values[0] + 2, &values[0] + 5);
testlist1.swap (testlist2);
std::copy (testlist1.begin(), testlist1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("345"));
std::copy (testlist2.begin(), testlist2.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("12"));
{ int init_values [] = { 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist1.begin() ); }
{ int init_values [] = { 1, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist2.begin() ); }
testlist2.splice (++testlist2.begin(), testlist1);
std::copy (testlist2.begin(), testlist2.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("13452"));
BOOST_CHECK (testlist1.empty());
{ int init_values [] = { 1, 3, 4, 5, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist2.begin() ); }
BOOST_TEST (testlist1.empty());
testlist1.splice (testlist1.end(), testlist2, ++(++testlist2.begin()));
std::copy (testlist1.begin(), testlist1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("4"));
std::copy (testlist2.begin(), testlist2.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("1352"));
{ int init_values [] = { 4 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist1.begin() ); }
{ int init_values [] = { 1, 3, 5, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist2.begin() ); }
testlist1.splice (testlist1.end(), testlist2,
testlist2.begin(), ----testlist2.end());
std::copy (testlist1.begin(), testlist1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("413"));
std::copy (testlist2.begin(), testlist2.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("52"));
{ int init_values [] = { 4, 1, 3 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist1.begin() ); }
{ int init_values [] = { 5, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist2.begin() ); }
testlist1.erase (testlist1.iterator_to(values[0]), testlist1.end());
BOOST_CHECK (testlist1.size() == 1);
BOOST_CHECK (&testlist1.front() == &values[3]);
BOOST_TEST (testlist1.size() == 1);
BOOST_TEST (&testlist1.front() == &values[3]);
}
{
boost::test_tools::output_test_stream test_seq;
list_type testlist1 (&values[0], &values[0] + 2);
list_type testlist2 (&values[0] + 3, &values[0] + 5);
values[0].swap_nodes(values[2]);
std::copy (testlist1.begin(), testlist1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("32"));
{ int init_values [] = { 3, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist1.begin() ); }
values[2].swap_nodes(values[4]);
std::copy (testlist1.begin(), testlist1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("52"));
std::copy (testlist2.begin(), testlist2.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("43"));
{ int init_values [] = { 5, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist1.begin() ); }
{ int init_values [] = { 4, 3 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist2.begin() ); }
}
}
@@ -288,7 +260,7 @@ void test_list<ValueTraits>
::test_clone(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
std::vector<int> expected;
typedef boost::intrusive::list
<ValueTraits
,ValueTraits::value_type::constant_time_size, std::size_t
@@ -298,9 +270,9 @@ void test_list<ValueTraits>
list_type testlist2;
testlist2.clone_from(testlist1, test::new_cloner(), test::delete_destroyer());
BOOST_CHECK (testlist2 == testlist1);
BOOST_TEST (testlist2 == testlist1);
testlist2.clear_and_destroy(test::delete_destroyer());
BOOST_CHECK (testlist2.empty());
BOOST_TEST (testlist2.empty());
}
template<class VoidPointer, bool constant_time_size>
@@ -314,10 +286,10 @@ class test_main_template
for (int i = 0; i < 5; ++i)
data[i].value_ = i + 1;
test_list <typename testvalue_t::list_base_hook::template
test_list <typename testvalue_t::list_base_hook_t::template
value_traits<testvalue_t> >::test_all(data);
test_list <typename testvalue_t::list_member_hook::template
test_list <typename testvalue_t::list_member_hook_t::template
value_traits<testvalue_t, &testvalue_t::list_node_> >::test_all(data);
return 0;
@@ -335,21 +307,21 @@ class test_main_template<VoidPointer, false>
for (int i = 0; i < 5; ++i)
data[i].value_ = i + 1;
test_list <typename testvalue_t::list_base_hook::template
test_list <typename testvalue_t::list_base_hook_t::template
value_traits<testvalue_t> >::test_all(data);
test_list <typename testvalue_t::list_member_hook::template
test_list <typename testvalue_t::list_member_hook_t::template
value_traits<testvalue_t, &testvalue_t::list_node_> >::test_all(data);
test_list <typename testvalue_t::list_auto_base_hook::template
test_list <typename testvalue_t::list_auto_base_hook_t::template
value_traits<testvalue_t> >::test_all(data);
test_list <typename testvalue_t::list_auto_member_hook::template
test_list <typename testvalue_t::list_auto_member_hook_t::template
value_traits<testvalue_t, &testvalue_t::list_auto_node_> >::test_all(data);
return 0;
}
};
/*
//Explicit instantiations of non-counted classes
template class boost::intrusive::list<list_base_raw, false>;
template class boost::intrusive::list<list_member_raw, false>;
@@ -365,12 +337,12 @@ template class boost::intrusive::list<list_base_raw_t, true>;
template class boost::intrusive::list<list_member_raw_t, true>;
template class boost::intrusive::list<list_base_smart_t, true>;
template class boost::intrusive::list<list_member_smart_t, true>;
int test_main( int, char* [] )
*/
int main( int, char* [] )
{
test_main_template<void*, false>()();
test_main_template<boost::intrusive::smart_ptr<void>, false>()();
test_main_template<void*, true>()();
test_main_template<boost::intrusive::smart_ptr<void>, true>()();
return 0;
return boost::report_errors();
}

113
test/multiset_test.cpp
View File

@@ -1,7 +1,7 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Olaf Krzikalla 2004-2006.
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007.
// (C) Copyright Ion Gaztanaga 2006-2007.
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
@@ -16,11 +16,9 @@
#include "itestvalue.hpp"
#include "smart_ptr.hpp"
#include "common_functors.hpp"
#include <vector>
// Boost.Test
#include "boost/test/included/test_exec_monitor.hpp"
#include <boost/detail/lightweight_test.hpp>
#include "test_macros.hpp"
using namespace boost::intrusive;
@@ -78,21 +76,17 @@ template<class ValueTraits>
void test_multiset<ValueTraits>::test_sort(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef multiset
<ValueTraits
,std::less<typename ValueTraits::value_type>
,ValueTraits::value_type::constant_time_size, std::size_t
> multiset_type;
multiset_type testset1 (values.begin(), values.end());
std::copy (testset1.begin(), testset1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("122345"));
{ int init_values [] = { 1, 2, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
testset1.clear();
BOOST_CHECK (testset1.empty());
BOOST_TEST (testset1.empty());
typedef multiset
<ValueTraits
@@ -100,11 +94,11 @@ void test_multiset<ValueTraits>::test_sort(std::vector<typename ValueTraits::val
,ValueTraits::value_type::constant_time_size, std::size_t
> multiset_type2;
multiset_type2 testset2 (&values[0], &values[0] + 6);
std::copy (testset2.rbegin(), testset2.rend(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("531422"));
BOOST_CHECK (testset2.begin()->value_ == 2);
BOOST_CHECK (testset2.rbegin()->value_ == 5);
{ int init_values [] = { 5, 3, 1, 4, 2, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.rbegin() ); }
BOOST_TEST (testset2.begin()->value_ == 2);
BOOST_TEST (testset2.rbegin()->value_ == 5);
}
//test: insert, const_iterator, const_reverse_iterator, erase, iterator_to:
@@ -112,8 +106,6 @@ template<class ValueTraits>
void test_multiset<ValueTraits>::test_insert(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef multiset
<ValueTraits
,std::less<typename ValueTraits::value_type>
@@ -122,31 +114,24 @@ void test_multiset<ValueTraits>::test_insert(std::vector<typename ValueTraits::v
multiset_type testset;
testset.insert(&values[0] + 2, &values[0] + 5);
{ int init_values [] = { 1, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.begin() ); }
const multiset_type& const_testset = testset;
std::copy (const_testset.begin(), const_testset.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("145"));
BOOST_DEDUCED_TYPENAME multiset_type::iterator i = testset.begin();
BOOST_CHECK (i->value_ == 1);
typename multiset_type::iterator i = testset.begin();
BOOST_TEST (i->value_ == 1);
i = testset.insert (i, values[0]);
BOOST_CHECK (&*i == &values[0]);
BOOST_TEST (&*i == &values[0]);
std::copy (const_testset.rbegin(), const_testset.rend(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("5431"));
{ int init_values [] = { 5, 4, 3, 1 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.rbegin() ); }
i = testset.iterator_to (values[2]);
BOOST_CHECK (&*i == &values[2]);
BOOST_TEST (&*i == &values[2]);
testset.erase(i);
//test post-increment:
for (BOOST_DEDUCED_TYPENAME multiset_type::const_iterator i = const_testset.begin(),
e = const_testset.end(); i != e; i++)
test_seq << *i;
BOOST_CHECK (test_seq.is_equal ("135"));
{ int init_values [] = { 1, 3, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.begin() ); }
}
//test: insert (seq-version), swap, erase (seq-version), size:
@@ -154,7 +139,6 @@ template<class ValueTraits>
void test_multiset<ValueTraits>::test_swap(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef multiset
<ValueTraits
,std::less<typename ValueTraits::value_type>
@@ -165,18 +149,14 @@ void test_multiset<ValueTraits>::test_swap(std::vector<typename ValueTraits::val
testset2.insert (&values[0] + 2, &values[0] + 6);
testset1.swap (testset2);
std::copy (testset1.begin(), testset1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("1245"));
//test post-increment:
for (BOOST_DEDUCED_TYPENAME multiset_type::iterator i = testset2.begin(),
e = testset2.end(); i != e; i++)
test_seq << *i;
BOOST_CHECK (test_seq.is_equal ("23"));
{ int init_values [] = { 1, 2, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
{ int init_values [] = { 2, 3 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.begin() ); }
testset1.erase (testset1.iterator_to(values[5]), testset1.end());
BOOST_CHECK (testset1.size() == 1);
BOOST_CHECK (&*testset1.begin() == &values[3]);
BOOST_TEST (testset1.size() == 1);
BOOST_TEST (&*testset1.begin() == &values[3]);
}
//test: find, equal_range (lower_bound, upper_bound):
@@ -184,28 +164,27 @@ template<class ValueTraits>
void test_multiset<ValueTraits>::test_find(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef multiset
<ValueTraits
,std::less<typename ValueTraits::value_type>
,ValueTraits::value_type::constant_time_size, std::size_t
> multiset_type;
multiset_type testset (values.begin(), values.end());
typedef BOOST_DEDUCED_TYPENAME multiset_type::iterator iterator;
typedef typename multiset_type::iterator iterator;
testvalue_t cmp_val;
cmp_val.value_ = 2;
iterator i = testset.find (cmp_val);
BOOST_CHECK (i->value_ == 2);
BOOST_CHECK ((++i)->value_ == 2);
BOOST_TEST (i->value_ == 2);
BOOST_TEST ((++i)->value_ == 2);
std::pair<iterator,iterator> range = testset.equal_range (cmp_val);
BOOST_CHECK (range.first->value_ == 2);
BOOST_CHECK (range.second->value_ == 3);
BOOST_CHECK (std::distance (range.first, range.second) == 2);
BOOST_TEST (range.first->value_ == 2);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (std::distance (range.first, range.second) == 2);
cmp_val.value_ = 7;
BOOST_CHECK (testset.find (cmp_val) == testset.end());
BOOST_TEST (testset.find (cmp_val) == testset.end());
}
template<class ValueTraits>
@@ -223,9 +202,9 @@ void test_multiset<ValueTraits>
multiset_type testmultiset2;
testmultiset2.clone_from(testmultiset1, test::new_cloner(), test::delete_destroyer());
BOOST_CHECK (testmultiset2 == testmultiset1);
BOOST_TEST (testmultiset2 == testmultiset1);
testmultiset2.clear_and_destroy(test::delete_destroyer());
BOOST_CHECK (testmultiset2.empty());
BOOST_TEST (testmultiset2.empty());
}
template<class VoidPointer, bool constant_time_size>
@@ -240,10 +219,10 @@ class test_main_template
for (int i = 0; i < 6; ++i)
data[i].value_ = random_init[i];
test_multiset <typename testvalue_t::set_base_hook::template
test_multiset <typename testvalue_t::set_base_hook_t::template
value_traits<testvalue_t> >::test_all(data);
test_multiset <typename testvalue_t::set_member_hook::template
test_multiset <typename testvalue_t::set_member_hook_t::template
value_traits<testvalue_t, &testvalue_t::set_node_> >::test_all(data);
return 0;
@@ -262,21 +241,21 @@ class test_main_template<VoidPointer, false>
for (int i = 0; i < 6; ++i)
data[i].value_ = random_init[i];
test_multiset <typename testvalue_t::set_base_hook::template
test_multiset <typename testvalue_t::set_base_hook_t::template
value_traits<testvalue_t> >::test_all(data);
test_multiset <typename testvalue_t::set_member_hook::template
test_multiset <typename testvalue_t::set_member_hook_t::template
value_traits<testvalue_t, &testvalue_t::set_node_> >::test_all(data);
test_multiset <typename testvalue_t::set_auto_base_hook::template
test_multiset <typename testvalue_t::set_auto_base_hook_t::template
value_traits<testvalue_t> >::test_all(data);
test_multiset <typename testvalue_t::set_auto_member_hook::template
test_multiset <typename testvalue_t::set_auto_member_hook_t::template
value_traits<testvalue_t, &testvalue_t::set_auto_node_> >::test_all(data);
return 0;
}
};
/*
//Explicit instantiations of non-counted classes
template class multiset
<set_base_raw, std::less<set_base_raw::value_type>, false>;
@@ -304,14 +283,14 @@ template class multiset
<set_base_smart_t, std::less<set_base_smart_t::value_type>, true>;
template class multiset
<set_member_smart_t, std::less<set_member_smart_t::value_type>, true>;
int test_main( int, char* [] )
*/
int main( int, char* [] )
{
test_main_template<void*, false>()();
test_main_template<smart_ptr<void>, false>()();
test_main_template<void*, true>()();
test_main_template<smart_ptr<void>, true>()();
return 0;
return boost::report_errors();
}

112
test/set_test.cpp
View File

@@ -1,7 +1,7 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Olaf Krzikalla 2004-2006.
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007.
// (C) Copyright Ion Gaztanaga 2006-2007.
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
@@ -17,9 +17,8 @@
#include "smart_ptr.hpp"
#include "common_functors.hpp"
#include <vector>
// Boost.Test
#include "boost/test/included/test_exec_monitor.hpp"
#include <boost/detail/lightweight_test.hpp>
#include "test_macros.hpp"
using namespace boost::intrusive;
@@ -78,20 +77,17 @@ template<class ValueTraits>
void test_set<ValueTraits>::test_sort(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::set
<ValueTraits
,std::less<typename ValueTraits::value_type>
,ValueTraits::value_type::constant_time_size, std::size_t
> set_type;
set_type testset1 (values.begin(), values.end());
std::copy (testset1.begin(), testset1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("12345"));
{ int init_values [] = { 1, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
testset1.clear();
BOOST_CHECK (testset1.empty());
BOOST_TEST (testset1.empty());
typedef boost::intrusive::set
<ValueTraits
@@ -99,11 +95,10 @@ void test_set<ValueTraits>::test_sort(std::vector<typename ValueTraits::value_ty
,ValueTraits::value_type::constant_time_size, std::size_t
> set_type2;
set_type2 testset2 (&values[0], &values[0] + 6);
std::copy (testset2.rbegin(), testset2.rend(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("53142"));
BOOST_CHECK (testset2.begin()->value_ == 2);
BOOST_CHECK (testset2.rbegin()->value_ == 5);
{ int init_values [] = { 5, 3, 1, 4, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.rbegin() ); }
BOOST_TEST (testset2.begin()->value_ == 2);
BOOST_TEST (testset2.rbegin()->value_ == 5);
}
//test: insert, const_iterator, const_reverse_iterator, erase, iterator_to:
@@ -111,7 +106,6 @@ template<class ValueTraits>
void test_set<ValueTraits>::test_insert(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::set
<ValueTraits
,std::less<typename ValueTraits::value_type>
@@ -121,29 +115,24 @@ void test_set<ValueTraits>::test_insert(std::vector<typename ValueTraits::value_
testset.insert(&values[0] + 2, &values[0] + 5);
const set_type& const_testset = testset;
std::copy (const_testset.begin(), const_testset.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("145"));
{ int init_values [] = { 1, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() ); }
BOOST_DEDUCED_TYPENAME set_type::iterator i = testset.begin();
BOOST_CHECK (i->value_ == 1);
typename set_type::iterator i = testset.begin();
BOOST_TEST (i->value_ == 1);
i = testset.insert (i, values[0]);
BOOST_CHECK (&*i == &values[0]);
BOOST_TEST (&*i == &values[0]);
std::copy (const_testset.rbegin(), const_testset.rend(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("5431"));
{ int init_values [] = { 5, 4, 3, 1 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.rbegin() ); }
i = testset.iterator_to (values[2]);
BOOST_CHECK (&*i == &values[2]);
BOOST_TEST (&*i == &values[2]);
testset.erase (i);
//test post-increment:
for (BOOST_DEDUCED_TYPENAME set_type::const_iterator i = const_testset.begin(),
e = const_testset.end(); i != e; i++)
test_seq << *i;
BOOST_CHECK (test_seq.is_equal ("135"));
{ int init_values [] = { 1, 3, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset.begin() ); }
}
//test: insert (seq-version), swap, erase (seq-version), size:
@@ -151,8 +140,6 @@ template<class ValueTraits>
void test_set<ValueTraits>::test_swap(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::set
<ValueTraits
,std::less<typename ValueTraits::value_type>
@@ -163,19 +150,16 @@ void test_set<ValueTraits>::test_swap(std::vector<typename ValueTraits::value_ty
testset2.insert (&values[0] + 2, &values[0] + 6);
testset1.swap (testset2);
std::copy (testset1.begin(), testset1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("1245"));
//test post-increment:
for (BOOST_DEDUCED_TYPENAME set_type::iterator i = testset2.begin(),
e = testset2.end(); i != e; i++)
test_seq << *i;
BOOST_CHECK (test_seq.is_equal ("23"));
{ int init_values [] = { 1, 2, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
{ int init_values [] = { 2, 3 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.begin() ); }
testset1.erase (testset1.iterator_to(values[5]), testset1.end());
BOOST_CHECK (testset1.size() == 1);
// BOOST_CHECK (&testset1.front() == &values[3]);
BOOST_CHECK (&*testset1.begin() == &values[3]);
BOOST_TEST (testset1.size() == 1);
// BOOST_TEST (&testset1.front() == &values[3]);
BOOST_TEST (&*testset1.begin() == &values[3]);
}
//test: find, equal_range (lower_bound, upper_bound):
@@ -183,29 +167,27 @@ template<class ValueTraits>
void test_set<ValueTraits>::test_find(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::set
<ValueTraits
,std::less<typename ValueTraits::value_type>
,ValueTraits::value_type::constant_time_size, std::size_t
> set_type;
set_type testset (values.begin(), values.end());
typedef BOOST_DEDUCED_TYPENAME set_type::iterator iterator;
typedef typename set_type::iterator iterator;
testvalue_t cmp_val;
cmp_val.value_ = 2;
iterator i = testset.find (cmp_val);
BOOST_CHECK (i->value_ == 2);
BOOST_CHECK ((++i)->value_ != 2);
BOOST_TEST (i->value_ == 2);
BOOST_TEST ((++i)->value_ != 2);
std::pair<iterator,iterator> range = testset.equal_range (cmp_val);
BOOST_CHECK (range.first->value_ == 2);
BOOST_CHECK (range.second->value_ == 3);
BOOST_CHECK (std::distance (range.first, range.second) == 1);
BOOST_TEST (range.first->value_ == 2);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (std::distance (range.first, range.second) == 1);
cmp_val.value_ = 7;
BOOST_CHECK (testset.find (cmp_val) == testset.end());
BOOST_TEST (testset.find (cmp_val) == testset.end());
}
template<class ValueTraits>
@@ -223,9 +205,9 @@ void test_set<ValueTraits>
set_type testset2;
testset2.clone_from(testset1, test::new_cloner(), test::delete_destroyer());
BOOST_CHECK (testset2 == testset1);
BOOST_TEST (testset2 == testset1);
testset2.clear_and_destroy(test::delete_destroyer());
BOOST_CHECK (testset2.empty());
BOOST_TEST (testset2.empty());
}
template<class VoidPointer, bool constant_time_size>
@@ -240,10 +222,10 @@ class test_main_template
for (int i = 0; i < 6; ++i)
data[i].value_ = random_init[i];
test_set <typename testvalue_t::set_base_hook::template
test_set <typename testvalue_t::set_base_hook_t::template
value_traits<testvalue_t> >::test_all(data);
test_set <typename testvalue_t::set_member_hook::template
test_set <typename testvalue_t::set_member_hook_t::template
value_traits<testvalue_t, &testvalue_t::set_node_> >::test_all(data);
return 0;
@@ -262,21 +244,21 @@ class test_main_template<VoidPointer, false>
for (int i = 0; i < 6; ++i)
data[i].value_ = random_init[i];
test_set <typename testvalue_t::set_base_hook::template
test_set <typename testvalue_t::set_base_hook_t::template
value_traits<testvalue_t> >::test_all(data);
test_set <typename testvalue_t::set_member_hook::template
test_set <typename testvalue_t::set_member_hook_t::template
value_traits<testvalue_t, &testvalue_t::set_node_> >::test_all(data);
test_set <typename testvalue_t::set_auto_base_hook::template
test_set <typename testvalue_t::set_auto_base_hook_t::template
value_traits<testvalue_t> >::test_all(data);
test_set <typename testvalue_t::set_auto_member_hook::template
test_set <typename testvalue_t::set_auto_member_hook_t::template
value_traits<testvalue_t, &testvalue_t::set_auto_node_> >::test_all(data);
return 0;
}
};
/*
//Explicit instantiations of non-counted classes
template class boost::intrusive::set
<set_base_raw, std::less<set_base_raw::value_type>, false>;
@@ -304,12 +286,12 @@ template class boost::intrusive::set
<set_base_smart_t, std::less<set_base_smart_t::value_type>, true>;
template class boost::intrusive::set
<set_member_smart_t, std::less<set_member_smart_t::value_type>, true>;
int test_main( int, char* [] )
*/
int main( int, char* [] )
{
test_main_template<void*, false>()();
test_main_template<boost::intrusive::smart_ptr<void>, false>()();
test_main_template<void*, true>()();
test_main_template<boost::intrusive::smart_ptr<void>, true>()();
return 0;
return boost::report_errors();
}

210
test/slist_test.cpp
View File

@@ -1,7 +1,7 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Olaf Krzikalla 2004-2006.
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007.
// (C) Copyright Ion Gaztanaga 2006-2007.
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
@@ -16,10 +16,8 @@
#include "smart_ptr.hpp"
#include "common_functors.hpp"
#include <vector>
#include <sstream>
// Boost.Test
#include "boost/test/included/test_exec_monitor.hpp"
#include <boost/detail/lightweight_test.hpp>
#include "test_macros.hpp"
using namespace boost::intrusive;
@@ -62,22 +60,22 @@ void test_slist<ValueTraits>
,ValueTraits::value_type::constant_time_size, std::size_t
> list_type;
list_type testlist;
BOOST_CHECK (testlist.empty());
BOOST_TEST (testlist.empty());
testlist.push_front (values[0]);
BOOST_CHECK (testlist.size() == 1);
BOOST_CHECK (&testlist.front() == &values[0]);
BOOST_TEST (testlist.size() == 1);
BOOST_TEST (&testlist.front() == &values[0]);
testlist.push_front (values[1]);
BOOST_CHECK (testlist.size() == 2);
BOOST_CHECK (&testlist.front() == &values[1]);
BOOST_TEST (testlist.size() == 2);
BOOST_TEST (&testlist.front() == &values[1]);
testlist.pop_front();
BOOST_CHECK (testlist.size() == 1);
BOOST_CHECK (&testlist.front() == &values[0]);
BOOST_TEST (testlist.size() == 1);
BOOST_TEST (&testlist.front() == &values[0]);
testlist.pop_front();
BOOST_CHECK (testlist.empty());
BOOST_TEST (testlist.empty());
}
//test: merge due to error in merge implementation:
@@ -86,7 +84,6 @@ void test_slist<ValueTraits>
::test_merge (std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::slist
<ValueTraits
,ValueTraits::value_type::constant_time_size, std::size_t
@@ -98,9 +95,8 @@ void test_slist<ValueTraits>
testlist2.push_front (values[2]);
testlist1.merge (testlist2);
std::copy (testlist1.begin(), testlist1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("1345"));
int init_values [] = { 1, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist1.begin() );
}
//test: constructor, iterator, sort, reverse:
@@ -109,27 +105,22 @@ void test_slist<ValueTraits>
::test_sort(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::slist
<ValueTraits
,ValueTraits::value_type::constant_time_size, std::size_t
> list_type;
list_type testlist (values.begin(), values.end());
std::copy (testlist.begin(), testlist.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("12345"));
{ int init_values [] = { 1, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist.begin() ); }
testlist.sort (even_odd());
for (BOOST_DEDUCED_TYPENAME list_type::iterator i = testlist.begin(),
e = testlist.end(); i != e; i++) //test postincrement
test_seq << *i;
BOOST_CHECK (test_seq.is_equal ("24135"));
{ int init_values [] = { 2, 4, 1, 3, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist.begin() ); }
testlist.reverse();
std::copy (testlist.begin(), testlist.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("53142"));
{ int init_values [] = { 5, 3, 1, 4, 2, };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist.begin() ); }
}
//test: assign, insert_after, const_iterator, erase_after, iterator_to, previous:
@@ -138,7 +129,6 @@ void test_slist<ValueTraits>
::test_insert(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::slist
<ValueTraits
,ValueTraits::value_type::constant_time_size, std::size_t
@@ -147,30 +137,25 @@ void test_slist<ValueTraits>
testlist.assign (&values[0] + 2, &values[0] + 5);
const list_type& const_testlist = testlist;
std::copy (const_testlist.begin(), const_testlist.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("345"));
{ int init_values [] = { 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, const_testlist.begin() ); }
BOOST_DEDUCED_TYPENAME list_type::iterator i = ++testlist.begin();
BOOST_CHECK (i->value_ == 4);
typename list_type::iterator i = ++testlist.begin();
BOOST_TEST (i->value_ == 4);
testlist.insert_after (i, values[0]);
for (BOOST_DEDUCED_TYPENAME list_type::const_iterator i2 = const_testlist.begin(),
e = const_testlist.end(); i2 != e; i2++) //test postincrement
test_seq << *i2;
BOOST_CHECK (test_seq.is_equal ("3415"));
{ int init_values [] = { 3, 4, 1, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, const_testlist.begin() ); }
i = testlist.iterator_to (values[4]);
BOOST_CHECK (&*i == &values[4]);
BOOST_TEST (&*i == &values[4]);
i = testlist.previous (i);
BOOST_CHECK (&*i == &values[0]);
BOOST_TEST (&*i == &values[0]);
testlist.erase_after (i);
BOOST_CHECK (&*i == &values[0]);
std::copy (const_testlist.begin(), const_testlist.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("341"));
BOOST_TEST (&*i == &values[0]);
{ int init_values [] = { 3, 4, 1 };
TEST_INTRUSIVE_SEQUENCE( init_values, const_testlist.begin() ); }
}
//test: insert, const_iterator, erase, iterator_to:
@@ -179,7 +164,6 @@ void test_slist<ValueTraits>
::test_slow_insert (std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::slist
<ValueTraits
,ValueTraits::value_type::constant_time_size, std::size_t
@@ -189,32 +173,28 @@ void test_slist<ValueTraits>
testlist.insert (testlist.begin(), &values[0] + 2, &values[0] + 4);
const list_type& const_testlist = testlist;
std::copy (const_testlist.begin(), const_testlist.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("345"));
{ int init_values [] = { 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, const_testlist.begin() ); }
BOOST_DEDUCED_TYPENAME list_type::iterator i = ++testlist.begin();
BOOST_CHECK (i->value_ == 4);
typename list_type::iterator i = ++testlist.begin();
BOOST_TEST (i->value_ == 4);
testlist.insert (i, values[0]);
std::copy (const_testlist.begin(), const_testlist.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("3145"));
{ int init_values [] = { 3, 1, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, const_testlist.begin() ); }
i = testlist.iterator_to (values[4]);
BOOST_CHECK (&*i == &values[4]);
BOOST_TEST (&*i == &values[4]);
i = testlist.erase (i);
BOOST_CHECK (i == testlist.end());
BOOST_TEST (i == testlist.end());
{ int init_values [] = { 3, 1, 4 };
TEST_INTRUSIVE_SEQUENCE( init_values, const_testlist.begin() ); }
//test postincrement:
for (BOOST_DEDUCED_TYPENAME list_type::const_iterator i =
const_testlist.begin(), e = const_testlist.end(); i != e; i++)
test_seq << *i;
BOOST_CHECK (test_seq.is_equal ("314"));
testlist.erase (++testlist.begin(), testlist.end());
BOOST_CHECK (testlist.size() == 1);
BOOST_CHECK (testlist.front().value_ == 3);
BOOST_TEST (testlist.size() == 1);
BOOST_TEST (testlist.front().value_ == 3);
}
template<class ValueTraits>
@@ -222,7 +202,6 @@ void test_slist<ValueTraits>
::test_shift(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::slist
<ValueTraits
,ValueTraits::value_type::constant_time_size, std::size_t
@@ -239,13 +218,8 @@ void test_slist<ValueTraits>
for(int j = 0; j < num_values; ++j){
expected_values[(j + num_values - i%num_values) % num_values] = (j + 1);
}
std::copy (testlist.begin(), testlist.end(),
std::ostream_iterator<testvalue_t> (test_seq));
std::stringstream stream;
std::copy (expected_values.begin(), expected_values.end(),
std::ostream_iterator<testvalue_t> (stream));
stream << std::ends;
BOOST_CHECK (test_seq.is_equal (stream.str().c_str()));
TEST_INTRUSIVE_SEQUENCE_EXPECTED(expected_values, testlist.begin())
testlist.clear();
}
@@ -256,19 +230,8 @@ void test_slist<ValueTraits>
for(int j = 0; j < num_values; ++j){
expected_values[(j + i) % num_values] = (j + 1);
}
std::copy (testlist.begin(), testlist.end(),
std::ostream_iterator<testvalue_t> (test_seq));
std::stringstream stream2;
std::copy (testlist.begin(), testlist.end(),
std::ostream_iterator<testvalue_t> (stream2));
stream2 << std::ends;
std::stringstream stream;
std::copy (expected_values.begin(), expected_values.end(),
std::ostream_iterator<testvalue_t> (stream));
stream << std::ends;
BOOST_CHECK (test_seq.is_equal (stream.str().c_str()));
TEST_INTRUSIVE_SEQUENCE_EXPECTED(expected_values, testlist.begin())
testlist.clear();
}
}
@@ -279,7 +242,6 @@ void test_slist<ValueTraits>
::test_swap(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::slist
<ValueTraits
,ValueTraits::value_type::constant_time_size, std::size_t
@@ -289,54 +251,41 @@ void test_slist<ValueTraits>
list_type testlist2;
testlist2.insert_after (testlist2.end(), &values[0] + 2, &values[0] + 5);
testlist1.swap(testlist2);
std::copy (testlist1.begin(), testlist1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("345"));
std::copy (testlist2.begin(), testlist2.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("12"));
{ int init_values [] = { 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist1.begin() ); }
{ int init_values [] = { 1, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist2.begin() ); }
testlist2.splice_after (testlist2.begin(), testlist1);
std::copy (testlist2.begin(), testlist2.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("13452"));
BOOST_CHECK (testlist1.empty());
{ int init_values [] = { 1, 3, 4, 5, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist2.begin() ); }
BOOST_TEST (testlist1.empty());
testlist1.splice_after (testlist1.end(), testlist2, ++testlist2.begin());
std::copy (testlist1.begin(), testlist1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("4"));
std::copy (testlist2.begin(), testlist2.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("1352"));
{ int init_values [] = { 4 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist1.begin() ); }
{ int init_values [] = { 1, 3, 5, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist2.begin() ); }
testlist1.splice_after (testlist1.begin(), testlist2,
testlist2.end(), ++++testlist2.begin());
std::copy (testlist1.begin(), testlist1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("4135"));
std::copy (testlist2.begin(), testlist2.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("2"));
{ int init_values [] = { 4, 1, 3, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist1.begin() ); }
{ int init_values [] = { 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist2.begin() ); }
}
{
boost::test_tools::output_test_stream test_seq;
list_type testlist1 (&values[0], &values[0] + 2);
list_type testlist2 (&values[0] + 3, &values[0] + 5);
values[0].swap_nodes(values[2]);
std::copy (testlist1.begin(), testlist1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("32"));
{ int init_values [] = { 3, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist1.begin() ); }
values[2].swap_nodes(values[4]);
std::copy (testlist1.begin(), testlist1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("52"));
std::copy (testlist2.begin(), testlist2.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("43"));
{ int init_values [] = { 5, 2 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist1.begin() ); }
{ int init_values [] = { 4, 3 };
TEST_INTRUSIVE_SEQUENCE( init_values, testlist2.begin() ); }
}
}
@@ -345,7 +294,6 @@ void test_slist<ValueTraits>
::test_clone(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::slist
<ValueTraits
,ValueTraits::value_type::constant_time_size, std::size_t
@@ -355,9 +303,9 @@ void test_slist<ValueTraits>
list_type testlist2;
testlist2.clone_from(testlist1, test::new_cloner(), test::delete_destroyer());
BOOST_CHECK (testlist2 == testlist1);
BOOST_TEST (testlist2 == testlist1);
testlist2.clear_and_destroy(test::delete_destroyer());
BOOST_CHECK (testlist2.empty());
BOOST_TEST (testlist2.empty());
}
template<class VoidPointer, bool constant_time_size>
@@ -371,10 +319,10 @@ class test_main_template
for (int i = 0; i < 5; ++i)
data[i].value_ = i + 1;
test_slist <typename testvalue_t::slist_base_hook::template
test_slist <typename testvalue_t::slist_base_hook_t::template
value_traits<testvalue_t> >::test_all(data);
test_slist <typename testvalue_t::slist_member_hook::template
test_slist <typename testvalue_t::slist_member_hook_t::template
value_traits<testvalue_t, &testvalue_t::slist_node_> >::test_all(data);
return 0;
@@ -392,21 +340,21 @@ class test_main_template<VoidPointer, false>
for (int i = 0; i < 5; ++i)
data[i].value_ = i + 1;
test_slist <typename testvalue_t::slist_base_hook::template
test_slist <typename testvalue_t::slist_base_hook_t::template
value_traits<testvalue_t> >::test_all(data);
test_slist <typename testvalue_t::slist_member_hook::template
test_slist <typename testvalue_t::slist_member_hook_t::template
value_traits<testvalue_t, &testvalue_t::slist_node_> >::test_all(data);
test_slist <typename testvalue_t::slist_auto_base_hook::template
test_slist <typename testvalue_t::slist_auto_base_hook_t::template
value_traits<testvalue_t> >::test_all(data);
test_slist <typename testvalue_t::slist_auto_member_hook::template
test_slist <typename testvalue_t::slist_auto_member_hook_t::template
value_traits<testvalue_t, &testvalue_t::slist_auto_node_> >::test_all(data);
return 0;
}
};
/*
//Explicit instantiations of non-counted classes
template class boost::intrusive::slist<slist_base_raw, false>;
template class boost::intrusive::slist<slist_member_raw, false>;
@@ -422,12 +370,12 @@ template class boost::intrusive::slist<slist_base_raw_t, true>;
template class boost::intrusive::slist<slist_member_raw_t, true>;
template class boost::intrusive::slist<slist_base_smart_t, true>;
template class boost::intrusive::slist<slist_member_smart_t, true>;
int test_main(int, char* [])
*/
int main(int, char* [])
{
test_main_template<void*, false>()();
test_main_template<boost::intrusive::smart_ptr<void>, false>()();
test_main_template<void*, true>()();
test_main_template<boost::intrusive::smart_ptr<void>, true>()();
return 0;
return boost::report_errors();
}

16
test/smart_ptr.hpp
View File

@@ -1,6 +1,6 @@
//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gazta<EFBFBD>aga 2006. Distributed under the Boost
// (C) Copyright Ion Gaztanaga 2006. 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)
//
@@ -43,44 +43,36 @@ struct random_it
template<> struct random_it<void>
{
typedef void * pointer;
typedef const void * const_pointer;
typedef empty_type& reference;
typedef const empty_type& const_reference;
typedef void value_type;
typedef empty_type difference_type;
typedef empty_type iterator_category;
};
template<> struct random_it<const void>
{
typedef const void * pointer;
typedef const void * const_pointer;
typedef const empty_type & reference;
typedef const empty_type & const_reference;
typedef const void value_type;
typedef empty_type difference_type;
typedef empty_type iterator_category;
};
template<> struct random_it<volatile void>
{
typedef volatile void * pointer;
typedef const volatile void * const_pointer;
typedef empty_type& reference;
typedef const empty_type& const_reference;
typedef volatile void value_type;
typedef empty_type difference_type;
typedef empty_type iterator_category;
};
template<> struct random_it<const volatile void>
{
typedef const volatile void * pointer;
typedef const volatile void * const_pointer;
typedef const empty_type & reference;
typedef const empty_type & const_reference;
typedef const volatile void value_type;
typedef empty_type difference_type;
typedef empty_type iterator_category;
};
@@ -104,9 +96,9 @@ class smart_ptr
typedef void (self_t::*unspecified_bool_type)() const;
public:
typedef typename random_it_t::pointer pointer;
typedef PointedType * pointer;
typedef typename random_it_t::reference reference;
typedef typename random_it_t::value_type value_type;
typedef PointedType value_type;
typedef typename random_it_t::difference_type difference_type;
typedef typename random_it_t::iterator_category iterator_category;
@@ -314,7 +306,7 @@ inline void swap (smart_ptr<T> &pt,
/*!get_pointer() enables boost::mem_fn to recognize smart_ptr.
Never throws.*/
template<class T>
inline T * get_pointer(smart_ptr<T> const & p)
inline T* get_pointer(const smart_ptr<T> & p)
{ return p.get(); }
/*!Simulation of static_cast between pointers. Never throws.*/

2
test/test_container.hpp
View File

@@ -1,7 +1,7 @@
//////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2006 Matias Capeletto
// Copyright (c) 2007 Ion Gazta<EFBFBD>aga
// Copyright (c) 2007 Ion Gaztanaga
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at

29
test/test_macros.hpp Normal file
View File

@@ -0,0 +1,29 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2006-2007
//
// 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)
//
// See http://www.boost.org/libs/intrusive for documentation.
//
/////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_INTRUSIVE_TEST_TEST_MACROS_HPP
#define BOOST_INTRUSIVE_TEST_TEST_MACROS_HPP
#define TEST_INTRUSIVE_SEQUENCE( INTVALUES, ITERATOR )\
{ \
const int init_values_size = sizeof(INTVALUES)/sizeof(INTVALUES[0]); \
std::vector<int> expected; \
expected.assign(&INTVALUES[0], &INTVALUES[0] + init_values_size); \
BOOST_TEST (std::equal(expected.begin(), expected.end(), ITERATOR) ); \
}
#define TEST_INTRUSIVE_SEQUENCE_EXPECTED( EXPECTEDVECTOR, ITERATOR )\
{ \
BOOST_TEST (std::equal(EXPECTEDVECTOR.begin(), EXPECTEDVECTOR.end(), ITERATOR) ); \
}
#endif

179
test/unordered_multiset_test.cpp
View File

@@ -1,7 +1,7 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Olaf Krzikalla 2004-2006.
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007.
// (C) Copyright Ion Gaztanaga 2006-2007.
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
@@ -16,11 +16,10 @@
#include "itestvalue.hpp"
#include "smart_ptr.hpp"
#include "common_functors.hpp"
#include <vector>
// Boost.Test
#include "boost/test/included/test_exec_monitor.hpp"
#include <set>
#include <boost/detail/lightweight_test.hpp>
#include "test_macros.hpp"
using namespace boost::intrusive;
@@ -85,8 +84,6 @@ template<class ValueTraits>
void test_unordered_multiset<ValueTraits>::test_sort(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::unordered_multiset
<ValueTraits
,boost::hash<typename ValueTraits::value_type>
@@ -96,12 +93,10 @@ void test_unordered_multiset<ValueTraits>::test_sort(std::vector<typename ValueT
typename unordered_multiset_type::bucket_type buckets [BucketSize];
unordered_multiset_type testset1(buckets, BucketSize, values.begin(), values.end());
std::copy (testset1.begin(), testset1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("122345"));
{ int init_values [] = { 1, 2, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
testset1.clear();
BOOST_CHECK (testset1.empty());
BOOST_TEST (testset1.empty());
}
//test: insert, const_iterator, const_reverse_iterator, erase, iterator_to:
@@ -109,8 +104,6 @@ template<class ValueTraits>
void test_unordered_multiset<ValueTraits>::test_insert(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::unordered_multiset
<ValueTraits
,boost::hash<typename ValueTraits::value_type>
@@ -124,49 +117,44 @@ void test_unordered_multiset<ValueTraits>::test_insert(std::vector<typename Valu
testset.insert(&values[0] + 2, &values[0] + 5);
const unordered_multiset_type& const_testset = testset;
std::copy (const_testset.begin(), const_testset.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("145"));
{ int init_values [] = { 1, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() ); }
BOOST_DEDUCED_TYPENAME unordered_multiset_type::iterator i = testset.begin();
BOOST_CHECK (i->value_ == 1);
typename unordered_multiset_type::iterator i = testset.begin();
BOOST_TEST (i->value_ == 1);
i = testset.insert (values[0]);
BOOST_CHECK (&*i == &values[0]);
BOOST_TEST (&*i == &values[0]);
i = testset.iterator_to (values[2]);
BOOST_CHECK (&*i == &values[2]);
BOOST_TEST (&*i == &values[2]);
testset.erase(i);
//test post-increment:
for (BOOST_DEDUCED_TYPENAME unordered_multiset_type::const_iterator i = const_testset.begin(),
e = const_testset.end(); i != e; i++)
test_seq << *i;
BOOST_CHECK (test_seq.is_equal ("135"));
{ int init_values [] = { 1, 3, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() ); }
testset.clear();
testset.insert(&values[0], &values[0] + values.size());
test_seq.clear();
for (BOOST_DEDUCED_TYPENAME unordered_multiset_type::const_iterator i = const_testset.begin(),
e = const_testset.end(); i != e; i++)
test_seq << *i;
BOOST_CHECK (test_seq.is_equal ("122345"));
BOOST_CHECK (testset.erase(1) == 1);
BOOST_CHECK (testset.erase(2) == 2);
BOOST_CHECK (testset.erase(3) == 1);
BOOST_CHECK (testset.erase(4) == 1);
BOOST_CHECK (testset.erase(5) == 1);
BOOST_CHECK (testset.empty() == true);
{ int init_values [] = { 1, 2, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() ); }
BOOST_TEST (testset.erase(1) == 1);
BOOST_TEST (testset.erase(2) == 2);
BOOST_TEST (testset.erase(3) == 1);
BOOST_TEST (testset.erase(4) == 1);
BOOST_TEST (testset.erase(5) == 1);
BOOST_TEST (testset.empty() == true);
//Now with a single bucket
typename unordered_multiset_type::bucket_type single_bucket[1];
unordered_multiset_type testset2(single_bucket, 1);
testset2.insert(&values[0], &values[0] + values.size());
BOOST_CHECK (testset2.erase(5) == 1);
BOOST_CHECK (testset2.erase(2) == 2);
BOOST_CHECK (testset2.erase(1) == 1);
BOOST_CHECK (testset2.erase(4) == 1);
BOOST_CHECK (testset2.erase(3) == 1);
BOOST_CHECK (testset2.empty() == true);
BOOST_TEST (testset2.erase(5) == 1);
BOOST_TEST (testset2.erase(2) == 2);
BOOST_TEST (testset2.erase(1) == 1);
BOOST_TEST (testset2.erase(4) == 1);
BOOST_TEST (testset2.erase(3) == 1);
BOOST_TEST (testset2.empty() == true);
}
//test: insert (seq-version), swap, erase (seq-version), size:
@@ -174,7 +162,6 @@ template<class ValueTraits>
void test_unordered_multiset<ValueTraits>::test_swap(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::unordered_multiset
<ValueTraits
,boost::hash<typename ValueTraits::value_type>
@@ -190,19 +177,16 @@ void test_unordered_multiset<ValueTraits>::test_swap(std::vector<typename ValueT
testset2.insert (&values[0] + 2, &values[0] + 6);
testset1.swap (testset2);
std::copy (testset1.begin(), testset1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("1245"));
//test post-increment:
for (BOOST_DEDUCED_TYPENAME unordered_multiset_type::iterator i = testset2.begin(),
e = testset2.end(); i != e; i++)
test_seq << *i;
BOOST_CHECK (test_seq.is_equal ("23"));
{ int init_values [] = { 1, 2, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
{ int init_values [] = { 2, 3 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.begin() ); }
testset1.erase (testset1.iterator_to(values[5]), testset1.end());
BOOST_CHECK (testset1.size() == 1);
// BOOST_CHECK (&testset1.front() == &values[3]);
BOOST_CHECK (&*testset1.begin() == &values[3]);
BOOST_TEST (testset1.size() == 1);
// BOOST_TEST (&testset1.front() == &values[3]);
BOOST_TEST (&*testset1.begin() == &values[3]);
}
//test: rehash:
@@ -210,8 +194,6 @@ template<class ValueTraits>
void test_unordered_multiset<ValueTraits>::test_rehash(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::unordered_multiset
<ValueTraits
,boost::hash<typename ValueTraits::value_type>
@@ -221,39 +203,33 @@ void test_unordered_multiset<ValueTraits>::test_rehash(std::vector<typename Valu
typename unordered_multiset_type::bucket_type buckets1 [BucketSize];
unordered_multiset_type testset1(buckets1, BucketSize, &values[0], &values[0] + 6);
BOOST_CHECK (testset1.size() == 6);
std::copy (testset1.begin(), testset1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("122345"));
BOOST_TEST (testset1.size() == 6);
{ int init_values [] = { 1, 2, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
typename unordered_multiset_type::bucket_type buckets2 [2];
testset1.rehash(buckets2, 2);
BOOST_CHECK (testset1.size() == 6);
std::copy (testset1.begin(), testset1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("422531"));
BOOST_TEST (testset1.size() == 6);
{ int init_values [] = { 4, 2, 2, 5, 3, 1 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
typename unordered_multiset_type::bucket_type buckets3 [BucketSize*2];
testset1.rehash(buckets3, BucketSize*2);
BOOST_CHECK (testset1.size() == 6);
std::copy (testset1.begin(), testset1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("122345"));
BOOST_TEST (testset1.size() == 6);
{ int init_values [] = { 1, 2, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
//Now rehash reducing the buckets
testset1.rehash(buckets3, 2);
BOOST_CHECK (testset1.size() == 6);
std::copy (testset1.begin(), testset1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("422531"));
BOOST_TEST (testset1.size() == 6);
{ int init_values [] = { 4, 2, 2, 5, 3, 1 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
//Now rehash increasing the buckets
testset1.rehash(buckets3, BucketSize*2);
BOOST_CHECK (testset1.size() == 6);
std::copy (testset1.begin(), testset1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("122345"));
BOOST_TEST (testset1.size() == 6);
{ int init_values [] = { 1, 2, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
}
//test: find, equal_range (lower_bound, upper_bound):
@@ -261,7 +237,6 @@ template<class ValueTraits>
void test_unordered_multiset<ValueTraits>::test_find(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::unordered_multiset
<ValueTraits
,boost::hash<typename ValueTraits::value_type>
@@ -271,21 +246,21 @@ void test_unordered_multiset<ValueTraits>::test_find(std::vector<typename ValueT
typename unordered_multiset_type::bucket_type buckets[BucketSize];
unordered_multiset_type testset(buckets, BucketSize, values.begin(), values.end());
typedef BOOST_DEDUCED_TYPENAME unordered_multiset_type::iterator iterator;
typedef typename unordered_multiset_type::iterator iterator;
testvalue_t cmp_val;
cmp_val.value_ = 2;
iterator i = testset.find (cmp_val);
BOOST_CHECK (i->value_ == 2);
BOOST_CHECK ((++i)->value_ == 2);
BOOST_TEST (i->value_ == 2);
BOOST_TEST ((++i)->value_ == 2);
std::pair<iterator,iterator> range = testset.equal_range (cmp_val);
BOOST_CHECK (range.first->value_ == 2);
BOOST_CHECK (range.second->value_ == 3);
BOOST_CHECK (std::distance (range.first, range.second) == 2);
BOOST_TEST (range.first->value_ == 2);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (std::distance (range.first, range.second) == 2);
cmp_val.value_ = 7;
BOOST_CHECK (testset.find (cmp_val) == testset.end());
BOOST_TEST (testset.find (cmp_val) == testset.end());
}
@@ -312,9 +287,9 @@ void test_unordered_multiset<ValueTraits>
src(testset1.begin(), testset1.end());
std::multiset<typename ValueTraits::value_type>
dst(testset2.begin(), testset2.end());
BOOST_CHECK (src == dst);
BOOST_TEST (src == dst);
testset2.clear_and_destroy(test::delete_destroyer());
BOOST_CHECK (testset2.empty());
BOOST_TEST (testset2.empty());
}
{
//Test with bigger source bucket arrays
@@ -329,9 +304,9 @@ void test_unordered_multiset<ValueTraits>
src(testset1.begin(), testset1.end());
std::multiset<typename ValueTraits::value_type>
dst(testset2.begin(), testset2.end());
BOOST_CHECK (src == dst);
BOOST_TEST (src == dst);
testset2.clear_and_destroy(test::delete_destroyer());
BOOST_CHECK (testset2.empty());
BOOST_TEST (testset2.empty());
}
{
//Test with smaller source bucket arrays
@@ -346,9 +321,9 @@ void test_unordered_multiset<ValueTraits>
src(testset1.begin(), testset1.end());
std::multiset<typename ValueTraits::value_type>
dst(testset2.begin(), testset2.end());
BOOST_CHECK (src == dst);
BOOST_TEST (src == dst);
testset2.clear_and_destroy(test::delete_destroyer());
BOOST_CHECK (testset2.empty());
BOOST_TEST (testset2.empty());
}
}
@@ -364,10 +339,10 @@ class test_main_template
for (int i = 0; i < 6; ++i)
data[i].value_ = random_init[i];
test_unordered_multiset <typename testvalue_t::unordered_set_base_hook::template
test_unordered_multiset <typename testvalue_t::unordered_set_base_hook_t::template
value_traits<testvalue_t> >::test_all(data);
test_unordered_multiset <typename testvalue_t::unordered_set_member_hook::template
test_unordered_multiset <typename testvalue_t::unordered_set_member_hook_t::template
value_traits<testvalue_t, &testvalue_t::unordered_set_node_> >::test_all(data);
return 0;
@@ -386,21 +361,21 @@ class test_main_template<VoidPointer, false>
for (int i = 0; i < 6; ++i)
data[i].value_ = random_init[i];
test_unordered_multiset <typename testvalue_t::unordered_set_base_hook::template
test_unordered_multiset <typename testvalue_t::unordered_set_base_hook_t::template
value_traits<testvalue_t> >::test_all(data);
test_unordered_multiset <typename testvalue_t::unordered_set_member_hook::template
test_unordered_multiset <typename testvalue_t::unordered_set_member_hook_t::template
value_traits<testvalue_t, &testvalue_t::unordered_set_node_> >::test_all(data);
test_unordered_multiset <typename testvalue_t::unordered_set_auto_base_hook::template
test_unordered_multiset <typename testvalue_t::unordered_set_auto_base_hook_t::template
value_traits<testvalue_t> >::test_all(data);
test_unordered_multiset <typename testvalue_t::unordered_set_auto_member_hook::template
test_unordered_multiset <typename testvalue_t::unordered_set_auto_member_hook_t::template
value_traits<testvalue_t, &testvalue_t::unordered_set_auto_node_> >::test_all(data);
return 0;
}
};
/*
//Explicit instantiations of non-counted classes
template class boost::intrusive::unordered_multiset
< unordered_set_base_raw_t
@@ -452,12 +427,12 @@ template class boost::intrusive::unordered_multiset
< unordered_set_member_smart_t
, boost::hash<unordered_set_member_smart_t::value_type>
, std::equal_to<unordered_set_member_smart_t::value_type>, true>;
int test_main( int, char* [] )
*/
int main( int, char* [] )
{
test_main_template<void*, false>()();
test_main_template<boost::intrusive::smart_ptr<void>, false>()();
test_main_template<void*, true>()();
test_main_template<boost::intrusive::smart_ptr<void>, true>()();
return 0;
return boost::report_errors();
}

147
test/unordered_set_test.cpp
View File

@@ -1,7 +1,7 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Olaf Krzikalla 2004-2006.
// (C) Copyright Ion Gazta<EFBFBD>aga 2006-2007.
// (C) Copyright Ion Gaztanaga 2006-2007.
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
@@ -18,9 +18,8 @@
#include "common_functors.hpp"
#include <vector>
#include <set>
// Boost.Test
#include "boost/test/included/test_exec_monitor.hpp"
#include <boost/detail/lightweight_test.hpp>
#include "test_macros.hpp"
using namespace boost::intrusive;
@@ -75,7 +74,6 @@ void test_unordered_set<ValueTraits>::test_impl()
testset.erase (testset.iterator_to (values[0]));
testset.erase (testset.iterator_to (values[1]));
testset.insert (values[1]);
testset.erase (testset.iterator_to (values[2]));
testset.erase (testset.iterator_to (values[3]));
}
@@ -84,9 +82,7 @@ void test_unordered_set<ValueTraits>::test_impl()
template<class ValueTraits>
void test_unordered_set<ValueTraits>::test_sort(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::unordered_set
<ValueTraits
,boost::hash<typename ValueTraits::value_type>
@@ -96,14 +92,12 @@ void test_unordered_set<ValueTraits>::test_sort(std::vector<typename ValueTraits
typename unordered_set_type::bucket_type buckets [BucketSize];
unordered_set_type testset1(buckets, BucketSize, values.begin(), values.end());
BOOST_CHECK (5 == std::distance(testset1.begin(), testset1.end()));
std::copy (testset1.begin(), testset1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("12345"));
BOOST_TEST (5 == std::distance(testset1.begin(), testset1.end()));
{ int init_values [] = { 1, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
testset1.clear();
BOOST_CHECK (testset1.empty());
BOOST_TEST (testset1.empty());
}
//test: insert, const_iterator, const_reverse_iterator, erase, iterator_to:
@@ -111,7 +105,6 @@ template<class ValueTraits>
void test_unordered_set<ValueTraits>::test_insert(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::unordered_set
<ValueTraits
,boost::hash<typename ValueTraits::value_type>
@@ -123,25 +116,22 @@ void test_unordered_set<ValueTraits>::test_insert(std::vector<typename ValueTrai
testset.insert(&values[0] + 2, &values[0] + 5);
const unordered_set_type& const_testset = testset;
std::copy (const_testset.begin(), const_testset.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("145"));
{ int init_values [] = { 1, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() ); }
BOOST_DEDUCED_TYPENAME unordered_set_type::iterator i = testset.begin();
BOOST_CHECK (i->value_ == 1);
typename unordered_set_type::iterator i = testset.begin();
BOOST_TEST (i->value_ == 1);
i = testset.insert(values[0]).first;
BOOST_CHECK (&*i == &values[0]);
BOOST_TEST (&*i == &values[0]);
i = testset.iterator_to (values[2]);
BOOST_CHECK (&*i == &values[2]);
BOOST_TEST (&*i == &values[2]);
testset.erase (i);
//test post-increment:
for (BOOST_DEDUCED_TYPENAME unordered_set_type::const_iterator i = const_testset.begin(),
e = const_testset.end(); i != e; i++)
test_seq << *i;
BOOST_CHECK (test_seq.is_equal ("135"));
{ int init_values [] = { 1, 3, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() ); }
}
//test: insert (seq-version), swap, erase (seq-version), size:
@@ -149,8 +139,6 @@ template<class ValueTraits>
void test_unordered_set<ValueTraits>::test_swap(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::unordered_set
<ValueTraits
,boost::hash<typename ValueTraits::value_type>
@@ -167,19 +155,15 @@ void test_unordered_set<ValueTraits>::test_swap(std::vector<typename ValueTraits
testset2.insert (&values[0] + 2, &values[0] + 6);
testset1.swap (testset2);
std::copy (testset1.begin(), testset1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("1245"));
//test post-increment:
for (BOOST_DEDUCED_TYPENAME unordered_set_type::iterator i = testset2.begin(),
e = testset2.end(); i != e; i++)
test_seq << *i;
BOOST_CHECK (test_seq.is_equal ("23"));
{ int init_values [] = { 1, 2, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
{ int init_values [] = { 2, 3 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset2.begin() ); }
testset1.erase (testset1.iterator_to(values[5]), testset1.end());
BOOST_CHECK (testset1.size() == 1);
// BOOST_CHECK (&testset1.front() == &values[3]);
BOOST_CHECK (&*testset1.begin() == &values[3]);
BOOST_TEST (testset1.size() == 1);
// BOOST_TEST (&testset1.front() == &values[3]);
BOOST_TEST (&*testset1.begin() == &values[3]);
}
//test: rehash:
@@ -187,8 +171,6 @@ template<class ValueTraits>
void test_unordered_set<ValueTraits>::test_rehash(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::unordered_set
<ValueTraits
,boost::hash<typename ValueTraits::value_type>
@@ -198,38 +180,33 @@ void test_unordered_set<ValueTraits>::test_rehash(std::vector<typename ValueTrai
typename unordered_set_type::bucket_type buckets1 [BucketSize];
unordered_set_type testset1(buckets1, BucketSize, &values[0], &values[0] + 6);
BOOST_CHECK (testset1.size() == 5);
std::copy (testset1.begin(), testset1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("12345"));
BOOST_TEST (testset1.size() == 5);
{ int init_values [] = { 1, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
typename unordered_set_type::bucket_type buckets2 [2];
testset1.rehash(buckets2, 2);
BOOST_CHECK (testset1.size() == 5);
std::copy (testset1.begin(), testset1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("42531"));
BOOST_TEST (testset1.size() == 5);
{ int init_values [] = { 4, 2, 5, 3, 1 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
typename unordered_set_type::bucket_type buckets3 [BucketSize*2];
testset1.rehash(buckets3, BucketSize*2);
BOOST_CHECK (testset1.size() == 5);
std::copy (testset1.begin(), testset1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("12345"));
BOOST_TEST (testset1.size() == 5);
{ int init_values [] = { 1, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
//Now rehash reducing the buckets
testset1.rehash(buckets3, 2);
BOOST_CHECK (testset1.size() == 5);
std::copy (testset1.begin(), testset1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("42531"));
BOOST_TEST (testset1.size() == 5);
{ int init_values [] = { 4, 2, 5, 3, 1 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
//Now rehash increasing the buckets
testset1.rehash(buckets3, BucketSize*2);
BOOST_CHECK (testset1.size() == 5);
std::copy (testset1.begin(), testset1.end(),
std::ostream_iterator<testvalue_t> (test_seq));
BOOST_CHECK (test_seq.is_equal ("12345"));
BOOST_TEST (testset1.size() == 5);
{ int init_values [] = { 1, 2, 3, 4, 5 };
TEST_INTRUSIVE_SEQUENCE( init_values, testset1.begin() ); }
}
@@ -238,8 +215,6 @@ template<class ValueTraits>
void test_unordered_set<ValueTraits>::test_find(std::vector<typename ValueTraits::value_type>& values)
{
typedef typename ValueTraits::value_type testvalue_t;
boost::test_tools::output_test_stream test_seq;
typedef boost::intrusive::unordered_set
<ValueTraits
,boost::hash<typename ValueTraits::value_type>
@@ -248,21 +223,21 @@ void test_unordered_set<ValueTraits>::test_find(std::vector<typename ValueTraits
> unordered_set_type;
typename unordered_set_type::bucket_type buckets [BucketSize];
unordered_set_type testset (buckets, BucketSize, values.begin(), values.end());
typedef BOOST_DEDUCED_TYPENAME unordered_set_type::iterator iterator;
typedef typename unordered_set_type::iterator iterator;
testvalue_t cmp_val;
cmp_val.value_ = 2;
iterator i = testset.find (cmp_val);
BOOST_CHECK (i->value_ == 2);
BOOST_CHECK ((++i)->value_ != 2);
BOOST_TEST (i->value_ == 2);
BOOST_TEST ((++i)->value_ != 2);
std::pair<iterator,iterator> range = testset.equal_range (cmp_val);
BOOST_CHECK (range.first->value_ == 2);
BOOST_CHECK (range.second->value_ == 3);
BOOST_CHECK (std::distance (range.first, range.second) == 1);
BOOST_TEST (range.first->value_ == 2);
BOOST_TEST (range.second->value_ == 3);
BOOST_TEST (std::distance (range.first, range.second) == 1);
cmp_val.value_ = 7;
BOOST_CHECK (testset.find (cmp_val) == testset.end());
BOOST_TEST (testset.find (cmp_val) == testset.end());
}
template<class ValueTraits>
@@ -288,9 +263,9 @@ void test_unordered_set<ValueTraits>
src(testset1.begin(), testset1.end());
std::set<typename ValueTraits::value_type>
dst(testset2.begin(), testset2.end());
BOOST_CHECK (src == dst );
BOOST_TEST (src == dst );
testset2.clear_and_destroy(test::delete_destroyer());
BOOST_CHECK (testset2.empty());
BOOST_TEST (testset2.empty());
}
{
//Test with bigger source bucket arrays
@@ -305,9 +280,9 @@ void test_unordered_set<ValueTraits>
src(testset1.begin(), testset1.end());
std::set<typename ValueTraits::value_type>
dst(testset2.begin(), testset2.end());
BOOST_CHECK (src == dst );
BOOST_TEST (src == dst );
testset2.clear_and_destroy(test::delete_destroyer());
BOOST_CHECK (testset2.empty());
BOOST_TEST (testset2.empty());
}
{
//Test with smaller source bucket arrays
@@ -322,9 +297,9 @@ void test_unordered_set<ValueTraits>
src(testset1.begin(), testset1.end());
std::set<typename ValueTraits::value_type>
dst(testset2.begin(), testset2.end());
BOOST_CHECK (src == dst );
BOOST_TEST (src == dst );
testset2.clear_and_destroy(test::delete_destroyer());
BOOST_CHECK (testset2.empty());
BOOST_TEST (testset2.empty());
}
}
@@ -340,10 +315,10 @@ class test_main_template
for (int i = 0; i < 6; ++i)
data[i].value_ = random_init[i];
test_unordered_set <typename testvalue_t::unordered_set_base_hook::template
test_unordered_set <typename testvalue_t::unordered_set_base_hook_t::template
value_traits<testvalue_t> >::test_all(data);
test_unordered_set <typename testvalue_t::unordered_set_member_hook::template
test_unordered_set <typename testvalue_t::unordered_set_member_hook_t::template
value_traits<testvalue_t, &testvalue_t::unordered_set_node_> >::test_all(data);
return 0;
@@ -362,21 +337,21 @@ class test_main_template<VoidPointer, false>
for (int i = 0; i < 6; ++i)
data[i].value_ = random_init[i];
test_unordered_set <typename testvalue_t::unordered_set_base_hook::template
test_unordered_set <typename testvalue_t::unordered_set_base_hook_t::template
value_traits<testvalue_t> >::test_all(data);
test_unordered_set <typename testvalue_t::unordered_set_member_hook::template
test_unordered_set <typename testvalue_t::unordered_set_member_hook_t::template
value_traits<testvalue_t, &testvalue_t::unordered_set_node_> >::test_all(data);
test_unordered_set <typename testvalue_t::unordered_set_auto_base_hook::template
test_unordered_set <typename testvalue_t::unordered_set_auto_base_hook_t::template
value_traits<testvalue_t> >::test_all(data);
test_unordered_set <typename testvalue_t::unordered_set_auto_member_hook::template
test_unordered_set <typename testvalue_t::unordered_set_auto_member_hook_t::template
value_traits<testvalue_t, &testvalue_t::unordered_set_auto_node_> >::test_all(data);
return 0;
}
};
/*
template class boost::intrusive::unordered_set
< unordered_set_base_raw_t
, boost::hash<unordered_set_base_raw_t::value_type>
@@ -427,12 +402,12 @@ template class boost::intrusive::unordered_set
< unordered_set_member_smart_t
, boost::hash<unordered_set_member_smart_t::value_type>
, std::equal_to<unordered_set_member_smart_t::value_type>, true>;
int test_main( int, char* [] )
*/
int main( int, char* [] )
{
test_main_template<void*, false>()();
test_main_template<boost::intrusive::smart_ptr<void>, false>()();
test_main_template<void*, true>()();
test_main_template<boost::intrusive::smart_ptr<void>, true>()();
return 0;
return boost::report_errors();
}