1 | // Demonstrate and test boost/operators.hpp on std::iterators --------------// |
2 | |
3 | // (C) Copyright Jeremy Siek 1999. |
4 | // Distributed under the Boost Software License, Version 1.0. (See |
5 | // accompanying file LICENSE_1_0.txt or copy at |
6 | // http://www.boost.org/LICENSE_1_0.txt) |
7 | |
8 | // See http://www.boost.org for most recent version including documentation. |
9 | |
10 | // Revision History |
11 | // 29 May 01 Factored implementation, added comparison tests, use Test Tools |
12 | // library (Daryle Walker) |
13 | // 12 Dec 99 Initial version with iterator operators (Jeremy Siek) |
14 | |
15 | #define BOOST_INCLUDE_MAIN |
16 | #include <boost/test/test_tools.hpp> // for main |
17 | |
18 | #include <boost/config.hpp> // for BOOST_STATIC_CONSTANT |
19 | #include <boost/cstdlib.hpp> // for boost::exit_success |
20 | #include <boost/operators.hpp> // for boost::random_access_iterator_helper |
21 | |
22 | #include <cstddef> // for std::ptrdiff_t, std::size_t |
23 | #include <cstring> // for std::strcmp |
24 | #include <iostream> // for std::cout (std::endl, ends, and flush indirectly) |
25 | #include <string> // for std::string |
26 | #include <sstream> // for std::stringstream |
27 | |
28 | # ifdef BOOST_NO_STDC_NAMESPACE |
29 | namespace std { using ::strcmp; } |
30 | # endif |
31 | |
32 | |
33 | // Iterator test class |
34 | template <class T, class R, class P> |
35 | struct test_iter |
36 | : public boost::random_access_iterator_helper< |
37 | test_iter<T,R,P>, T, std::ptrdiff_t, P, R> |
38 | { |
39 | typedef test_iter self; |
40 | typedef R Reference; |
41 | typedef std::ptrdiff_t Distance; |
42 | |
43 | public: |
44 | explicit test_iter(T* i =0) : _i(i) { } |
45 | test_iter(const self& x) : _i(x._i) { } |
46 | self& operator=(const self& x) { _i = x._i; return *this; } |
47 | Reference operator*() const { return *_i; } |
48 | self& operator++() { ++_i; return *this; } |
49 | self& operator--() { --_i; return *this; } |
50 | self& operator+=(Distance n) { _i += n; return *this; } |
51 | self& operator-=(Distance n) { _i -= n; return *this; } |
52 | bool operator==(const self& x) const { return _i == x._i; } |
53 | bool operator<(const self& x) const { return _i < x._i; } |
54 | friend Distance operator-(const self& x, const self& y) { |
55 | return x._i - y._i; |
56 | } |
57 | protected: |
58 | P _i; |
59 | }; |
60 | |
61 | // Iterator operator testing classes |
62 | class test_opr_base |
63 | { |
64 | protected: |
65 | // Test data and types |
66 | BOOST_STATIC_CONSTANT( std::size_t, fruit_length = 6u ); |
67 | |
68 | typedef std::string fruit_array_type[ fruit_length ]; |
69 | |
70 | static fruit_array_type fruit; |
71 | |
72 | }; // test_opr_base |
73 | |
74 | #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION |
75 | // A definition is required even for integral static constants |
76 | const std::size_t test_opr_base::fruit_length; |
77 | #endif |
78 | |
79 | template <typename T, typename R = T&, typename P = T*> |
80 | class test_opr |
81 | : public test_opr_base |
82 | { |
83 | typedef test_opr<T, R, P> self_type; |
84 | |
85 | public: |
86 | // Types |
87 | typedef T value_type; |
88 | typedef R reference; |
89 | typedef P pointer; |
90 | |
91 | typedef test_iter<T, R, P> iter_type; |
92 | |
93 | // Test controller |
94 | static void master_test( char const name[] ); |
95 | |
96 | private: |
97 | // Test data |
98 | static iter_type const fruit_begin; |
99 | static iter_type const fruit_end; |
100 | |
101 | // Test parts |
102 | static void post_increment_test(); |
103 | static void post_decrement_test(); |
104 | static void indirect_referral_test(); |
105 | static void offset_addition_test(); |
106 | static void reverse_offset_addition_test(); |
107 | static void offset_subtraction_test(); |
108 | static void comparison_test(); |
109 | static void indexing_test(); |
110 | |
111 | }; // test_opr |
112 | |
113 | |
114 | // Class-static data definitions |
115 | test_opr_base::fruit_array_type |
116 | test_opr_base::fruit = { "apple" , "orange" , "pear" , "peach" , "grape" , "plum" }; |
117 | |
118 | template <typename T, typename R, typename P> |
119 | typename test_opr<T, R, P>::iter_type const |
120 | test_opr<T, R, P>::fruit_begin = test_iter<T,R,P>( fruit ); |
121 | |
122 | template <typename T, typename R, typename P> |
123 | typename test_opr<T, R, P>::iter_type const |
124 | test_opr<T, R, P>::fruit_end = test_iter<T,R,P>( fruit + fruit_length ); |
125 | |
126 | |
127 | // Main testing function |
128 | int |
129 | test_main( int , char * [] ) |
130 | { |
131 | using std::string; |
132 | |
133 | typedef test_opr<string, string &, string *> test1_type; |
134 | typedef test_opr<string, string const &, string const *> test2_type; |
135 | |
136 | test1_type::master_test( name: "non-const string" ); |
137 | test2_type::master_test( name: "const string" ); |
138 | |
139 | return boost::exit_success; |
140 | } |
141 | |
142 | // Tests for all of the operators added by random_access_iterator_helper |
143 | template <typename T, typename R, typename P> |
144 | void |
145 | test_opr<T, R, P>::master_test |
146 | ( |
147 | char const name[] |
148 | ) |
149 | { |
150 | std::cout << "Doing test run for " << name << '.' << std::endl; |
151 | |
152 | post_increment_test(); |
153 | post_decrement_test(); |
154 | indirect_referral_test(); |
155 | offset_addition_test(); |
156 | reverse_offset_addition_test(); |
157 | offset_subtraction_test(); |
158 | comparison_test(); |
159 | indexing_test(); |
160 | } |
161 | |
162 | // Test post-increment |
163 | template <typename T, typename R, typename P> |
164 | void |
165 | test_opr<T, R, P>::post_increment_test |
166 | ( |
167 | ) |
168 | { |
169 | std::cout << "\tDoing post-increment test." << std::endl; |
170 | |
171 | std::stringstream oss; |
172 | for ( iter_type i = fruit_begin ; i != fruit_end ; ) |
173 | { |
174 | oss << *i++ << ' '; |
175 | } |
176 | |
177 | BOOST_CHECK( oss.str() == "apple orange pear peach grape plum " ); |
178 | } |
179 | |
180 | // Test post-decrement |
181 | template <typename T, typename R, typename P> |
182 | void |
183 | test_opr<T, R, P>::post_decrement_test |
184 | ( |
185 | ) |
186 | { |
187 | std::cout << "\tDoing post-decrement test." << std::endl; |
188 | |
189 | std::stringstream oss; |
190 | for ( iter_type i = fruit_end ; i != fruit_begin ; ) |
191 | { |
192 | i--; |
193 | oss << *i << ' '; |
194 | } |
195 | |
196 | BOOST_CHECK( oss.str() == "plum grape peach pear orange apple " ); |
197 | } |
198 | |
199 | // Test indirect structure referral |
200 | template <typename T, typename R, typename P> |
201 | void |
202 | test_opr<T, R, P>::indirect_referral_test |
203 | ( |
204 | ) |
205 | { |
206 | std::cout << "\tDoing indirect reference test." << std::endl; |
207 | |
208 | std::stringstream oss; |
209 | for ( iter_type i = fruit_begin ; i != fruit_end ; ++i ) |
210 | { |
211 | oss << i->size() << ' '; |
212 | } |
213 | |
214 | BOOST_CHECK( oss.str() == "5 6 4 5 5 4 " ); |
215 | } |
216 | |
217 | // Test offset addition |
218 | template <typename T, typename R, typename P> |
219 | void |
220 | test_opr<T, R, P>::offset_addition_test |
221 | ( |
222 | ) |
223 | { |
224 | std::cout << "\tDoing offset addition test." << std::endl; |
225 | |
226 | std::ptrdiff_t const two = 2; |
227 | std::stringstream oss; |
228 | for ( iter_type i = fruit_begin ; i != fruit_end ; i = i + two ) |
229 | { |
230 | oss << *i << ' '; |
231 | } |
232 | |
233 | BOOST_CHECK( oss.str() == "apple pear grape " ); |
234 | } |
235 | |
236 | // Test offset addition, in reverse order |
237 | template <typename T, typename R, typename P> |
238 | void |
239 | test_opr<T, R, P>::reverse_offset_addition_test |
240 | ( |
241 | ) |
242 | { |
243 | std::cout << "\tDoing reverse offset addition test." << std::endl; |
244 | |
245 | std::ptrdiff_t const two = 2; |
246 | std::stringstream oss; |
247 | for ( iter_type i = fruit_begin ; i != fruit_end ; i = two + i ) |
248 | { |
249 | oss << *i << ' '; |
250 | } |
251 | |
252 | BOOST_CHECK( oss.str() == "apple pear grape " ); |
253 | } |
254 | |
255 | // Test offset subtraction |
256 | template <typename T, typename R, typename P> |
257 | void |
258 | test_opr<T, R, P>::offset_subtraction_test |
259 | ( |
260 | ) |
261 | { |
262 | std::cout << "\tDoing offset subtraction test." << std::endl; |
263 | |
264 | std::ptrdiff_t const two = 2; |
265 | std::stringstream oss; |
266 | for ( iter_type i = fruit_end ; fruit_begin < i ; ) |
267 | { |
268 | i = i - two; |
269 | if ( (fruit_begin < i) || (fruit_begin == i) ) |
270 | { |
271 | oss << *i << ' '; |
272 | } |
273 | } |
274 | |
275 | BOOST_CHECK( oss.str() == "grape pear apple " ); |
276 | } |
277 | |
278 | // Test comparisons |
279 | template <typename T, typename R, typename P> |
280 | void |
281 | test_opr<T, R, P>::comparison_test |
282 | ( |
283 | ) |
284 | { |
285 | using std::cout; |
286 | using std::ptrdiff_t; |
287 | |
288 | cout << "\tDoing comparison tests.\n\t\tPass:" ; |
289 | |
290 | for ( iter_type i = fruit_begin ; i != fruit_end ; ++i ) |
291 | { |
292 | ptrdiff_t const i_offset = i - fruit_begin; |
293 | |
294 | cout << ' ' << *i << std::flush; |
295 | for ( iter_type j = fruit_begin ; j != fruit_end ; ++j ) |
296 | { |
297 | ptrdiff_t const j_offset = j - fruit_begin; |
298 | |
299 | BOOST_CHECK( (i != j) == (i_offset != j_offset) ); |
300 | BOOST_CHECK( (i > j) == (i_offset > j_offset) ); |
301 | BOOST_CHECK( (i <= j) == (i_offset <= j_offset) ); |
302 | BOOST_CHECK( (i >= j) == (i_offset >= j_offset) ); |
303 | } |
304 | } |
305 | cout << std::endl; |
306 | } |
307 | |
308 | // Test indexing |
309 | template <typename T, typename R, typename P> |
310 | void |
311 | test_opr<T, R, P>::indexing_test |
312 | ( |
313 | ) |
314 | { |
315 | std::cout << "\tDoing indexing test." << std::endl; |
316 | |
317 | std::stringstream oss; |
318 | for ( std::size_t k = 0u ; k < fruit_length ; ++k ) |
319 | { |
320 | oss << fruit_begin[ k ] << ' '; |
321 | } |
322 | |
323 | BOOST_CHECK( oss.str() == "apple orange pear peach grape plum " ); |
324 | } |
325 | |