1 | #ifndef BOOST_NEW_ITERATOR_TESTS_HPP |
---|
2 | # define BOOST_NEW_ITERATOR_TESTS_HPP |
---|
3 | |
---|
4 | // |
---|
5 | // Copyright (c) David Abrahams 2001. |
---|
6 | // Copyright (c) Jeremy Siek 2001-2003. |
---|
7 | // Copyright (c) Thomas Witt 2002. |
---|
8 | // |
---|
9 | // Use, modification and distribution is subject to the |
---|
10 | // Boost Software License, Version 1.0. |
---|
11 | // (See accompanying file LICENSE_1_0.txt or copy at |
---|
12 | // http://www.boost.org/LICENSE_1_0.txt) |
---|
13 | // |
---|
14 | |
---|
15 | // This is meant to be the beginnings of a comprehensive, generic |
---|
16 | // test suite for STL concepts such as iterators and containers. |
---|
17 | // |
---|
18 | // Revision History: |
---|
19 | // 28 Oct 2002 Started update for new iterator categories |
---|
20 | // (Jeremy Siek) |
---|
21 | // 28 Apr 2002 Fixed input iterator requirements. |
---|
22 | // For a == b a++ == b++ is no longer required. |
---|
23 | // See 24.1.1/3 for details. |
---|
24 | // (Thomas Witt) |
---|
25 | // 08 Feb 2001 Fixed bidirectional iterator test so that |
---|
26 | // --i is no longer a precondition. |
---|
27 | // (Jeremy Siek) |
---|
28 | // 04 Feb 2001 Added lvalue test, corrected preconditions |
---|
29 | // (David Abrahams) |
---|
30 | |
---|
31 | # include <iterator> |
---|
32 | # include <boost/type_traits.hpp> |
---|
33 | # include <boost/static_assert.hpp> |
---|
34 | # include <boost/concept_archetype.hpp> // for detail::dummy_constructor |
---|
35 | # include <boost/detail/iterator.hpp> |
---|
36 | # include <boost/pending/iterator_tests.hpp> |
---|
37 | # include <boost/iterator/is_readable_iterator.hpp> |
---|
38 | # include <boost/iterator/is_lvalue_iterator.hpp> |
---|
39 | |
---|
40 | # include <boost/iterator/detail/config_def.hpp> |
---|
41 | # include <boost/detail/is_incrementable.hpp> |
---|
42 | # include <boost/detail/lightweight_test.hpp> |
---|
43 | |
---|
44 | namespace boost { |
---|
45 | |
---|
46 | |
---|
47 | // Do separate tests for *i++ so we can treat, e.g., smart pointers, |
---|
48 | // as readable and/or writable iterators. |
---|
49 | template <class Iterator, class T> |
---|
50 | void readable_iterator_traversal_test(Iterator i1, T v, mpl::true_) |
---|
51 | { |
---|
52 | T v2(*i1++); |
---|
53 | BOOST_TEST(v == v2); |
---|
54 | } |
---|
55 | |
---|
56 | template <class Iterator, class T> |
---|
57 | void readable_iterator_traversal_test(const Iterator i1, T v, mpl::false_) |
---|
58 | {} |
---|
59 | |
---|
60 | template <class Iterator, class T> |
---|
61 | void writable_iterator_traversal_test(Iterator i1, T v, mpl::true_) |
---|
62 | { |
---|
63 | ++i1; // we just wrote into that position |
---|
64 | *i1++ = v; |
---|
65 | Iterator x(i1++); |
---|
66 | (void)x; |
---|
67 | } |
---|
68 | |
---|
69 | template <class Iterator, class T> |
---|
70 | void writable_iterator_traversal_test(const Iterator i1, T v, mpl::false_) |
---|
71 | {} |
---|
72 | |
---|
73 | |
---|
74 | // Preconditions: *i == v |
---|
75 | template <class Iterator, class T> |
---|
76 | void readable_iterator_test(const Iterator i1, T v) |
---|
77 | { |
---|
78 | Iterator i2(i1); // Copy Constructible |
---|
79 | typedef typename detail::iterator_traits<Iterator>::reference ref_t; |
---|
80 | ref_t r1 = *i1; |
---|
81 | ref_t r2 = *i2; |
---|
82 | T v1 = r1; |
---|
83 | T v2 = r2; |
---|
84 | BOOST_TEST(v1 == v); |
---|
85 | BOOST_TEST(v2 == v); |
---|
86 | |
---|
87 | # if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407) |
---|
88 | readable_iterator_traversal_test(i1, v, detail::is_postfix_incrementable<Iterator>()); |
---|
89 | |
---|
90 | // I think we don't really need this as it checks the same things as |
---|
91 | // the above code. |
---|
92 | BOOST_STATIC_ASSERT(is_readable_iterator<Iterator>::value); |
---|
93 | # endif |
---|
94 | } |
---|
95 | |
---|
96 | template <class Iterator, class T> |
---|
97 | void writable_iterator_test(Iterator i, T v, T v2) |
---|
98 | { |
---|
99 | Iterator i2(i); // Copy Constructible |
---|
100 | *i2 = v; |
---|
101 | |
---|
102 | # if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407) |
---|
103 | writable_iterator_traversal_test( |
---|
104 | i, v2, mpl::and_< |
---|
105 | detail::is_incrementable<Iterator> |
---|
106 | , detail::is_postfix_incrementable<Iterator> |
---|
107 | >()); |
---|
108 | # endif |
---|
109 | } |
---|
110 | |
---|
111 | template <class Iterator> |
---|
112 | void swappable_iterator_test(Iterator i, Iterator j) |
---|
113 | { |
---|
114 | Iterator i2(i), j2(j); |
---|
115 | typename detail::iterator_traits<Iterator>::value_type bi = *i, bj = *j; |
---|
116 | iter_swap(i2, j2); |
---|
117 | typename detail::iterator_traits<Iterator>::value_type ai = *i, aj = *j; |
---|
118 | BOOST_TEST(bi == aj && bj == ai); |
---|
119 | } |
---|
120 | |
---|
121 | template <class Iterator, class T> |
---|
122 | void constant_lvalue_iterator_test(Iterator i, T v1) |
---|
123 | { |
---|
124 | Iterator i2(i); |
---|
125 | typedef typename detail::iterator_traits<Iterator>::value_type value_type; |
---|
126 | typedef typename detail::iterator_traits<Iterator>::reference reference; |
---|
127 | BOOST_STATIC_ASSERT((is_same<const value_type&, reference>::value)); |
---|
128 | const T& v2 = *i2; |
---|
129 | BOOST_TEST(v1 == v2); |
---|
130 | # ifndef BOOST_NO_LVALUE_RETURN_DETECTION |
---|
131 | BOOST_STATIC_ASSERT(is_lvalue_iterator<Iterator>::value); |
---|
132 | BOOST_STATIC_ASSERT(!is_non_const_lvalue_iterator<Iterator>::value); |
---|
133 | # endif |
---|
134 | } |
---|
135 | |
---|
136 | template <class Iterator, class T> |
---|
137 | void non_const_lvalue_iterator_test(Iterator i, T v1, T v2) |
---|
138 | { |
---|
139 | Iterator i2(i); |
---|
140 | typedef typename detail::iterator_traits<Iterator>::value_type value_type; |
---|
141 | typedef typename detail::iterator_traits<Iterator>::reference reference; |
---|
142 | BOOST_STATIC_ASSERT((is_same<value_type&, reference>::value)); |
---|
143 | T& v3 = *i2; |
---|
144 | BOOST_TEST(v1 == v3); |
---|
145 | |
---|
146 | // A non-const lvalue iterator is not neccessarily writable, but we |
---|
147 | // are assuming the value_type is assignable here |
---|
148 | *i = v2; |
---|
149 | |
---|
150 | T& v4 = *i2; |
---|
151 | BOOST_TEST(v2 == v4); |
---|
152 | # ifndef BOOST_NO_LVALUE_RETURN_DETECTION |
---|
153 | BOOST_STATIC_ASSERT(is_lvalue_iterator<Iterator>::value); |
---|
154 | BOOST_STATIC_ASSERT(is_non_const_lvalue_iterator<Iterator>::value); |
---|
155 | # endif |
---|
156 | } |
---|
157 | |
---|
158 | template <class Iterator, class T> |
---|
159 | void forward_readable_iterator_test(Iterator i, Iterator j, T val1, T val2) |
---|
160 | { |
---|
161 | Iterator i2; |
---|
162 | Iterator i3(i); |
---|
163 | i2 = i; |
---|
164 | BOOST_TEST(i2 == i3); |
---|
165 | BOOST_TEST(i != j); |
---|
166 | BOOST_TEST(i2 != j); |
---|
167 | readable_iterator_test(i, val1); |
---|
168 | readable_iterator_test(i2, val1); |
---|
169 | readable_iterator_test(i3, val1); |
---|
170 | |
---|
171 | BOOST_TEST(i == i2++); |
---|
172 | BOOST_TEST(i != ++i3); |
---|
173 | |
---|
174 | readable_iterator_test(i2, val2); |
---|
175 | readable_iterator_test(i3, val2); |
---|
176 | |
---|
177 | readable_iterator_test(i, val1); |
---|
178 | } |
---|
179 | |
---|
180 | template <class Iterator, class T> |
---|
181 | void forward_swappable_iterator_test(Iterator i, Iterator j, T val1, T val2) |
---|
182 | { |
---|
183 | forward_readable_iterator_test(i, j, val1, val2); |
---|
184 | Iterator i2 = i; |
---|
185 | ++i2; |
---|
186 | swappable_iterator_test(i, i2); |
---|
187 | } |
---|
188 | |
---|
189 | // bidirectional |
---|
190 | // Preconditions: *i == v1, *++i == v2 |
---|
191 | template <class Iterator, class T> |
---|
192 | void bidirectional_readable_iterator_test(Iterator i, T v1, T v2) |
---|
193 | { |
---|
194 | Iterator j(i); |
---|
195 | ++j; |
---|
196 | forward_readable_iterator_test(i, j, v1, v2); |
---|
197 | ++i; |
---|
198 | |
---|
199 | Iterator i1 = i, i2 = i; |
---|
200 | |
---|
201 | BOOST_TEST(i == i1--); |
---|
202 | BOOST_TEST(i != --i2); |
---|
203 | |
---|
204 | readable_iterator_test(i, v2); |
---|
205 | readable_iterator_test(i1, v1); |
---|
206 | readable_iterator_test(i2, v1); |
---|
207 | |
---|
208 | --i; |
---|
209 | BOOST_TEST(i == i1); |
---|
210 | BOOST_TEST(i == i2); |
---|
211 | ++i1; |
---|
212 | ++i2; |
---|
213 | |
---|
214 | readable_iterator_test(i, v1); |
---|
215 | readable_iterator_test(i1, v2); |
---|
216 | readable_iterator_test(i2, v2); |
---|
217 | } |
---|
218 | |
---|
219 | // random access |
---|
220 | // Preconditions: [i,i+N) is a valid range |
---|
221 | template <class Iterator, class TrueVals> |
---|
222 | void random_access_readable_iterator_test(Iterator i, int N, TrueVals vals) |
---|
223 | { |
---|
224 | bidirectional_readable_iterator_test(i, vals[0], vals[1]); |
---|
225 | const Iterator j = i; |
---|
226 | int c; |
---|
227 | |
---|
228 | for (c = 0; c < N-1; ++c) |
---|
229 | { |
---|
230 | BOOST_TEST(i == j + c); |
---|
231 | BOOST_TEST(*i == vals[c]); |
---|
232 | typename detail::iterator_traits<Iterator>::value_type x = j[c]; |
---|
233 | BOOST_TEST(*i == x); |
---|
234 | BOOST_TEST(*i == *(j + c)); |
---|
235 | BOOST_TEST(*i == *(c + j)); |
---|
236 | ++i; |
---|
237 | BOOST_TEST(i > j); |
---|
238 | BOOST_TEST(i >= j); |
---|
239 | BOOST_TEST(j <= i); |
---|
240 | BOOST_TEST(j < i); |
---|
241 | } |
---|
242 | |
---|
243 | Iterator k = j + N - 1; |
---|
244 | for (c = 0; c < N-1; ++c) |
---|
245 | { |
---|
246 | BOOST_TEST(i == k - c); |
---|
247 | BOOST_TEST(*i == vals[N - 1 - c]); |
---|
248 | typename detail::iterator_traits<Iterator>::value_type x = j[N - 1 - c]; |
---|
249 | BOOST_TEST(*i == x); |
---|
250 | Iterator q = k - c; |
---|
251 | BOOST_TEST(*i == *q); |
---|
252 | BOOST_TEST(i > j); |
---|
253 | BOOST_TEST(i >= j); |
---|
254 | BOOST_TEST(j <= i); |
---|
255 | BOOST_TEST(j < i); |
---|
256 | --i; |
---|
257 | } |
---|
258 | } |
---|
259 | |
---|
260 | } // namespace boost |
---|
261 | |
---|
262 | # include <boost/iterator/detail/config_undef.hpp> |
---|
263 | |
---|
264 | #endif // BOOST_NEW_ITERATOR_TESTS_HPP |
---|