]>
Commit | Line | Data |
---|---|---|
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 |