?????????? ?????????

?????????? ????????? - ??????????????? - /home/agenciai/public_html/cd38d8/old.tar

???????
impl.hpp��0000644��00000031462�15125516220�0006223 0��ustar�00��// (C) Copyright Gennadiy Rozental 2001. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/test for the library home page. // // File : $RCSfile$ // // Version : $Revision: 74248 $ // // Description : implementation details for old toolbox // ************************************************************************* #ifndef BOOST_TEST_TOOLS_OLD_IMPL_HPP_012705GER #define BOOST_TEST_TOOLS_OLD_IMPL_HPP_012705GER // Boost.Test #include <boost/test/unit_test_log.hpp> #include <boost/test/tools/assertion_result.hpp> #include <boost/test/tools/floating_point_comparison.hpp> #include <boost/test/tools/detail/fwd.hpp> #include <boost/test/tools/detail/print_helper.hpp> // Boost #include <boost/limits.hpp> #include <boost/numeric/conversion/conversion_traits.hpp> // for numeric::conversion_traits #include <boost/type_traits/is_array.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/preprocessor/arithmetic/add.hpp> // STL #include <cstddef> // for std::size_t #include <climits> // for CHAR_BIT #include <boost/test/detail/suppress_warnings.hpp> //____________________________________________________________________________// namespace boost { namespace test_tools { namespace tt_detail { // ********************************************************************** // // ********** old TOOLBOX Implementation ********** // // ************************************************************************ // // This function adds level of indirection, but it makes sure we evaluate predicate // arguments only once #ifndef BOOST_TEST_PROD #define TEMPL_PARAMS( z, m, dummy ) , typename BOOST_JOIN( Arg, m ) #define FUNC_PARAMS( z, m, dummy ) \ , BOOST_JOIN( Arg, m ) const& BOOST_JOIN( arg, m ) \ , char const* BOOST_JOIN( BOOST_JOIN( arg, m ), _descr ) \ // #define PRED_PARAMS( z, m, dummy ) BOOST_PP_COMMA_IF( m ) BOOST_JOIN( arg, m ) #define ARG_INFO( z, m, dummy ) \ , BOOST_JOIN( BOOST_JOIN( arg, m ), _descr ) \ , &static_cast<const unit_test::lazy_ostream&>(unit_test::lazy_ostream::instance() \ << ::boost::test_tools::tt_detail::print_helper( BOOST_JOIN( arg, m ) )) \ // #define IMPL_FRWD( z, n, dummy ) \ template<typename Pred \ BOOST_PP_REPEAT_ ## z( BOOST_PP_ADD( n, 1 ), TEMPL_PARAMS, _ )> \ inline bool \ check_frwd( Pred P, unit_test::lazy_ostream const& assertion_descr, \ const_string file_name, std::size_t line_num, \ tool_level tl, check_type ct \ BOOST_PP_REPEAT_ ## z( BOOST_PP_ADD( n, 1 ), FUNC_PARAMS, _ ) \ ) \ { \ return \ report_assertion( P( BOOST_PP_REPEAT_ ## z(BOOST_PP_ADD(n, 1), PRED_PARAMS,_) ),\ assertion_descr, file_name, line_num, tl, ct, \ BOOST_PP_ADD( n, 1 ) \ BOOST_PP_REPEAT_ ## z( BOOST_PP_ADD( n, 1 ), ARG_INFO, _ ) \ ); \ } \ /*/ #ifndef BOOST_TEST_MAX_PREDICATE_ARITY #define BOOST_TEST_MAX_PREDICATE_ARITY 5 #endif BOOST_PP_REPEAT( BOOST_TEST_MAX_PREDICATE_ARITY, IMPL_FRWD, _ ) #undef TEMPL_PARAMS #undef FUNC_PARAMS #undef PRED_INFO #undef ARG_INFO #undef IMPL_FRWD #endif //____________________________________________________________________________// template <class Left, class Right> inline assertion_result equal_impl( Left const& left, Right const& right ) { return left == right; } //____________________________________________________________________________// inline assertion_result equal_impl( char left, char const* right ) { return equal_impl( static_cast<char const>(left), static_cast<char const>(right) ); } inline assertion_result equal_impl( char const* left, char* right ) { return equal_impl( static_cast<char const>(left), static_cast<char const>(right) ); } inline assertion_result equal_impl( char* left, char* right ) { return equal_impl( static_cast<char const>(left), static_cast<char const>(right) ); } #if !defined( BOOST_NO_CWCHAR ) BOOST_TEST_DECL assertion_result equal_impl( wchar_t const* left, wchar_t const* right ); 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) ); } 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) ); } 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) ); } #endif //____________________________________________________________________________// struct equal_impl_frwd { template <typename Left, typename Right> inline assertion_result call_impl( Left const& left, Right const& right, mpl::false_ ) const { return equal_impl( left, right ); } template <typename Left, typename Right> inline assertion_result call_impl( Left const& left, Right const& right, mpl::true_ ) const { return (this)( right, &left[0] ); } template <typename Left, typename Right> inline assertion_result operator()( Left const& left, Right const& right ) const { typedef typename is_array<Left>::type left_is_array; return call_impl( left, right, left_is_array() ); } }; //____________________________________________________________________________// struct ne_impl { template <class Left, class Right> assertion_result operator()( Left const& left, Right const& right ) { return !equal_impl_frwd()( left, right ); } }; //____________________________________________________________________________// struct lt_impl { template <class Left, class Right> assertion_result operator()( Left const& left, Right const& right ) { return left < right; } }; //____________________________________________________________________________// struct le_impl { template <class Left, class Right> assertion_result operator()( Left const& left, Right const& right ) { return left <= right; } }; //____________________________________________________________________________// struct gt_impl { template <class Left, class Right> assertion_result operator()( Left const& left, Right const& right ) { return left > right; } }; //____________________________________________________________________________// struct ge_impl { template <class Left, class Right> assertion_result operator()( Left const& left, Right const& right ) { return left >= right; } }; //____________________________________________________________________________// struct equal_coll_impl { template <typename Left, typename Right> assertion_result operator()( Left left_begin, Left left_end, Right right_begin, Right right_end ) { assertion_result pr( true ); std::size_t pos = 0; for( ; left_begin != left_end && right_begin != right_end; ++left_begin, ++right_begin, ++pos ) { if( left_begin != right_begin ) { pr = false; pr.message() << "\nMismatch at position " << pos << ": " << ::boost::test_tools::tt_detail::print_helper(left_begin) << " != " << ::boost::test_tools::tt_detail::print_helper(right_begin); } } if( left_begin != left_end ) { std::size_t r_size = pos; while( left_begin != left_end ) { ++pos; ++left_begin; } pr = false; pr.message() << "\nCollections size mismatch: " << pos << " != " << r_size; } if( right_begin != right_end ) { std::size_t l_size = pos; while( right_begin != right_end ) { ++pos; ++right_begin; } pr = false; pr.message() << "\nCollections size mismatch: " << l_size << " != " << pos; } return pr; } }; //____________________________________________________________________________// struct bitwise_equal_impl { template <class Left, class Right> assertion_result operator()( Left const& left, Right const& right ) { assertion_result pr( true ); std::size_t left_bit_size = sizeof(Left)CHAR_BIT; std::size_t right_bit_size = sizeof(Right)CHAR_BIT; static Left const leftOne( 1 ); static Right const rightOne( 1 ); std::size_t total_bits = left_bit_size < right_bit_size ? left_bit_size : right_bit_size; for( std::size_t counter = 0; counter < total_bits; ++counter ) { if( ( left & ( leftOne << counter ) ) != ( right & ( rightOne << counter ) ) ) { pr = false; pr.message() << "\nMismatch at position " << counter; } } if( left_bit_size != right_bit_size ) { pr = false; pr.message() << "\nOperands bit sizes mismatch: " << left_bit_size << " != " << right_bit_size; } return pr; } }; //____________________________________________________________________________// template<typename FPT1, typename FPT2> struct comp_supertype { // deduce "better" type from types of arguments being compared // if one type is floating and the second integral we use floating type and // value of integral type is promoted to the floating. The same for float and double // But we don't want to compare two values of integral types using this tool. typedef typename numeric::conversion_traits<FPT1,FPT2>::supertype type; BOOST_STATIC_ASSERT_MSG( !is_integral<type>::value, "Only floating-point types can be compared!"); }; } // namespace tt_detail namespace fpc = math::fpc; // *********************************************************************** // // ********** check_is_close ********** // // ********************************************************************** // struct BOOST_TEST_DECL check_is_close_t { // Public typedefs typedef assertion_result result_type; template<typename FPT1, typename FPT2, typename ToleranceType> assertion_result operator()( FPT1 left, FPT2 right, ToleranceType tolerance ) const { fpc::close_at_tolerance<typename tt_detail::comp_supertype<FPT1,FPT2>::type> pred( tolerance, fpc::FPC_STRONG ); assertion_result ar( pred( left, right ) ); if( !ar ) ar.message() << pred.tested_rel_diff(); return ar; } }; //____________________________________________________________________________// template<typename FPT1, typename FPT2, typename ToleranceType> inline assertion_result check_is_close( FPT1 left, FPT2 right, ToleranceType tolerance ) { return check_is_close_t()( left, right, tolerance ); } //____________________________________________________________________________// // ********************************************************************** // // ********** check_is_small ********** // // ********************************************************************** // struct BOOST_TEST_DECL check_is_small_t { // Public typedefs typedef bool result_type; template<typename FPT> bool operator()( FPT fpv, FPT tolerance ) const { return fpc::is_small( fpv, tolerance ); } }; //____________________________________________________________________________// template<typename FPT> inline bool check_is_small( FPT fpv, FPT tolerance ) { return fpc::is_small( fpv, tolerance ); } //____________________________________________________________________________// } // namespace test_tools } // namespace boost #include <boost/test/detail/enable_warnings.hpp> #endif // BOOST_TEST_TOOLS_OLD_IMPL_HPP_012705GER ��interface.hpp��0000644��00000037011�15125516220�0007216 0��ustar�00��// (C) Copyright Gennadiy Rozental 2001. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/test for the library home page. // // File : $RCSfile$ // // Version : $Revision: 81247 $ // // Description : contains definition for all test tools in old test toolbox // *********************************************************************** #ifndef BOOST_TEST_TOOLS_OLD_INTERFACE_HPP_111712GER #define BOOST_TEST_TOOLS_OLD_INTERFACE_HPP_111712GER // Boost #include <boost/preprocessor/seq/for_each.hpp> #include <boost/preprocessor/seq/size.hpp> #include <boost/preprocessor/seq/to_tuple.hpp> #include <boost/core/ignore_unused.hpp> #include <boost/test/detail/suppress_warnings.hpp> //____________________________________________________________________________// // ********************************************************************** // // ********** TOOL BOX ********** // // ********************************************************************** // // In macros below following argument abbreviations are used: // P - predicate // M - message // S - statement // E - exception // L - left argument // R - right argument // TL - tool level // CT - check type // ARGS - arguments list (as PP sequence) // frwd_type: // 0 - args exists and need to be forwarded; call check_frwd // 1 - args exists, but do not need to be forwarded; call report_assertion directly // 2 - no arguments; call report_assertion directly #define BOOST_TEST_TOOL_PASS_PRED0( P, ARGS ) P #define BOOST_TEST_TOOL_PASS_PRED1( P, ARGS ) P BOOST_PP_SEQ_TO_TUPLE(ARGS) #define BOOST_TEST_TOOL_PASS_PRED2( P, ARGS ) P #define BOOST_TEST_TOOL_PASS_ARG( r, _, arg ) , arg, BOOST_STRINGIZE( arg ) #define BOOST_TEST_TOOL_PASS_ARG_DSCR( r, _, arg ) , BOOST_STRINGIZE( arg ) #define BOOST_TEST_TOOL_PASS_ARGS0( ARGS ) \ BOOST_PP_SEQ_FOR_EACH( BOOST_TEST_TOOL_PASS_ARG, _, ARGS ) #define BOOST_TEST_TOOL_PASS_ARGS1( ARGS ) \ , BOOST_PP_SEQ_SIZE(ARGS) BOOST_PP_SEQ_FOR_EACH( BOOST_TEST_TOOL_PASS_ARG_DSCR, _, ARGS ) #define BOOST_TEST_TOOL_PASS_ARGS2( ARGS ) \ , 0 #define BOOST_TEST_TOOL_IMPL( frwd_type, P, assertion_descr, TL, CT, ARGS ) \ do { \ BOOST_TEST_PASSPOINT(); \ ::boost::test_tools::tt_detail:: \ BOOST_PP_IF( frwd_type, report_assertion, check_frwd ) ( \ BOOST_JOIN( BOOST_TEST_TOOL_PASS_PRED, frwd_type )( P, ARGS ), \ BOOST_TEST_LAZY_MSG( assertion_descr ), \ BOOST_TEST_L(__FILE__), \ static_cast<std::size_t>(__LINE__), \ ::boost::test_tools::tt_detail::TL, \ ::boost::test_tools::tt_detail::CT \ BOOST_JOIN( BOOST_TEST_TOOL_PASS_ARGS, frwd_type )( ARGS ) ); \ } while( ::boost::test_tools::tt_detail::dummy_cond() ) \ // //____________________________________________________________________________// #define BOOST_WARN( P ) BOOST_TEST_TOOL_IMPL( 2, \ (P), BOOST_TEST_STRINGIZE( P ), WARN, CHECK_PRED, _ ) #define BOOST_CHECK( P ) BOOST_TEST_TOOL_IMPL( 2, \ (P), BOOST_TEST_STRINGIZE( P ), CHECK, CHECK_PRED, _ ) #define BOOST_REQUIRE( P ) BOOST_TEST_TOOL_IMPL( 2, \ (P), BOOST_TEST_STRINGIZE( P ), REQUIRE, CHECK_PRED, _ ) //____________________________________________________________________________// #define BOOST_WARN_MESSAGE( P, M ) BOOST_TEST_TOOL_IMPL( 2, (P), M, WARN, CHECK_MSG, _ ) #define BOOST_CHECK_MESSAGE( P, M ) BOOST_TEST_TOOL_IMPL( 2, (P), M, CHECK, CHECK_MSG, _ ) #define BOOST_REQUIRE_MESSAGE( P, M ) BOOST_TEST_TOOL_IMPL( 2, (P), M, REQUIRE, CHECK_MSG, _ ) //____________________________________________________________________________// #define BOOST_ERROR( M ) BOOST_CHECK_MESSAGE( false, M ) #define BOOST_FAIL( M ) BOOST_REQUIRE_MESSAGE( false, M ) //____________________________________________________________________________// #define BOOST_CHECK_THROW_IMPL( S, E, P, postfix, TL ) \ do { \ try { \ BOOST_TEST_PASSPOINT(); \ S; \ BOOST_TEST_TOOL_IMPL( 2, false, "exception " BOOST_STRINGIZE(E) " expected but not raised", \ TL, CHECK_MSG, _ ); \ } catch( E const& ex ) { \ boost::ignore_unused( ex ); \ BOOST_TEST_TOOL_IMPL( 2, P, \ "exception \"" BOOST_STRINGIZE( E )"\" raised as expected" postfix, \ TL, CHECK_MSG, _ ); \ } \ } while( ::boost::test_tools::tt_detail::dummy_cond() ) \ // //____________________________________________________________________________// #define BOOST_WARN_THROW( S, E ) BOOST_CHECK_THROW_IMPL( S, E, true, "", WARN ) #define BOOST_CHECK_THROW( S, E ) BOOST_CHECK_THROW_IMPL( S, E, true, "", CHECK ) #define BOOST_REQUIRE_THROW( S, E ) BOOST_CHECK_THROW_IMPL( S, E, true, "", REQUIRE ) //____________________________________________________________________________// #define BOOST_WARN_EXCEPTION( S, E, P ) BOOST_CHECK_THROW_IMPL( S, E, P( ex ), \ ": validation on the raised exception through predicate \"" BOOST_STRINGIZE(P) "\"", WARN ) #define BOOST_CHECK_EXCEPTION( S, E, P ) BOOST_CHECK_THROW_IMPL( S, E, P( ex ), \ ": validation on the raised exception through predicate \"" BOOST_STRINGIZE(P) "\"", CHECK ) #define BOOST_REQUIRE_EXCEPTION( S, E, P ) BOOST_CHECK_THROW_IMPL( S, E, P( ex ), \ ": validation on the raised exception through predicate \"" BOOST_STRINGIZE(P) "\"", REQUIRE ) //____________________________________________________________________________// #define BOOST_CHECK_NO_THROW_IMPL( S, TL ) \ do { \ try { \ S; \ BOOST_TEST_TOOL_IMPL( 2, true, "no exceptions thrown by " BOOST_STRINGIZE( S ), \ TL, CHECK_MSG, _ ); \ } catch( ... ) { \ BOOST_TEST_TOOL_IMPL( 2, false, "unexpected exception thrown by " BOOST_STRINGIZE( S ), \ TL, CHECK_MSG, _ ); \ } \ } while( ::boost::test_tools::tt_detail::dummy_cond() ) \ // #define BOOST_WARN_NO_THROW( S ) BOOST_CHECK_NO_THROW_IMPL( S, WARN ) #define BOOST_CHECK_NO_THROW( S ) BOOST_CHECK_NO_THROW_IMPL( S, CHECK ) #define BOOST_REQUIRE_NO_THROW( S ) BOOST_CHECK_NO_THROW_IMPL( S, REQUIRE ) //____________________________________________________________________________// #define BOOST_WARN_EQUAL( L, R ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::tt_detail::equal_impl_frwd(), "", WARN, CHECK_EQUAL, (L)(R) ) #define BOOST_CHECK_EQUAL( L, R ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::tt_detail::equal_impl_frwd(), "", CHECK, CHECK_EQUAL, (L)(R) ) #define BOOST_REQUIRE_EQUAL( L, R ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::tt_detail::equal_impl_frwd(), "", REQUIRE, CHECK_EQUAL, (L)(R) ) //____________________________________________________________________________// #define BOOST_WARN_NE( L, R ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::tt_detail::ne_impl(), "", WARN, CHECK_NE, (L)(R) ) #define BOOST_CHECK_NE( L, R ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::tt_detail::ne_impl(), "", CHECK, CHECK_NE, (L)(R) ) #define BOOST_REQUIRE_NE( L, R ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::tt_detail::ne_impl(), "", REQUIRE, CHECK_NE, (L)(R) ) //____________________________________________________________________________// #define BOOST_WARN_LT( L, R ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::tt_detail::lt_impl(), "", WARN, CHECK_LT, (L)(R) ) #define BOOST_CHECK_LT( L, R ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::tt_detail::lt_impl(), "", CHECK, CHECK_LT, (L)(R) ) #define BOOST_REQUIRE_LT( L, R ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::tt_detail::lt_impl(), "", REQUIRE, CHECK_LT, (L)(R) ) //____________________________________________________________________________// #define BOOST_WARN_LE( L, R ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::tt_detail::le_impl(), "", WARN, CHECK_LE, (L)(R) ) #define BOOST_CHECK_LE( L, R ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::tt_detail::le_impl(), "", CHECK, CHECK_LE, (L)(R) ) #define BOOST_REQUIRE_LE( L, R ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::tt_detail::le_impl(), "", REQUIRE, CHECK_LE, (L)(R) ) //____________________________________________________________________________// #define BOOST_WARN_GT( L, R ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::tt_detail::gt_impl(), "", WARN, CHECK_GT, (L)(R) ) #define BOOST_CHECK_GT( L, R ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::tt_detail::gt_impl(), "", CHECK, CHECK_GT, (L)(R) ) #define BOOST_REQUIRE_GT( L, R ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::tt_detail::gt_impl(), "", REQUIRE, CHECK_GT, (L)(R) ) //____________________________________________________________________________// #define BOOST_WARN_GE( L, R ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::tt_detail::ge_impl(), "", WARN, CHECK_GE, (L)(R) ) #define BOOST_CHECK_GE( L, R ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::tt_detail::ge_impl(), "", CHECK, CHECK_GE, (L)(R) ) #define BOOST_REQUIRE_GE( L, R ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::tt_detail::ge_impl(), "", REQUIRE, CHECK_GE, (L)(R) ) //____________________________________________________________________________// #define BOOST_WARN_CLOSE( L, R, T ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::check_is_close_t(), "", WARN, CHECK_CLOSE, (L)(R)(::boost::math::fpc::percent_tolerance(T)) ) #define BOOST_CHECK_CLOSE( L, R, T ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::check_is_close_t(), "", CHECK, CHECK_CLOSE, (L)(R)(::boost::math::fpc::percent_tolerance(T)) ) #define BOOST_REQUIRE_CLOSE( L, R, T ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::check_is_close_t(), "", REQUIRE, CHECK_CLOSE, (L)(R)(::boost::math::fpc::percent_tolerance(T)) ) //____________________________________________________________________________// #define BOOST_WARN_CLOSE_FRACTION(L, R, T) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::check_is_close_t(), "", WARN, CHECK_CLOSE_FRACTION, (L)(R)(T) ) #define BOOST_CHECK_CLOSE_FRACTION(L, R, T) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::check_is_close_t(), "", CHECK, CHECK_CLOSE_FRACTION, (L)(R)(T) ) #define BOOST_REQUIRE_CLOSE_FRACTION(L,R,T) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::check_is_close_t(), "", REQUIRE, CHECK_CLOSE_FRACTION, (L)(R)(T) ) //____________________________________________________________________________// #define BOOST_WARN_SMALL( FPV, T ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::check_is_small_t(), "", WARN, CHECK_SMALL, (FPV)(T) ) #define BOOST_CHECK_SMALL( FPV, T ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::check_is_small_t(), "", CHECK, CHECK_SMALL, (FPV)(T) ) #define BOOST_REQUIRE_SMALL( FPV, T ) BOOST_TEST_TOOL_IMPL( 0, \ ::boost::test_tools::check_is_small_t(), "", REQUIRE, CHECK_SMALL, (FPV)(T) ) //____________________________________________________________________________// #define BOOST_WARN_PREDICATE( P, ARGS ) BOOST_TEST_TOOL_IMPL( 0, \ P, BOOST_TEST_STRINGIZE( P ), WARN, CHECK_PRED_WITH_ARGS, ARGS ) #define BOOST_CHECK_PREDICATE( P, ARGS ) BOOST_TEST_TOOL_IMPL( 0, \ P, BOOST_TEST_STRINGIZE( P ), CHECK, CHECK_PRED_WITH_ARGS, ARGS ) #define BOOST_REQUIRE_PREDICATE( P, ARGS ) BOOST_TEST_TOOL_IMPL( 0, \ P, BOOST_TEST_STRINGIZE( P ), REQUIRE, CHECK_PRED_WITH_ARGS, ARGS ) //____________________________________________________________________________// #define BOOST_WARN_EQUAL_COLLECTIONS( L_begin, L_end, R_begin, R_end ) \ BOOST_TEST_TOOL_IMPL( 1, ::boost::test_tools::tt_detail::equal_coll_impl(), \ "", WARN, CHECK_EQUAL_COLL, (L_begin)(L_end)(R_begin)(R_end) ) \ // #define BOOST_CHECK_EQUAL_COLLECTIONS( L_begin, L_end, R_begin, R_end ) \ BOOST_TEST_TOOL_IMPL( 1, ::boost::test_tools::tt_detail::equal_coll_impl(), \ "", CHECK, CHECK_EQUAL_COLL, (L_begin)(L_end)(R_begin)(R_end) ) \ // #define BOOST_REQUIRE_EQUAL_COLLECTIONS( L_begin, L_end, R_begin, R_end ) \ BOOST_TEST_TOOL_IMPL( 1, ::boost::test_tools::tt_detail::equal_coll_impl(), \ "", REQUIRE, CHECK_EQUAL_COLL, (L_begin)(L_end)(R_begin)(R_end) ) \ /**/ //____________________________________________________________________________// #define BOOST_WARN_BITWISE_EQUAL( L, R ) BOOST_TEST_TOOL_IMPL( 1, \ ::boost::test_tools::tt_detail::bitwise_equal_impl(), "", WARN, CHECK_BITWISE_EQUAL, (L)(R) ) #define BOOST_CHECK_BITWISE_EQUAL( L, R ) BOOST_TEST_TOOL_IMPL( 1, \ ::boost::test_tools::tt_detail::bitwise_equal_impl(), "", CHECK, CHECK_BITWISE_EQUAL, (L)(R) ) #define BOOST_REQUIRE_BITWISE_EQUAL( L, R ) BOOST_TEST_TOOL_IMPL( 1, \ ::boost::test_tools::tt_detail::bitwise_equal_impl(), "", REQUIRE, CHECK_BITWISE_EQUAL, (L)(R) ) //____________________________________________________________________________// #define BOOST_IS_DEFINED( symb ) ::boost::test_tools::tt_detail::is_defined_impl( #symb, BOOST_STRINGIZE(= symb) ) //____________________________________________________________________________// #ifdef BOOST_TEST_NO_NEW_TOOLS #define BOOST_TEST_WARN( P ) BOOST_WARN( P ) #define BOOST_TEST_CHECK( P ) BOOST_CHECK( P ) #define BOOST_TEST_REQUIRE( P ) BOOST_REQUIRE( P ) #define BOOST_TEST( P ) BOOST_CHECK( P ) #endif //____________________________________________________________________________// #include <boost/test/detail/enable_warnings.hpp> #endif // BOOST_TEST_TOOLS_OLD_INTERFACE_HPP_111712GER ��

| ver. 1.6 | Github | . | PHP 8.2.30 | ??????????? ?????????: 0 | proxy | phpinfo | ???????????