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 | #include <boost/test/utils/is_cstring.hpp> |
20 | |
21 | // Boost |
22 | #include <boost/mpl/bool.hpp> |
23 | #include <boost/mpl/if.hpp> |
24 | #include <boost/utility/enable_if.hpp> |
25 | #include <boost/type_traits/decay.hpp> |
26 | |
27 | #include <boost/test/detail/suppress_warnings.hpp> |
28 | |
29 | //____________________________________________________________________________// |
30 | |
31 | namespace boost { |
32 | namespace test_tools { |
33 | namespace assertion { |
34 | |
35 | // ************************************************************************** // |
36 | // ************* selectors for specialized comparizon routines ************** // |
37 | // ************************************************************************** // |
38 | |
39 | template<typename T> |
40 | struct specialized_compare : public mpl::false_ {}; |
41 | |
42 | template <typename T> |
43 | struct is_c_array : public mpl::false_ {}; |
44 | |
45 | template<typename T, std::size_t N> |
46 | struct is_c_array<T [N]> : public mpl::true_ {}; |
47 | |
48 | template<typename T, std::size_t N> |
49 | struct is_c_array<T (&)[N]> : public mpl::true_ {}; |
50 | |
51 | #define BOOST_TEST_SPECIALIZED_COLLECTION_COMPARE(Col) \ |
52 | namespace boost { namespace test_tools { namespace assertion { \ |
53 | template<> \ |
54 | struct specialized_compare<Col> : public mpl::true_ {}; \ |
55 | }}} \ |
56 | /**/ |
57 | |
58 | // ************************************************************************** // |
59 | // ************** lexicographic_compare ************** // |
60 | // ************************************************************************** // |
61 | |
62 | namespace op { |
63 | |
64 | template <typename OP, bool can_be_equal, bool prefer_shorter, |
65 | typename Lhs, typename Rhs> |
66 | inline |
67 | typename boost::enable_if_c< |
68 | unit_test::is_forward_iterable<Lhs>::value && !unit_test::is_cstring<Lhs>::value |
69 | && unit_test::is_forward_iterable<Rhs>::value && !unit_test::is_cstring<Rhs>::value, |
70 | assertion_result>::type |
71 | lexicographic_compare( Lhs const& lhs, Rhs const& rhs ) |
72 | { |
73 | assertion_result ar( true ); |
74 | |
75 | typedef unit_test::bt_iterator_traits<Lhs> t_Lhs_iterator; |
76 | typedef unit_test::bt_iterator_traits<Rhs> t_Rhs_iterator; |
77 | |
78 | typename t_Lhs_iterator::const_iterator first1 = t_Lhs_iterator::begin(lhs); |
79 | typename t_Rhs_iterator::const_iterator first2 = t_Rhs_iterator::begin(rhs); |
80 | typename t_Lhs_iterator::const_iterator last1 = t_Lhs_iterator::end(lhs); |
81 | typename t_Rhs_iterator::const_iterator last2 = t_Rhs_iterator::end(rhs); |
82 | std::size_t pos = 0; |
83 | |
84 | for( ; (first1 != last1) && (first2 != last2); ++first1, ++first2, ++pos ) { |
85 | assertion_result const& element_ar = OP::eval(*first1, *first2); |
86 | if( !can_be_equal && element_ar ) |
87 | return ar; // a < b |
88 | |
89 | assertion_result const& reverse_ar = OP::eval(*first2, *first1); |
90 | if( element_ar && !reverse_ar ) |
91 | return ar; // a<=b and !(b<=a) => a < b => return true |
92 | |
93 | if( element_ar || !reverse_ar ) { |
94 | continue; // (a<=b and b<=a) or (!(a<b) and !(b<a)) => a == b => keep looking |
95 | } |
96 | |
97 | // !(a<=b) and b<=a => b < a => return false |
98 | ar = false; |
99 | ar.message() << "\nFailure at position " << pos << ":" ; |
100 | ar.message() << "\n - condition [" << tt_detail::print_helper(*first1) << OP::forward() << tt_detail::print_helper(*first2) << "] is false" ; |
101 | if(!element_ar.has_empty_message()) |
102 | ar.message() << ": " << element_ar.message(); |
103 | ar.message() << "\n - inverse condition [" << tt_detail::print_helper(*first2) << OP::forward() << tt_detail::print_helper(*first1) << "] is true" ; |
104 | if(!reverse_ar.has_empty_message()) |
105 | ar.message() << ": " << reverse_ar.message(); |
106 | return ar; |
107 | } |
108 | |
109 | if( first1 != last1 ) { |
110 | if( prefer_shorter ) { |
111 | ar = false; |
112 | ar.message() << "\nFirst collection has extra trailing elements." ; |
113 | } |
114 | } |
115 | else if( first2 != last2 ) { |
116 | if( !prefer_shorter ) { |
117 | ar = false; |
118 | ar.message() << "\nSecond collection has extra trailing elements." ; |
119 | } |
120 | } |
121 | else if( !can_be_equal ) { |
122 | ar = false; |
123 | ar.message() << "\nCollections appear to be equal." ; |
124 | } |
125 | |
126 | return ar; |
127 | } |
128 | |
129 | template <typename OP, bool can_be_equal, bool prefer_shorter, |
130 | typename Lhs, typename Rhs> |
131 | inline |
132 | typename boost::enable_if_c< |
133 | (unit_test::is_cstring<Lhs>::value || unit_test::is_cstring<Rhs>::value), |
134 | assertion_result>::type |
135 | lexicographic_compare( Lhs const& lhs, Rhs const& rhs ) |
136 | { |
137 | typedef typename unit_test::deduce_cstring_transform<Lhs>::type lhs_char_type; |
138 | typedef typename unit_test::deduce_cstring_transform<Rhs>::type rhs_char_type; |
139 | |
140 | return lexicographic_compare<OP, can_be_equal, prefer_shorter>( |
141 | lhs_char_type(lhs), |
142 | rhs_char_type(rhs)); |
143 | } |
144 | |
145 | //____________________________________________________________________________// |
146 | |
147 | // ************************************************************************** // |
148 | // ************** equality_compare ************** // |
149 | // ************************************************************************** // |
150 | |
151 | template <typename OP, typename Lhs, typename Rhs> |
152 | inline |
153 | typename boost::enable_if_c< |
154 | unit_test::is_forward_iterable<Lhs>::value && !unit_test::is_cstring<Lhs>::value |
155 | && unit_test::is_forward_iterable<Rhs>::value && !unit_test::is_cstring<Rhs>::value, |
156 | assertion_result>::type |
157 | element_compare( Lhs const& lhs, Rhs const& rhs ) |
158 | { |
159 | typedef unit_test::bt_iterator_traits<Lhs> t_Lhs_iterator; |
160 | typedef unit_test::bt_iterator_traits<Rhs> t_Rhs_iterator; |
161 | |
162 | assertion_result ar( true ); |
163 | |
164 | if( t_Lhs_iterator::size(lhs) != t_Rhs_iterator::size(rhs) ) { |
165 | ar = false; |
166 | ar.message() << "\nCollections size mismatch: " << t_Lhs_iterator::size(lhs) << " != " << t_Rhs_iterator::size(rhs); |
167 | return ar; |
168 | } |
169 | |
170 | typename t_Lhs_iterator::const_iterator left = t_Lhs_iterator::begin(lhs); |
171 | typename t_Rhs_iterator::const_iterator right = t_Rhs_iterator::begin(rhs); |
172 | std::size_t pos = 0; |
173 | |
174 | for( ; pos < t_Lhs_iterator::size(lhs); ++left, ++right, ++pos ) { |
175 | assertion_result const element_ar = OP::eval( *left, *right ); |
176 | if( element_ar ) |
177 | continue; |
178 | |
179 | ar = false; |
180 | ar.message() << "\n - mismatch at position " << pos << ": [" |
181 | << tt_detail::print_helper(*left) |
182 | << OP::forward() |
183 | << tt_detail::print_helper(*right) |
184 | << "] is false" ; |
185 | if(!element_ar.has_empty_message()) |
186 | ar.message() << ": " << element_ar.message(); |
187 | } |
188 | |
189 | return ar; |
190 | } |
191 | |
192 | // In case string comparison is branching here |
193 | template <typename OP, typename Lhs, typename Rhs> |
194 | inline |
195 | typename boost::enable_if_c< |
196 | (unit_test::is_cstring<Lhs>::value || unit_test::is_cstring<Rhs>::value), |
197 | assertion_result>::type |
198 | element_compare( Lhs const& lhs, Rhs const& rhs ) |
199 | { |
200 | typedef typename unit_test::deduce_cstring_transform<Lhs>::type lhs_char_type; |
201 | typedef typename unit_test::deduce_cstring_transform<Rhs>::type rhs_char_type; |
202 | |
203 | return element_compare<OP>(lhs_char_type(lhs), |
204 | rhs_char_type(rhs)); |
205 | } |
206 | |
207 | //____________________________________________________________________________// |
208 | |
209 | // ************************************************************************** // |
210 | // ************** non_equality_compare ************** // |
211 | // ************************************************************************** // |
212 | |
213 | template <typename OP, typename Lhs, typename Rhs> |
214 | inline assertion_result |
215 | non_equality_compare( Lhs const& lhs, Rhs const& rhs ) |
216 | { |
217 | typedef unit_test::bt_iterator_traits<Lhs> t_Lhs_iterator; |
218 | typedef unit_test::bt_iterator_traits<Rhs> t_Rhs_iterator; |
219 | |
220 | assertion_result ar( true ); |
221 | |
222 | if( t_Lhs_iterator::size(lhs) != t_Rhs_iterator::size(rhs) ) |
223 | return ar; |
224 | |
225 | typename t_Lhs_iterator::const_iterator left = t_Lhs_iterator::begin(lhs); |
226 | typename t_Rhs_iterator::const_iterator right = t_Rhs_iterator::begin(rhs); |
227 | typename t_Lhs_iterator::const_iterator end = t_Lhs_iterator::end(lhs); |
228 | |
229 | for( ; left != end; ++left, ++right ) { |
230 | if( OP::eval( *left, *right ) ) |
231 | return ar; |
232 | } |
233 | |
234 | ar = false; |
235 | ar.message() << "\nCollections appear to be equal" ; |
236 | |
237 | return ar; |
238 | } |
239 | |
240 | //____________________________________________________________________________// |
241 | |
242 | // ************************************************************************** // |
243 | // ************** cctraits ************** // |
244 | // ************************************************************************** // |
245 | // set of collection comparison traits per comparison OP |
246 | |
247 | template<typename OP> |
248 | struct cctraits; |
249 | |
250 | template<typename Lhs, typename Rhs> |
251 | struct cctraits<op::EQ<Lhs, Rhs> > { |
252 | typedef specialized_compare<Lhs> is_specialized; |
253 | }; |
254 | |
255 | template<typename Lhs, typename Rhs> |
256 | struct cctraits<op::NE<Lhs, Rhs> > { |
257 | typedef specialized_compare<Lhs> is_specialized; |
258 | }; |
259 | |
260 | template<typename Lhs, typename Rhs> |
261 | struct cctraits<op::LT<Lhs, Rhs> > { |
262 | static const bool can_be_equal = false; |
263 | static const bool prefer_short = true; |
264 | |
265 | typedef specialized_compare<Lhs> is_specialized; |
266 | }; |
267 | |
268 | template<typename Lhs, typename Rhs> |
269 | struct cctraits<op::LE<Lhs, Rhs> > { |
270 | static const bool can_be_equal = true; |
271 | static const bool prefer_short = true; |
272 | |
273 | typedef specialized_compare<Lhs> is_specialized; |
274 | }; |
275 | |
276 | template<typename Lhs, typename Rhs> |
277 | struct cctraits<op::GT<Lhs, Rhs> > { |
278 | static const bool can_be_equal = false; |
279 | static const bool prefer_short = false; |
280 | |
281 | typedef specialized_compare<Lhs> is_specialized; |
282 | }; |
283 | |
284 | template<typename Lhs, typename Rhs> |
285 | struct cctraits<op::GE<Lhs, Rhs> > { |
286 | static const bool can_be_equal = true; |
287 | static const bool prefer_short = false; |
288 | |
289 | typedef specialized_compare<Lhs> is_specialized; |
290 | }; |
291 | |
292 | // ************************************************************************** // |
293 | // ************** compare_collections ************** // |
294 | // ************************************************************************** // |
295 | // Overloaded set of functions dispatching to specific implementation of comparison |
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::EQ<L, R> >*, mpl::true_ ) |
300 | { |
301 | return assertion::op::element_compare<op::EQ<L, R> >( 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::EQ<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::NE<L, R> >*, mpl::true_ ) |
318 | { |
319 | return assertion::op::non_equality_compare<op::NE<L, R> >( lhs, rhs ); |
320 | } |
321 | |
322 | //____________________________________________________________________________// |
323 | |
324 | template <typename Lhs, typename Rhs, typename L, typename R> |
325 | inline assertion_result |
326 | compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::NE<L, R> >*, mpl::false_ ) |
327 | { |
328 | return lhs != rhs; |
329 | } |
330 | |
331 | //____________________________________________________________________________// |
332 | |
333 | template <typename OP, typename Lhs, typename Rhs> |
334 | inline assertion_result |
335 | lexicographic_compare( Lhs const& lhs, Rhs const& rhs ) |
336 | { |
337 | return assertion::op::lexicographic_compare<OP, cctraits<OP>::can_be_equal, cctraits<OP>::prefer_short>( lhs, rhs ); |
338 | } |
339 | |
340 | //____________________________________________________________________________// |
341 | |
342 | template <typename Lhs, typename Rhs, typename OP> |
343 | inline assertion_result |
344 | compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<OP>*, mpl::true_ ) |
345 | { |
346 | return lexicographic_compare<OP>( lhs, rhs ); |
347 | } |
348 | |
349 | //____________________________________________________________________________// |
350 | |
351 | template <typename Lhs, typename Rhs, typename L, typename R> |
352 | inline assertion_result |
353 | compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::LT<L, R> >*, mpl::false_ ) |
354 | { |
355 | return lhs < rhs; |
356 | } |
357 | |
358 | //____________________________________________________________________________// |
359 | |
360 | template <typename Lhs, typename Rhs, typename L, typename R> |
361 | inline assertion_result |
362 | compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::LE<L, R> >*, mpl::false_ ) |
363 | { |
364 | return lhs <= rhs; |
365 | } |
366 | |
367 | //____________________________________________________________________________// |
368 | |
369 | template <typename Lhs, typename Rhs, typename L, typename R> |
370 | inline assertion_result |
371 | compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::GT<L, R> >*, mpl::false_ ) |
372 | { |
373 | return lhs > rhs; |
374 | } |
375 | |
376 | //____________________________________________________________________________// |
377 | |
378 | template <typename Lhs, typename Rhs, typename L, typename R> |
379 | inline assertion_result |
380 | compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::GE<L, R> >*, mpl::false_ ) |
381 | { |
382 | return lhs >= rhs; |
383 | } |
384 | |
385 | //____________________________________________________________________________// |
386 | |
387 | // ************************************************************************** // |
388 | // ********* specialization of comparison operators for collections ********* // |
389 | // ************************************************************************** // |
390 | |
391 | #define DEFINE_COLLECTION_COMPARISON( oper, name, rev, name_inverse ) \ |
392 | template<typename Lhs,typename Rhs> \ |
393 | struct name<Lhs,Rhs,typename boost::enable_if_c< \ |
394 | unit_test::is_forward_iterable<Lhs>::value \ |
395 | && !unit_test::is_cstring_comparable<Lhs>::value \ |
396 | && unit_test::is_forward_iterable<Rhs>::value \ |
397 | && !unit_test::is_cstring_comparable<Rhs>::value>::type> { \ |
398 | public: \ |
399 | typedef assertion_result result_type; \ |
400 | typedef name_inverse<Lhs, Rhs> inverse; \ |
401 | typedef unit_test::bt_iterator_traits<Lhs> t_Lhs_iterator_helper; \ |
402 | typedef unit_test::bt_iterator_traits<Rhs> t_Rhs_iterator_helper; \ |
403 | \ |
404 | typedef name<Lhs, Rhs> OP; \ |
405 | \ |
406 | typedef typename \ |
407 | mpl::if_c< \ |
408 | mpl::or_< \ |
409 | typename is_c_array<Lhs>::type, \ |
410 | typename is_c_array<Rhs>::type \ |
411 | >::value, \ |
412 | mpl::true_, \ |
413 | typename \ |
414 | mpl::if_c<is_same<typename decay<Lhs>::type, \ |
415 | typename decay<Rhs>::type>::value, \ |
416 | typename cctraits<OP>::is_specialized, \ |
417 | mpl::false_>::type \ |
418 | >::type is_specialized; \ |
419 | \ |
420 | typedef name<typename t_Lhs_iterator_helper::value_type, \ |
421 | typename t_Rhs_iterator_helper::value_type \ |
422 | > elem_op; \ |
423 | \ |
424 | static assertion_result \ |
425 | eval( Lhs const& lhs, Rhs const& rhs) \ |
426 | { \ |
427 | return assertion::op::compare_collections( lhs, rhs, \ |
428 | (boost::type<elem_op>*)0, \ |
429 | is_specialized() ); \ |
430 | } \ |
431 | \ |
432 | template<typename PrevExprType> \ |
433 | static void \ |
434 | report( std::ostream&, \ |
435 | PrevExprType const&, \ |
436 | Rhs const& ) {} \ |
437 | \ |
438 | static char const* forward() \ |
439 | { return " " #oper " "; } \ |
440 | static char const* revert() \ |
441 | { return " " #rev " "; } \ |
442 | \ |
443 | }; \ |
444 | /**/ |
445 | |
446 | BOOST_TEST_FOR_EACH_COMP_OP( DEFINE_COLLECTION_COMPARISON ) |
447 | #undef DEFINE_COLLECTION_COMPARISON |
448 | |
449 | //____________________________________________________________________________// |
450 | |
451 | } // namespace op |
452 | } // namespace assertion |
453 | } // namespace test_tools |
454 | } // namespace boost |
455 | |
456 | #include <boost/test/detail/enable_warnings.hpp> |
457 | |
458 | #endif // BOOST_TEST_TOOLS_COLLECTION_COMPARISON_OP_HPP_050815GER |
459 | |