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 |
265 | |