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 : $RCSfile$
9 //
10 // Version : $Revision: 74248 $
11 //
12 // Description : implementation details for old toolbox
13 // ***************************************************************************
14
15 #ifndef BOOST_TEST_TOOLS_OLD_IMPL_HPP_012705GER
16 #define BOOST_TEST_TOOLS_OLD_IMPL_HPP_012705GER
17
18 // Boost.Test
19 #include <boost/test/unit_test_log.hpp>
20 #include <boost/test/tools/assertion_result.hpp>
21 #include <boost/test/tools/floating_point_comparison.hpp>
22
23 #include <boost/test/tools/detail/fwd.hpp>
24 #include <boost/test/tools/detail/print_helper.hpp>
25
26 // Boost
27 #include <boost/limits.hpp>
28 #include <boost/numeric/conversion/conversion_traits.hpp> // for numeric::conversion_traits
29 #include <boost/type_traits/is_array.hpp>
30
31 #include <boost/preprocessor/repetition/repeat.hpp>
32 #include <boost/preprocessor/arithmetic/add.hpp>
33
34 // STL
35 #include <cstddef> // for std::size_t
36 #include <climits> // for CHAR_BIT
37
38 #include <boost/test/detail/suppress_warnings.hpp>
39
40 //____________________________________________________________________________//
41
42 namespace boost {
43 namespace test_tools {
44 namespace tt_detail {
45
46 // ************************************************************************** //
47 // ************** old TOOLBOX Implementation ************** //
48 // ************************************************************************** //
49
50 // This function adds level of indirection, but it makes sure we evaluate predicate
51 // arguments only once
52
53 #ifndef BOOST_TEST_PROD
54 #define TEMPL_PARAMS( z, m, dummy ) , typename BOOST_JOIN( Arg, m )
55
56 #define FUNC_PARAMS( z, m, dummy ) \
57 , BOOST_JOIN( Arg, m ) const& BOOST_JOIN( arg, m ) \
58 , char const* BOOST_JOIN( BOOST_JOIN( arg, m ), _descr ) \
59 /**/
60
61 #define PRED_PARAMS( z, m, dummy ) BOOST_PP_COMMA_IF( m ) BOOST_JOIN( arg, m )
62
63 #define ARG_INFO( z, m, dummy ) \
64 , BOOST_JOIN( BOOST_JOIN( arg, m ), _descr ) \
65 , &static_cast<const unit_test::lazy_ostream&>(unit_test::lazy_ostream::instance() \
66 << ::boost::test_tools::tt_detail::print_helper( BOOST_JOIN( arg, m ) )) \
67 /**/
68
69 #define IMPL_FRWD( z, n, dummy ) \
70 template<typename Pred \
71 BOOST_PP_REPEAT_ ## z( BOOST_PP_ADD( n, 1 ), TEMPL_PARAMS, _ )> \
72 inline bool \
73 check_frwd( Pred P, unit_test::lazy_ostream const& assertion_descr, \
74 const_string file_name, std::size_t line_num, \
75 tool_level tl, check_type ct \
76 BOOST_PP_REPEAT_ ## z( BOOST_PP_ADD( n, 1 ), FUNC_PARAMS, _ ) \
77 ) \
78 { \
79 return \
80 report_assertion( P( BOOST_PP_REPEAT_ ## z(BOOST_PP_ADD(n, 1), PRED_PARAMS,_) ),\
81 assertion_descr, file_name, line_num, tl, ct, \
82 BOOST_PP_ADD( n, 1 ) \
83 BOOST_PP_REPEAT_ ## z( BOOST_PP_ADD( n, 1 ), ARG_INFO, _ ) \
84 ); \
85 } \
86 /**/
87
88 #ifndef BOOST_TEST_MAX_PREDICATE_ARITY
89 #define BOOST_TEST_MAX_PREDICATE_ARITY 5
90 #endif
91
BOOST_PP_REPEAT(BOOST_TEST_MAX_PREDICATE_ARITY,IMPL_FRWD,_)92 BOOST_PP_REPEAT( BOOST_TEST_MAX_PREDICATE_ARITY, IMPL_FRWD, _ )
93
94 #undef TEMPL_PARAMS
95 #undef FUNC_PARAMS
96 #undef PRED_INFO
97 #undef ARG_INFO
98 #undef IMPL_FRWD
99
100 #endif
101
102 //____________________________________________________________________________//
103
104 template <class Left, class Right>
105 inline assertion_result equal_impl( Left const& left, Right const& right )
106 {
107 return left == right;
108 }
109
110 //____________________________________________________________________________//
111
equal_impl(char * left,char const * right)112 inline assertion_result equal_impl( char* left, char const* right ) { return equal_impl( static_cast<char const*>(left), static_cast<char const*>(right) ); }
equal_impl(char const * left,char * right)113 inline assertion_result equal_impl( char const* left, char* right ) { return equal_impl( static_cast<char const*>(left), static_cast<char const*>(right) ); }
equal_impl(char * left,char * right)114 inline assertion_result equal_impl( char* left, char* right ) { return equal_impl( static_cast<char const*>(left), static_cast<char const*>(right) ); }
115
116 #if !defined( BOOST_NO_CWCHAR )
117 assertion_result BOOST_TEST_DECL equal_impl( wchar_t const* left, wchar_t const* right );
equal_impl(wchar_t * left,wchar_t const * right)118 inline assertion_result equal_impl( wchar_t* left, wchar_t const* right ) { return equal_impl( static_cast<wchar_t const*>(left), static_cast<wchar_t const*>(right) ); }
equal_impl(wchar_t const * left,wchar_t * right)119 inline assertion_result equal_impl( wchar_t const* left, wchar_t* right ) { return equal_impl( static_cast<wchar_t const*>(left), static_cast<wchar_t const*>(right) ); }
equal_impl(wchar_t * left,wchar_t * right)120 inline assertion_result equal_impl( wchar_t* left, wchar_t* right ) { return equal_impl( static_cast<wchar_t const*>(left), static_cast<wchar_t const*>(right) ); }
121 #endif
122
123 //____________________________________________________________________________//
124
125 struct equal_impl_frwd {
126 template <typename Left, typename Right>
127 inline assertion_result
call_implboost::test_tools::tt_detail::equal_impl_frwd128 call_impl( Left const& left, Right const& right, mpl::false_ ) const
129 {
130 return equal_impl( left, right );
131 }
132
133 template <typename Left, typename Right>
134 inline assertion_result
call_implboost::test_tools::tt_detail::equal_impl_frwd135 call_impl( Left const& left, Right const& right, mpl::true_ ) const
136 {
137 return (*this)( right, &left[0] );
138 }
139
140 template <typename Left, typename Right>
141 inline assertion_result
operator ()boost::test_tools::tt_detail::equal_impl_frwd142 operator()( Left const& left, Right const& right ) const
143 {
144 typedef typename is_array<Left>::type left_is_array;
145 return call_impl( left, right, left_is_array() );
146 }
147 };
148
149 //____________________________________________________________________________//
150
151 struct ne_impl {
152 template <class Left, class Right>
operator ()boost::test_tools::tt_detail::ne_impl153 assertion_result operator()( Left const& left, Right const& right )
154 {
155 return !equal_impl_frwd()( left, right );
156 }
157 };
158
159 //____________________________________________________________________________//
160
161 struct lt_impl {
162 template <class Left, class Right>
operator ()boost::test_tools::tt_detail::lt_impl163 assertion_result operator()( Left const& left, Right const& right )
164 {
165 return left < right;
166 }
167 };
168
169 //____________________________________________________________________________//
170
171 struct le_impl {
172 template <class Left, class Right>
operator ()boost::test_tools::tt_detail::le_impl173 assertion_result operator()( Left const& left, Right const& right )
174 {
175 return left <= right;
176 }
177 };
178
179 //____________________________________________________________________________//
180
181 struct gt_impl {
182 template <class Left, class Right>
operator ()boost::test_tools::tt_detail::gt_impl183 assertion_result operator()( Left const& left, Right const& right )
184 {
185 return left > right;
186 }
187 };
188
189 //____________________________________________________________________________//
190
191 struct ge_impl {
192 template <class Left, class Right>
operator ()boost::test_tools::tt_detail::ge_impl193 assertion_result operator()( Left const& left, Right const& right )
194 {
195 return left >= right;
196 }
197 };
198
199 //____________________________________________________________________________//
200
201 struct equal_coll_impl {
202 template <typename Left, typename Right>
operator ()boost::test_tools::tt_detail::equal_coll_impl203 assertion_result operator()( Left left_begin, Left left_end, Right right_begin, Right right_end )
204 {
205 assertion_result pr( true );
206 std::size_t pos = 0;
207
208 for( ; left_begin != left_end && right_begin != right_end; ++left_begin, ++right_begin, ++pos ) {
209 if( *left_begin != *right_begin ) {
210 pr = false;
211 pr.message() << "\nMismatch at position " << pos << ": "
212 << ::boost::test_tools::tt_detail::print_helper(*left_begin)
213 << " != "
214 << ::boost::test_tools::tt_detail::print_helper(*right_begin);
215 }
216 }
217
218 if( left_begin != left_end ) {
219 std::size_t r_size = pos;
220 while( left_begin != left_end ) {
221 ++pos;
222 ++left_begin;
223 }
224
225 pr = false;
226 pr.message() << "\nCollections size mismatch: " << pos << " != " << r_size;
227 }
228
229 if( right_begin != right_end ) {
230 std::size_t l_size = pos;
231 while( right_begin != right_end ) {
232 ++pos;
233 ++right_begin;
234 }
235
236 pr = false;
237 pr.message() << "\nCollections size mismatch: " << l_size << " != " << pos;
238 }
239
240 return pr;
241 }
242 };
243
244 //____________________________________________________________________________//
245
246 struct bitwise_equal_impl {
247 template <class Left, class Right>
operator ()boost::test_tools::tt_detail::bitwise_equal_impl248 assertion_result operator()( Left const& left, Right const& right )
249 {
250 assertion_result pr( true );
251
252 std::size_t left_bit_size = sizeof(Left)*CHAR_BIT;
253 std::size_t right_bit_size = sizeof(Right)*CHAR_BIT;
254
255 static Left const leftOne( 1 );
256 static Right const rightOne( 1 );
257
258 std::size_t total_bits = left_bit_size < right_bit_size ? left_bit_size : right_bit_size;
259
260 for( std::size_t counter = 0; counter < total_bits; ++counter ) {
261 if( ( left & ( leftOne << counter ) ) != ( right & ( rightOne << counter ) ) ) {
262 pr = false;
263 pr.message() << "\nMismatch at position " << counter;
264 }
265 }
266
267 if( left_bit_size != right_bit_size ) {
268 pr = false;
269 pr.message() << "\nOperands bit sizes mismatch: " << left_bit_size << " != " << right_bit_size;
270 }
271
272 return pr;
273 }
274 };
275
276 //____________________________________________________________________________//
277
278 template<typename FPT1, typename FPT2>
279 struct comp_supertype {
280 // deduce "better" type from types of arguments being compared
281 // if one type is floating and the second integral we use floating type and
282 // value of integral type is promoted to the floating. The same for float and double
283 // But we don't want to compare two values of integral types using this tool.
284 typedef typename numeric::conversion_traits<FPT1,FPT2>::supertype type;
285 BOOST_STATIC_ASSERT_MSG( !is_integral<type>::value, "Only floating-point types can be compared!");
286 };
287
288 } // namespace tt_detail
289
290 namespace fpc = math::fpc;
291
292 // ************************************************************************** //
293 // ************** check_is_close ************** //
294 // ************************************************************************** //
295
296 struct BOOST_TEST_DECL check_is_close_t {
297 // Public typedefs
298 typedef assertion_result result_type;
299
300 template<typename FPT1, typename FPT2, typename ToleranceType>
301 assertion_result
operator ()boost::test_tools::check_is_close_t302 operator()( FPT1 left, FPT2 right, ToleranceType tolerance ) const
303 {
304 fpc::close_at_tolerance<typename tt_detail::comp_supertype<FPT1,FPT2>::type> pred( tolerance, fpc::FPC_STRONG );
305
306 assertion_result ar( pred( left, right ) );
307
308 if( !ar )
309 ar.message() << pred.tested_rel_diff();
310
311 return ar;
312 }
313 };
314
315 //____________________________________________________________________________//
316
317 template<typename FPT1, typename FPT2, typename ToleranceType>
318 inline assertion_result
check_is_close(FPT1 left,FPT2 right,ToleranceType tolerance)319 check_is_close( FPT1 left, FPT2 right, ToleranceType tolerance )
320 {
321 return check_is_close_t()( left, right, tolerance );
322 }
323
324 //____________________________________________________________________________//
325
326 // ************************************************************************** //
327 // ************** check_is_small ************** //
328 // ************************************************************************** //
329
330 struct BOOST_TEST_DECL check_is_small_t {
331 // Public typedefs
332 typedef bool result_type;
333
334 template<typename FPT>
335 bool
operator ()boost::test_tools::check_is_small_t336 operator()( FPT fpv, FPT tolerance ) const
337 {
338 return fpc::is_small( fpv, tolerance );
339 }
340 };
341
342 //____________________________________________________________________________//
343
344 template<typename FPT>
345 inline bool
check_is_small(FPT fpv,FPT tolerance)346 check_is_small( FPT fpv, FPT tolerance )
347 {
348 return fpc::is_small( fpv, tolerance );
349 }
350
351 //____________________________________________________________________________//
352
353 } // namespace test_tools
354 } // namespace boost
355
356 #include <boost/test/detail/enable_warnings.hpp>
357
358 #endif // BOOST_TEST_TOOLS_OLD_IMPL_HPP_012705GER
359