1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
/*=============================================================================
Copyright (c) 2010 Tim Blechmann
Use, modification and distribution is subject to the Boost Software
License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#define BOOST_TEST_MAIN
#include <boost/test/unit_test.hpp>
#include <boost/heap/skew_heap.hpp>
#include "common_heap_tests.hpp"
#include "merge_heap_tests.hpp"
#include "mutable_heap_tests.hpp"
#include "stable_heap_tests.hpp"
template < bool stable, bool constant_time_size, bool store_parent_pointer >
void run_skew_heap_test( void )
{
typedef boost::heap::skew_heap< int,
boost::heap::stable< stable >,
boost::heap::compare< std::less< int > >,
boost::heap::allocator< std::allocator< int > >,
boost::heap::constant_time_size< constant_time_size >,
boost::heap::store_parent_pointer< store_parent_pointer > >
pri_queue;
BOOST_CONCEPT_ASSERT( (boost::heap::PriorityQueue< pri_queue >));
BOOST_CONCEPT_ASSERT( (boost::heap::MergablePriorityQueue< pri_queue >));
run_common_heap_tests< pri_queue >();
run_iterator_heap_tests< pri_queue >();
run_copyable_heap_tests< pri_queue >();
run_moveable_heap_tests< pri_queue >();
run_merge_tests< pri_queue >();
pri_queue_test_ordered_iterators< pri_queue >();
if ( stable ) {
typedef boost::heap::skew_heap< q_tester,
boost::heap::stable< stable >,
boost::heap::constant_time_size< constant_time_size >,
boost::heap::store_parent_pointer< store_parent_pointer > >
stable_pri_queue;
run_stable_heap_tests< stable_pri_queue >();
}
typedef boost::heap::skew_heap< int,
boost::heap::stable< stable >,
boost::heap::compare< std::less< int > >,
boost::heap::allocator< boost::container::pmr::polymorphic_allocator< int > >,
boost::heap::constant_time_size< constant_time_size >,
boost::heap::store_parent_pointer< store_parent_pointer > >
pmr_pri_queue;
pri_queue_test_stateful_allocator< pmr_pri_queue >();
}
template < bool stable, bool constant_time_size >
void run_skew_heap_mutable_test( void )
{
typedef boost::heap::skew_heap< int,
boost::heap::stable< stable >,
boost::heap::mutable_< true >,
boost::heap::compare< std::less< int > >,
boost::heap::allocator< std::allocator< int > >,
boost::heap::constant_time_size< constant_time_size > >
pri_queue;
BOOST_CONCEPT_ASSERT( (boost::heap::MutablePriorityQueue< pri_queue >));
BOOST_CONCEPT_ASSERT( (boost::heap::MergablePriorityQueue< pri_queue >));
run_common_heap_tests< pri_queue >();
run_iterator_heap_tests< pri_queue >();
run_copyable_heap_tests< pri_queue >();
run_moveable_heap_tests< pri_queue >();
run_merge_tests< pri_queue >();
run_mutable_heap_tests< pri_queue >();
run_ordered_iterator_tests< pri_queue >();
if ( stable ) {
typedef boost::heap::skew_heap< q_tester,
boost::heap::stable< stable >,
boost::heap::mutable_< true >,
boost::heap::constant_time_size< constant_time_size > >
stable_pri_queue;
run_stable_heap_tests< stable_pri_queue >();
}
}
BOOST_AUTO_TEST_CASE( skew_heap_test )
{
run_skew_heap_test< false, false, true >();
run_skew_heap_test< false, true, true >();
run_skew_heap_test< true, false, true >();
run_skew_heap_test< true, true, true >();
run_skew_heap_test< false, false, false >();
run_skew_heap_test< false, true, false >();
run_skew_heap_test< true, false, false >();
run_skew_heap_test< true, true, false >();
RUN_EMPLACE_TEST( skew_heap );
}
BOOST_AUTO_TEST_CASE( skew_heap_mutable_test )
{
run_skew_heap_mutable_test< false, false >();
run_skew_heap_mutable_test< false, true >();
run_skew_heap_mutable_test< true, false >();
run_skew_heap_mutable_test< true, true >();
}
BOOST_AUTO_TEST_CASE( skew_heap_compare_lookup_test )
{
typedef boost::heap::skew_heap< int, boost::heap::compare< less_with_T >, boost::heap::allocator< std::allocator< int > > >
pri_queue;
run_common_heap_tests< pri_queue >();
}
BOOST_AUTO_TEST_CASE( skew_heap_leak_test )
{
typedef boost::heap::skew_heap< boost::shared_ptr< int > > pri_queue;
run_leak_check_test< pri_queue >();
}
|
