]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // (C) Copyright Gennadiy Rozental 2001. |
2 | // Distributed under the Boost Software License, Version 1.0. | |
3 | // (See accompanying file LICENSE_1_0.txt or copy at | |
4 | // http://www.boost.org/LICENSE_1_0.txt) | |
5 | ||
6 | // See http://www.boost.org/libs/test for the library home page. | |
7 | // | |
8 | //!@file | |
9 | //!@brief Collection comparison with enhanced reporting | |
10 | // *************************************************************************** | |
11 | ||
12 | #ifndef BOOST_TEST_TOOLS_COLLECTION_COMPARISON_OP_HPP_050815GER | |
13 | #define BOOST_TEST_TOOLS_COLLECTION_COMPARISON_OP_HPP_050815GER | |
14 | ||
15 | // Boost.Test | |
16 | #include <boost/test/tools/assertion.hpp> | |
17 | ||
18 | #include <boost/test/utils/is_forward_iterable.hpp> | |
19 | ||
20 | // Boost | |
21 | #include <boost/mpl/bool.hpp> | |
22 | #include <boost/utility/enable_if.hpp> | |
23 | #include <boost/type_traits/decay.hpp> | |
24 | ||
25 | #include <boost/test/detail/suppress_warnings.hpp> | |
26 | ||
27 | //____________________________________________________________________________// | |
28 | ||
29 | namespace boost { | |
30 | namespace test_tools { | |
31 | namespace assertion { | |
32 | ||
33 | // ************************************************************************** // | |
34 | // ************* selectors for specialized comparizon routines ************** // | |
35 | // ************************************************************************** // | |
36 | ||
37 | template<typename T> | |
38 | struct specialized_compare : public mpl::false_ {}; | |
39 | ||
40 | #define BOOST_TEST_SPECIALIZED_COLLECTION_COMPARE(Col) \ | |
41 | namespace boost { namespace test_tools { namespace assertion { \ | |
42 | template<> \ | |
43 | struct specialized_compare<Col> : public mpl::true_ {}; \ | |
44 | }}} \ | |
45 | /**/ | |
46 | ||
47 | // ************************************************************************** // | |
48 | // ************** lexicographic_compare ************** // | |
49 | // ************************************************************************** // | |
50 | ||
51 | namespace op { | |
52 | ||
53 | template <typename OP, bool can_be_equal, bool prefer_shorter, | |
54 | typename Lhs, typename Rhs> | |
55 | inline assertion_result | |
56 | lexicographic_compare( Lhs const& lhs, Rhs const& rhs ) | |
57 | { | |
58 | assertion_result ar( true ); | |
59 | ||
60 | typename Lhs::const_iterator first1 = lhs.begin(); | |
61 | typename Rhs::const_iterator first2 = rhs.begin(); | |
62 | typename Lhs::const_iterator last1 = lhs.end(); | |
63 | typename Rhs::const_iterator last2 = rhs.end(); | |
64 | std::size_t pos = 0; | |
65 | ||
66 | for( ; (first1 != last1) && (first2 != last2); ++first1, ++first2, ++pos ) { | |
67 | assertion_result const& element_ar = OP::eval(*first1, *first2); | |
68 | if( !can_be_equal && element_ar ) | |
69 | return ar; // a < b | |
70 | ||
71 | assertion_result const& reverse_ar = OP::eval(*first2, *first1); | |
72 | if( element_ar && !reverse_ar ) | |
73 | return ar; // a<=b and !(b<=a) => a < b => return true | |
74 | ||
75 | if( element_ar || !reverse_ar ) | |
76 | continue; // (a<=b and b<=a) or (!(a<b) and !(b<a)) => a == b => keep looking | |
77 | ||
78 | // !(a<=b) and b<=a => b < a => return false | |
79 | ar = false; | |
80 | ar.message() << "\nFailure at position " << pos << ": " | |
81 | << tt_detail::print_helper(*first1) | |
82 | << OP::revert() | |
83 | << tt_detail::print_helper(*first2) | |
84 | << ". " << element_ar.message(); | |
85 | return ar; | |
86 | } | |
87 | ||
88 | ||
89 | if( first1 != last1 ) { | |
90 | if( prefer_shorter ) { | |
91 | ar = false; | |
92 | ar.message() << "\nFirst collection has extra trailing elements."; | |
93 | } | |
94 | } | |
95 | else if( first2 != last2 ) { | |
96 | if( !prefer_shorter ) { | |
97 | ar = false; | |
98 | ar.message() << "\nSecond collection has extra trailing elements."; | |
99 | } | |
100 | } | |
101 | else if( !can_be_equal ) { | |
102 | ar = false; | |
103 | ar.message() << "\nCollections appear to be equal."; | |
104 | } | |
105 | ||
106 | return ar; | |
107 | } | |
108 | ||
109 | //____________________________________________________________________________// | |
110 | ||
111 | // ************************************************************************** // | |
112 | // ************** equality_compare ************** // | |
113 | // ************************************************************************** // | |
114 | ||
115 | template <typename OP, typename Lhs, typename Rhs> | |
116 | inline assertion_result | |
117 | element_compare( Lhs const& lhs, Rhs const& rhs ) | |
118 | { | |
119 | assertion_result ar( true ); | |
120 | ||
121 | if( lhs.size() != rhs.size() ) { | |
122 | ar = false; | |
123 | ar.message() << "\nCollections size mismatch: " << lhs.size() << " != " << rhs.size(); | |
124 | return ar; | |
125 | } | |
126 | ||
127 | typename Lhs::const_iterator left = lhs.begin(); | |
128 | typename Rhs::const_iterator right = rhs.begin(); | |
129 | std::size_t pos = 0; | |
130 | ||
131 | for( ; pos < lhs.size(); ++left, ++right, ++pos ) { | |
132 | assertion_result const element_ar = OP::eval( *left, *right ); | |
133 | if( element_ar ) | |
134 | continue; | |
135 | ||
136 | ar = false; | |
137 | ar.message() << "\nMismatch at position " << pos << ": " | |
138 | << tt_detail::print_helper(*left) | |
139 | << OP::revert() | |
140 | << tt_detail::print_helper(*right) | |
141 | << ". " << element_ar.message(); | |
142 | } | |
143 | ||
144 | return ar; | |
145 | } | |
146 | ||
147 | //____________________________________________________________________________// | |
148 | ||
149 | // ************************************************************************** // | |
150 | // ************** non_equality_compare ************** // | |
151 | // ************************************************************************** // | |
152 | ||
153 | template <typename OP, typename Lhs, typename Rhs> | |
154 | inline assertion_result | |
155 | non_equality_compare( Lhs const& lhs, Rhs const& rhs ) | |
156 | { | |
157 | assertion_result ar( true ); | |
158 | ||
159 | if( lhs.size() != rhs.size() ) | |
160 | return ar; | |
161 | ||
162 | typename Lhs::const_iterator left = lhs.begin(); | |
163 | typename Rhs::const_iterator right = rhs.begin(); | |
164 | typename Lhs::const_iterator end = lhs.end(); | |
165 | ||
166 | for( ; left != end; ++left, ++right ) { | |
167 | if( OP::eval( *left, *right ) ) | |
168 | return ar; | |
169 | } | |
170 | ||
171 | ar = false; | |
172 | ar.message() << "\nCollections appear to be equal"; | |
173 | ||
174 | return ar; | |
175 | } | |
176 | ||
177 | //____________________________________________________________________________// | |
178 | ||
179 | // ************************************************************************** // | |
180 | // ************** cctraits ************** // | |
181 | // ************************************************************************** // | |
182 | // set of collection comparison traits per comparison OP | |
183 | ||
184 | template<typename OP> | |
185 | struct cctraits; | |
186 | ||
187 | template<typename Lhs, typename Rhs> | |
188 | struct cctraits<op::EQ<Lhs, Rhs> > { | |
189 | typedef specialized_compare<Lhs> is_specialized; | |
190 | }; | |
191 | ||
192 | template<typename Lhs, typename Rhs> | |
193 | struct cctraits<op::NE<Lhs, Rhs> > { | |
194 | typedef specialized_compare<Lhs> is_specialized; | |
195 | }; | |
196 | ||
197 | template<typename Lhs, typename Rhs> | |
198 | struct cctraits<op::LT<Lhs, Rhs> > { | |
199 | static const bool can_be_equal = false; | |
200 | static const bool prefer_short = true; | |
201 | ||
202 | typedef specialized_compare<Lhs> is_specialized; | |
203 | }; | |
204 | ||
205 | template<typename Lhs, typename Rhs> | |
206 | struct cctraits<op::LE<Lhs, Rhs> > { | |
207 | static const bool can_be_equal = true; | |
208 | static const bool prefer_short = true; | |
209 | ||
210 | typedef specialized_compare<Lhs> is_specialized; | |
211 | }; | |
212 | ||
213 | template<typename Lhs, typename Rhs> | |
214 | struct cctraits<op::GT<Lhs, Rhs> > { | |
215 | static const bool can_be_equal = false; | |
216 | static const bool prefer_short = false; | |
217 | ||
218 | typedef specialized_compare<Lhs> is_specialized; | |
219 | }; | |
220 | ||
221 | template<typename Lhs, typename Rhs> | |
222 | struct cctraits<op::GE<Lhs, Rhs> > { | |
223 | static const bool can_be_equal = true; | |
224 | static const bool prefer_short = false; | |
225 | ||
226 | typedef specialized_compare<Lhs> is_specialized; | |
227 | }; | |
228 | ||
229 | // ************************************************************************** // | |
230 | // ************** compare_collections ************** // | |
231 | // ************************************************************************** // | |
232 | // Overloaded set of functions dispatching to specific implementation of comparison | |
233 | ||
234 | template <typename Lhs, typename Rhs, typename L, typename R> | |
235 | inline assertion_result | |
236 | compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::EQ<L, R> >*, mpl::true_ ) | |
237 | { | |
238 | return assertion::op::element_compare<op::EQ<L, R> >( lhs, rhs ); | |
239 | } | |
240 | ||
241 | //____________________________________________________________________________// | |
242 | ||
243 | template <typename Lhs, typename Rhs, typename L, typename R> | |
244 | inline assertion_result | |
245 | compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::EQ<L, R> >*, mpl::false_ ) | |
246 | { | |
247 | return lhs == rhs; | |
248 | } | |
249 | ||
250 | //____________________________________________________________________________// | |
251 | ||
252 | template <typename Lhs, typename Rhs, typename L, typename R> | |
253 | inline assertion_result | |
254 | compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::NE<L, R> >*, mpl::true_ ) | |
255 | { | |
256 | return assertion::op::non_equality_compare<op::NE<L, R> >( lhs, rhs ); | |
257 | } | |
258 | ||
259 | //____________________________________________________________________________// | |
260 | ||
261 | template <typename Lhs, typename Rhs, typename L, typename R> | |
262 | inline assertion_result | |
263 | compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::NE<L, R> >*, mpl::false_ ) | |
264 | { | |
265 | return lhs != rhs; | |
266 | } | |
267 | ||
268 | //____________________________________________________________________________// | |
269 | ||
270 | template <typename OP, typename Lhs, typename Rhs> | |
271 | inline assertion_result | |
272 | lexicographic_compare( Lhs const& lhs, Rhs const& rhs ) | |
273 | { | |
274 | return assertion::op::lexicographic_compare<OP, cctraits<OP>::can_be_equal, cctraits<OP>::prefer_short>( lhs, rhs ); | |
275 | } | |
276 | ||
277 | //____________________________________________________________________________// | |
278 | ||
279 | template <typename Lhs, typename Rhs, typename OP> | |
280 | inline assertion_result | |
281 | compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<OP>*, mpl::true_ ) | |
282 | { | |
283 | return lexicographic_compare<OP>( lhs, rhs ); | |
284 | } | |
285 | ||
286 | //____________________________________________________________________________// | |
287 | ||
288 | template <typename Lhs, typename Rhs, typename L, typename R> | |
289 | inline assertion_result | |
290 | compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::LT<L, R> >*, mpl::false_ ) | |
291 | { | |
292 | return lhs < rhs; | |
293 | } | |
294 | ||
295 | //____________________________________________________________________________// | |
296 | ||
297 | template <typename Lhs, typename Rhs, typename L, typename R> | |
298 | inline assertion_result | |
299 | compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::LE<L, R> >*, mpl::false_ ) | |
300 | { | |
301 | return lhs <= rhs; | |
302 | } | |
303 | ||
304 | //____________________________________________________________________________// | |
305 | ||
306 | template <typename Lhs, typename Rhs, typename L, typename R> | |
307 | inline assertion_result | |
308 | compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::GT<L, R> >*, mpl::false_ ) | |
309 | { | |
310 | return lhs > rhs; | |
311 | } | |
312 | ||
313 | //____________________________________________________________________________// | |
314 | ||
315 | template <typename Lhs, typename Rhs, typename L, typename R> | |
316 | inline assertion_result | |
317 | compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::GE<L, R> >*, mpl::false_ ) | |
318 | { | |
319 | return lhs >= rhs; | |
320 | } | |
321 | ||
322 | //____________________________________________________________________________// | |
323 | ||
324 | // ************************************************************************** // | |
325 | // ********* specialization of comparison operators for collections ********* // | |
326 | // ************************************************************************** // | |
327 | ||
328 | #define DEFINE_COLLECTION_COMPARISON( oper, name, rev ) \ | |
329 | template<typename Lhs,typename Rhs> \ | |
330 | struct name<Lhs,Rhs,typename boost::enable_if_c< \ | |
331 | unit_test::is_forward_iterable<Lhs>::value && \ | |
332 | unit_test::is_forward_iterable<Rhs>::value>::type> { \ | |
333 | public: \ | |
334 | typedef assertion_result result_type; \ | |
335 | \ | |
336 | typedef name<Lhs, Rhs> OP; \ | |
337 | typedef typename \ | |
338 | mpl::if_c<is_same<typename decay<Lhs>::type, \ | |
339 | typename decay<Rhs>::type>::value, \ | |
340 | typename cctraits<OP>::is_specialized, \ | |
341 | mpl::false_>::type is_specialized; \ | |
342 | \ | |
343 | typedef name<typename Lhs::value_type, \ | |
344 | typename Rhs::value_type> elem_op; \ | |
345 | \ | |
346 | static assertion_result \ | |
347 | eval( Lhs const& lhs, Rhs const& rhs) \ | |
348 | { \ | |
349 | return assertion::op::compare_collections( lhs, rhs, \ | |
350 | (boost::type<elem_op>*)0, \ | |
351 | is_specialized() ); \ | |
352 | } \ | |
353 | \ | |
354 | template<typename PrevExprType> \ | |
355 | static void \ | |
356 | report( std::ostream&, \ | |
357 | PrevExprType const&, \ | |
358 | Rhs const& ) {} \ | |
359 | \ | |
360 | static char const* revert() \ | |
361 | { return " " #rev " "; } \ | |
362 | \ | |
363 | }; \ | |
364 | /**/ | |
365 | ||
366 | BOOST_TEST_FOR_EACH_COMP_OP( DEFINE_COLLECTION_COMPARISON ) | |
367 | #undef DEFINE_COLLECTION_COMPARISON | |
368 | ||
369 | //____________________________________________________________________________// | |
370 | ||
371 | } // namespace op | |
372 | } // namespace assertion | |
373 | } // namespace test_tools | |
374 | } // namespace boost | |
375 | ||
376 | #include <boost/test/detail/enable_warnings.hpp> | |
377 | ||
378 | #endif // BOOST_TEST_TOOLS_COLLECTION_COMPARISON_OP_HPP_050815GER |