test_tools.hpp File Reference

#include <boost/test/predicate_result.hpp>
#include <boost/test/unit_test_log.hpp>
#include <boost/test/floating_point_comparison.hpp>
#include <boost/test/detail/config.hpp>
#include <boost/test/detail/global_typedef.hpp>
#include <boost/test/detail/workaround.hpp>
#include <boost/test/utils/wrap_stringstream.hpp>
#include <boost/test/utils/basic_cstring/io.hpp>
#include <boost/test/utils/lazy_ostream.hpp>
#include <boost/preprocessor/seq/for_each.hpp>
#include <boost/preprocessor/seq/size.hpp>
#include <boost/preprocessor/seq/enum.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/preprocessor/arithmetic/add.hpp>
#include <boost/limits.hpp>
#include <boost/type_traits/is_array.hpp>
#include <boost/type_traits/is_function.hpp>
#include <boost/type_traits/is_abstract.hpp>
#include <boost/mpl/or.hpp>
#include <cstddef>
#include <iosfwd>
#include <ios>
#include <climits>
#include <boost/test/detail/suppress_warnings.hpp>
#include <boost/test/detail/enable_warnings.hpp>

Include dependency graph for test_tools.hpp:

This graph shows which files directly or indirectly include this file:

Classes
struct	boost::test_tools::print_log_value< T >
struct	boost::test_tools::print_log_value< bool >
struct	boost::test_tools::print_log_value< char >
struct	boost::test_tools::print_log_value< unsigned char >
struct	boost::test_tools::print_log_value< char const * >
struct	boost::test_tools::print_log_value< wchar_t const * >
struct	boost::test_tools::tt_detail::print_helper_t< T >
struct	boost::test_tools::tt_detail::equal_impl_frwd
struct	boost::test_tools::tt_detail::ne_impl
struct	boost::test_tools::tt_detail::lt_impl
struct	boost::test_tools::tt_detail::le_impl
struct	boost::test_tools::tt_detail::gt_impl
struct	boost::test_tools::tt_detail::ge_impl

Namespaces
	boost
	Duration formatting facet for input.
	boost::test_tools
	boost::test_tools::tt_detail

Macros
#define	BOOST_TEST_TOOL_IMPL(func, P, check_descr, TL, CT)
#define	BOOST_CHECK_IMPL(P, check_descr, TL, CT)
#define	BOOST_TEST_PASS_ARG_INFO(r, data, arg)   , arg, BOOST_STRINGIZE( arg )
#define	BOOST_CHECK_WITH_ARGS_IMPL(P, check_descr, TL, CT, ARGS)
#define	BOOST_WARN(P)   BOOST_CHECK_IMPL( (P), BOOST_TEST_STRINGIZE( P ), WARN, CHECK_PRED )
#define	BOOST_CHECK(P)   BOOST_CHECK_IMPL( (P), BOOST_TEST_STRINGIZE( P ), CHECK, CHECK_PRED )
#define	BOOST_REQUIRE(P)   BOOST_CHECK_IMPL( (P), BOOST_TEST_STRINGIZE( P ), REQUIRE, CHECK_PRED )
#define	BOOST_WARN_MESSAGE(P, M)   BOOST_CHECK_IMPL( (P), M, WARN, CHECK_MSG )
#define	BOOST_CHECK_MESSAGE(P, M)   BOOST_CHECK_IMPL( (P), M, CHECK, CHECK_MSG )
#define	BOOST_REQUIRE_MESSAGE(P, M)   BOOST_CHECK_IMPL( (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, prefix, TL)
#define	BOOST_WARN_THROW(S, E)   BOOST_CHECK_THROW_IMPL( S, E, true, "exception ", WARN )
#define	BOOST_CHECK_THROW(S, E)   BOOST_CHECK_THROW_IMPL( S, E, true, "exception ", CHECK )
#define	BOOST_REQUIRE_THROW(S, E)   BOOST_CHECK_THROW_IMPL( S, E, true, "exception ", REQUIRE )
#define	BOOST_WARN_EXCEPTION(S, E, P)   BOOST_CHECK_THROW_IMPL( S, E, P( ex ), "incorrect exception ", WARN )
#define	BOOST_CHECK_EXCEPTION(S, E, P)   BOOST_CHECK_THROW_IMPL( S, E, P( ex ), "incorrect exception ", CHECK )
#define	BOOST_REQUIRE_EXCEPTION(S, E, P)   BOOST_CHECK_THROW_IMPL( S, E, P( ex ), "incorrect exception ", REQUIRE )
#define	BOOST_CHECK_NO_THROW_IMPL(S, TL)
#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_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::equal_impl_frwd(), "", WARN, CHECK_EQUAL, (L)(R) )
#define	BOOST_CHECK_EQUAL(L, R)   BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::equal_impl_frwd(), "", CHECK, CHECK_EQUAL, (L)(R) )
#define	BOOST_REQUIRE_EQUAL(L, R)   BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::equal_impl_frwd(), "", REQUIRE, CHECK_EQUAL, (L)(R) )
#define	BOOST_WARN_NE(L, R)   BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::ne_impl(), "", WARN, CHECK_NE, (L)(R) )
#define	BOOST_CHECK_NE(L, R)   BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::ne_impl(), "", CHECK, CHECK_NE, (L)(R) )
#define	BOOST_REQUIRE_NE(L, R)   BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::ne_impl(), "", REQUIRE, CHECK_NE, (L)(R) )
#define	BOOST_WARN_LT(L, R)   BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::lt_impl(), "", WARN, CHECK_LT, (L)(R) )
#define	BOOST_CHECK_LT(L, R)   BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::lt_impl(), "", CHECK, CHECK_LT, (L)(R) )
#define	BOOST_REQUIRE_LT(L, R)   BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::lt_impl(), "", REQUIRE, CHECK_LT, (L)(R) )
#define	BOOST_WARN_LE(L, R)   BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::le_impl(), "", WARN, CHECK_LE, (L)(R) )
#define	BOOST_CHECK_LE(L, R)   BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::le_impl(), "", CHECK, CHECK_LE, (L)(R) )
#define	BOOST_REQUIRE_LE(L, R)   BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::le_impl(), "", REQUIRE, CHECK_LE, (L)(R) )
#define	BOOST_WARN_GT(L, R)   BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::gt_impl(), "", WARN, CHECK_GT, (L)(R) )
#define	BOOST_CHECK_GT(L, R)   BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::gt_impl(), "", CHECK, CHECK_GT, (L)(R) )
#define	BOOST_REQUIRE_GT(L, R)   BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::gt_impl(), "", REQUIRE, CHECK_GT, (L)(R) )
#define	BOOST_WARN_GE(L, R)   BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::ge_impl(), "", WARN, CHECK_GE, (L)(R) )
#define	BOOST_CHECK_GE(L, R)   BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::ge_impl(), "", CHECK, CHECK_GE, (L)(R) )
#define	BOOST_REQUIRE_GE(L, R)   BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::ge_impl(), "", REQUIRE, CHECK_GE, (L)(R) )
#define	BOOST_WARN_CLOSE(L, R, T)
#define	BOOST_CHECK_CLOSE(L, R, T)
#define	BOOST_REQUIRE_CLOSE(L, R, T)
#define	BOOST_WARN_CLOSE_FRACTION(L, R, T)
#define	BOOST_CHECK_CLOSE_FRACTION(L, R, T)
#define	BOOST_REQUIRE_CLOSE_FRACTION(L, R, T)
#define	BOOST_WARN_SMALL(FPV, T)   BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::check_is_small, "", WARN, CHECK_SMALL, (FPV)(T) )
#define	BOOST_CHECK_SMALL(FPV, T)   BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::check_is_small, "", CHECK, CHECK_SMALL, (FPV)(T) )
#define	BOOST_REQUIRE_SMALL(FPV, T)   BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::check_is_small, "", REQUIRE, CHECK_SMALL, (FPV)(T) )
#define	BOOST_WARN_PREDICATE(P, ARGS)   BOOST_CHECK_WITH_ARGS_IMPL( P, BOOST_TEST_STRINGIZE( P ), WARN, CHECK_PRED_WITH_ARGS, ARGS )
#define	BOOST_CHECK_PREDICATE(P, ARGS)   BOOST_CHECK_WITH_ARGS_IMPL( P, BOOST_TEST_STRINGIZE( P ), CHECK, CHECK_PRED_WITH_ARGS, ARGS )
#define	BOOST_REQUIRE_PREDICATE(P, ARGS)   BOOST_CHECK_WITH_ARGS_IMPL( P, BOOST_TEST_STRINGIZE( P ), REQUIRE, CHECK_PRED_WITH_ARGS, ARGS )
#define	BOOST_EQUAL_COLLECTIONS_IMPL(L_begin, L_end, R_begin, R_end, TL)
#define	BOOST_WARN_EQUAL_COLLECTIONS(L_begin, L_end, R_begin, R_end)   BOOST_EQUAL_COLLECTIONS_IMPL( L_begin, L_end, R_begin, R_end, WARN )
#define	BOOST_CHECK_EQUAL_COLLECTIONS(L_begin, L_end, R_begin, R_end)   BOOST_EQUAL_COLLECTIONS_IMPL( L_begin, L_end, R_begin, R_end, CHECK )
#define	BOOST_REQUIRE_EQUAL_COLLECTIONS(L_begin, L_end, R_begin, R_end)   BOOST_EQUAL_COLLECTIONS_IMPL( L_begin, L_end, R_begin, R_end, REQUIRE )
#define	BOOST_BITWISE_EQUAL_IMPL(L, R, TL)
#define	BOOST_WARN_BITWISE_EQUAL(L, R)   BOOST_BITWISE_EQUAL_IMPL( L, R, WARN )
#define	BOOST_CHECK_BITWISE_EQUAL(L, R)   BOOST_BITWISE_EQUAL_IMPL( L, R, CHECK )
#define	BOOST_REQUIRE_BITWISE_EQUAL(L, R)   BOOST_BITWISE_EQUAL_IMPL( L, R, REQUIRE )
#define	BOOST_IS_DEFINED(symb)   ::boost::test_tools::tt_detail::is_defined_impl( #symb, BOOST_STRINGIZE(= symb) )
#define	BOOST_BITWISE_EQUAL(L, R)   BOOST_CHECK_BITWISE_EQUAL( L, R )
#define	BOOST_MESSAGE(M)   BOOST_TEST_MESSAGE( M )
#define	BOOST_CHECKPOINT(M)   BOOST_TEST_CHECKPOINT( M )
#define	BOOST_TEST_DONT_PRINT_LOG_VALUE(the_type)
#define	TEMPL_PARAMS(z, m, dummy)   , typename BOOST_JOIN( Arg, m )
#define	FUNC_PARAMS(z, m, dummy)
#define	PRED_PARAMS(z, m, dummy)   BOOST_PP_COMMA_IF( m ) BOOST_JOIN( arg, m )
#define	ARG_INFO(z, m, dummy)
#define	IMPL_FRWD(z, n, dummy)
#define	BOOST_TEST_MAX_PREDICATE_ARITY   5

Typedefs
typedef unit_test::const_string	boost::test_tools::const_string

Enumerations
enum	boost::test_tools::tt_detail::check_type {   boost::test_tools::tt_detail::CHECK_PRED,   boost::test_tools::tt_detail::CHECK_MSG,   boost::test_tools::tt_detail::CHECK_EQUAL,   boost::test_tools::tt_detail::CHECK_NE,   boost::test_tools::tt_detail::CHECK_LT,   boost::test_tools::tt_detail::CHECK_LE,   boost::test_tools::tt_detail::CHECK_GT,   boost::test_tools::tt_detail::CHECK_GE,   boost::test_tools::tt_detail::CHECK_CLOSE,   boost::test_tools::tt_detail::CHECK_CLOSE_FRACTION,   boost::test_tools::tt_detail::CHECK_SMALL,   boost::test_tools::tt_detail::CHECK_BITWISE_EQUAL,   boost::test_tools::tt_detail::CHECK_PRED_WITH_ARGS,   boost::test_tools::tt_detail::CHECK_EQUAL_COLL }
enum	boost::test_tools::tt_detail::tool_level {   boost::test_tools::tt_detail::WARN,   boost::test_tools::tt_detail::CHECK,   boost::test_tools::tt_detail::REQUIRE,   boost::test_tools::tt_detail::PASS }

Functions
template<typename T >
print_helper_t< T >	boost::test_tools::tt_detail::print_helper (T const &t)
template<typename T >
std::ostream &	boost::test_tools::tt_detail::operator<< (std::ostream &ostr, print_helper_t< T > const &ph)
BOOST_TEST_DECL bool	boost::test_tools::tt_detail::check_impl (predicate_result const &pr,::boost::unit_test::lazy_ostream const &check_descr, const_string file_name, std::size_t line_num, tool_level tl, check_type ct, std::size_t num_args,...)
template<class Left , class Right >
predicate_result	boost::test_tools::tt_detail::equal_impl (Left const &left, Right const &right)
predicate_result BOOST_TEST_DECL	boost::test_tools::tt_detail::equal_impl (char const *left, char const *right)
predicate_result	boost::test_tools::tt_detail::equal_impl (char *left, char const *right)
predicate_result	boost::test_tools::tt_detail::equal_impl (char const *left, char *right)
predicate_result	boost::test_tools::tt_detail::equal_impl (char *left, char *right)
predicate_result BOOST_TEST_DECL	boost::test_tools::tt_detail::equal_impl (wchar_t const *left, wchar_t const *right)
predicate_result	boost::test_tools::tt_detail::equal_impl (wchar_t *left, wchar_t const *right)
predicate_result	boost::test_tools::tt_detail::equal_impl (wchar_t const *left, wchar_t *right)
predicate_result	boost::test_tools::tt_detail::equal_impl (wchar_t *left, wchar_t *right)
template<typename Left , typename Right >
predicate_result	boost::test_tools::tt_detail::equal_coll_impl (Left left_begin, Left left_end, Right right_begin, Right right_end)
template<class Left , class Right >
predicate_result	boost::test_tools::tt_detail::bitwise_equal_impl (Left const &left, Right const &right)
bool BOOST_TEST_DECL	boost::test_tools::tt_detail::is_defined_impl (const_string symbol_name, const_string symbol_value)

Macro Definition Documentation

#define ARG_INFO	(		z,
			m,
			dummy
	)

Value:

, 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 BOOST_BITWISE_EQUAL	(		L,
			R
	)		BOOST_CHECK_BITWISE_EQUAL( L, R )

#define BOOST_BITWISE_EQUAL_IMPL	(		L,
			R,
			TL
	)

Value:

BOOST_TEST_TOOL_IMPL( check_impl,                                           \
      ::boost::test_tools::tt_detail::bitwise_equal_impl( (L), (R) ),           \
      "", TL, CHECK_BITWISE_EQUAL ),                                            \
    2, BOOST_STRINGIZE( L ), BOOST_STRINGIZE( R ) )                             \

#define BOOST_CHECK

(

P

)

BOOST_CHECK_IMPL( (P), BOOST_TEST_STRINGIZE( P ), CHECK, CHECK_PRED )

#define BOOST_CHECK_BITWISE_EQUAL	(		L,
			R
	)		BOOST_BITWISE_EQUAL_IMPL( L, R, CHECK )

#define BOOST_CHECK_CLOSE	(		L,
			R,
			T
	)

Value:

BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::check_is_close, "", CHECK, CHECK_CLOSE, \
        (L)(R)(::boost::test_tools::percent_tolerance(T)) )

#define BOOST_CHECK_CLOSE_FRACTION	(		L,
			R,
			T
	)

Value:

BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::check_is_close, "", CHECK, CHECK_CLOSE_FRACTION, \
    (L)(R)(::boost::test_tools::fraction_tolerance(T)) )

#define BOOST_CHECK_EQUAL	(		L,
			R
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::equal_impl_frwd(), "", CHECK, CHECK_EQUAL, (L)(R) )

#define BOOST_CHECK_EQUAL_COLLECTIONS	(		L_begin,
			L_end,
			R_begin,
			R_end
	)		BOOST_EQUAL_COLLECTIONS_IMPL( L_begin, L_end, R_begin, R_end, CHECK )

#define BOOST_CHECK_EXCEPTION	(		S,
			E,
			P
	)		BOOST_CHECK_THROW_IMPL( S, E, P( ex ), "incorrect exception ", CHECK )

#define BOOST_CHECK_GE	(		L,
			R
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::ge_impl(), "", CHECK, CHECK_GE, (L)(R) )

#define BOOST_CHECK_GT	(		L,
			R
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::gt_impl(), "", CHECK, CHECK_GT, (L)(R) )

#define BOOST_CHECK_IMPL	(		P,
			check_descr,
			TL,
			CT
	)

Value:

do {                                                                \
    BOOST_TEST_PASSPOINT();                                         \
    BOOST_TEST_TOOL_IMPL( check_impl, P, check_descr, TL, CT ), 0 );\
} while( ::boost::test_tools::dummy_cond )                          \

#define BOOST_CHECK_LE	(		L,
			R
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::le_impl(), "", CHECK, CHECK_LE, (L)(R) )

#define BOOST_CHECK_LT	(		L,
			R
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::lt_impl(), "", CHECK, CHECK_LT, (L)(R) )

#define BOOST_CHECK_MESSAGE	(		P,
			M
	)		BOOST_CHECK_IMPL( (P), M, CHECK, CHECK_MSG )

#define BOOST_CHECK_NE	(		L,
			R
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::ne_impl(), "", CHECK, CHECK_NE, (L)(R) )

#define BOOST_CHECK_NO_THROW

(

S

)

BOOST_CHECK_NO_THROW_IMPL( S, CHECK )

#define BOOST_CHECK_NO_THROW_IMPL	(		S,
			TL
	)

Value:

try {                                                                                           \
        S;                                                                                          \
        BOOST_CHECK_IMPL( true, "no exceptions thrown by " BOOST_STRINGIZE( S ), TL, CHECK_MSG ); } \
    catch( ... ) {                                                                                  \
        BOOST_CHECK_IMPL( false, "exception thrown by " BOOST_STRINGIZE( S ), TL, CHECK_MSG );      \
    }                                                                                               \

#define BOOST_CHECK_PREDICATE	(		P,
			ARGS
	)		BOOST_CHECK_WITH_ARGS_IMPL( P, BOOST_TEST_STRINGIZE( P ), CHECK, CHECK_PRED_WITH_ARGS, ARGS )

#define BOOST_CHECK_SMALL	(		FPV,
			T
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::check_is_small, "", CHECK, CHECK_SMALL, (FPV)(T) )

#define BOOST_CHECK_THROW	(		S,
			E
	)		BOOST_CHECK_THROW_IMPL( S, E, true, "exception ", CHECK )

#define BOOST_CHECK_THROW_IMPL	(		S,
			E,
			P,
			prefix,
			TL
	)

Value:

try {                                                                                               \
        BOOST_TEST_PASSPOINT();                                                                         \
        S;                                                                                              \
        BOOST_CHECK_IMPL( false, "exception " BOOST_STRINGIZE( E ) " is expected", TL, CHECK_MSG ); }   \
    catch( E const& ex ) {                                                                              \
        ::boost::unit_test::ut_detail::ignore_unused_variable_warning( ex );                            \
        BOOST_CHECK_IMPL( P, prefix BOOST_STRINGIZE( E ) " is caught", TL, CHECK_MSG );                 \
    }                                                                                                   \

#define BOOST_CHECK_WITH_ARGS_IMPL	(		P,
			check_descr,
			TL,
			CT,
			ARGS
	)

Value:

do {                                                                \
    BOOST_TEST_PASSPOINT();                                         \
    BOOST_TEST_TOOL_IMPL( check_frwd, P, check_descr, TL, CT )      \
    BOOST_PP_SEQ_FOR_EACH( BOOST_TEST_PASS_ARG_INFO, '_', ARGS ) ); \
} while( ::boost::test_tools::dummy_cond )                          \

#define BOOST_CHECKPOINT

(

M

)

BOOST_TEST_CHECKPOINT( M )

#define BOOST_EQUAL_COLLECTIONS_IMPL	(		L_begin,
			L_end,
			R_begin,
			R_end,
			TL
	)

Value:

BOOST_TEST_TOOL_IMPL( check_impl, ::boost::test_tools::tt_detail::equal_coll_impl( \
        (L_begin), (L_end), (R_begin), (R_end) ), "", TL, CHECK_EQUAL_COLL ),   \
    4,                                                                          \
    BOOST_STRINGIZE( L_begin ), BOOST_STRINGIZE( L_end ),                       \
    BOOST_STRINGIZE( R_begin ), BOOST_STRINGIZE( R_end ) )                      \

#define BOOST_ERROR

(

M

)

BOOST_CHECK_MESSAGE( false, M )

#define BOOST_FAIL

(

M

)

BOOST_REQUIRE_MESSAGE( false, M )

#define BOOST_IS_DEFINED

(

symb

)

::boost::test_tools::tt_detail::is_defined_impl( #symb, BOOST_STRINGIZE(= symb) )

#define BOOST_MESSAGE

(

M

)

BOOST_TEST_MESSAGE( M )

#define BOOST_REQUIRE

(

P

)

BOOST_CHECK_IMPL( (P), BOOST_TEST_STRINGIZE( P ), REQUIRE, CHECK_PRED )

#define BOOST_REQUIRE_BITWISE_EQUAL	(		L,
			R
	)		BOOST_BITWISE_EQUAL_IMPL( L, R, REQUIRE )

#define BOOST_REQUIRE_CLOSE	(		L,
			R,
			T
	)

Value:

BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::check_is_close, "", REQUIRE, CHECK_CLOSE, \
        (L)(R)(::boost::test_tools::percent_tolerance(T)) )

#define BOOST_REQUIRE_CLOSE_FRACTION	(		L,
			R,
			T
	)

Value:

BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::check_is_close, "", REQUIRE, CHECK_CLOSE_FRACTION, \
    (L)(R)(::boost::test_tools::fraction_tolerance(T)) )

#define BOOST_REQUIRE_EQUAL	(		L,
			R
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::equal_impl_frwd(), "", REQUIRE, CHECK_EQUAL, (L)(R) )

#define BOOST_REQUIRE_EQUAL_COLLECTIONS	(		L_begin,
			L_end,
			R_begin,
			R_end
	)		BOOST_EQUAL_COLLECTIONS_IMPL( L_begin, L_end, R_begin, R_end, REQUIRE )

#define BOOST_REQUIRE_EXCEPTION	(		S,
			E,
			P
	)		BOOST_CHECK_THROW_IMPL( S, E, P( ex ), "incorrect exception ", REQUIRE )

#define BOOST_REQUIRE_GE	(		L,
			R
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::ge_impl(), "", REQUIRE, CHECK_GE, (L)(R) )

#define BOOST_REQUIRE_GT	(		L,
			R
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::gt_impl(), "", REQUIRE, CHECK_GT, (L)(R) )

#define BOOST_REQUIRE_LE	(		L,
			R
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::le_impl(), "", REQUIRE, CHECK_LE, (L)(R) )

#define BOOST_REQUIRE_LT	(		L,
			R
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::lt_impl(), "", REQUIRE, CHECK_LT, (L)(R) )

#define BOOST_REQUIRE_MESSAGE	(		P,
			M
	)		BOOST_CHECK_IMPL( (P), M, REQUIRE, CHECK_MSG )

#define BOOST_REQUIRE_NE	(		L,
			R
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::ne_impl(), "", REQUIRE, CHECK_NE, (L)(R) )

#define BOOST_REQUIRE_NO_THROW

(

S

)

BOOST_CHECK_NO_THROW_IMPL( S, REQUIRE )

#define BOOST_REQUIRE_PREDICATE	(		P,
			ARGS
	)		BOOST_CHECK_WITH_ARGS_IMPL( P, BOOST_TEST_STRINGIZE( P ), REQUIRE, CHECK_PRED_WITH_ARGS, ARGS )

#define BOOST_REQUIRE_SMALL	(		FPV,
			T
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::check_is_small, "", REQUIRE, CHECK_SMALL, (FPV)(T) )

#define BOOST_REQUIRE_THROW	(		S,
			E
	)		BOOST_CHECK_THROW_IMPL( S, E, true, "exception ", REQUIRE )

#define BOOST_TEST_DONT_PRINT_LOG_VALUE

(

the_type

)

Value:

namespace boost { namespace test_tools {                    \
template<>                                                  \
struct print_log_value<the_type > {                         \
    void operator()( std::ostream&, the_type const& ) {}    \
};                                                          \
}}                                                          \

#define BOOST_TEST_MAX_PREDICATE_ARITY   5

#define BOOST_TEST_PASS_ARG_INFO	(		r,
			data,
			arg
	)		, arg, BOOST_STRINGIZE( arg )

#define BOOST_TEST_TOOL_IMPL	(		func,
			P,
			check_descr,
			TL,
			CT
	)

Value:

::boost::test_tools::tt_detail::func(                               \
        P,                                                              \
        ::boost::unit_test::lazy_ostream::instance() << check_descr,    \
        BOOST_TEST_L(__FILE__),                                         \
        static_cast<std::size_t>(__LINE__),                             \
        ::boost::test_tools::tt_detail::TL,                             \
        ::boost::test_tools::tt_detail::CT                              \

#define BOOST_WARN

(

P

)

BOOST_CHECK_IMPL( (P), BOOST_TEST_STRINGIZE( P ), WARN, CHECK_PRED )

#define BOOST_WARN_BITWISE_EQUAL	(		L,
			R
	)		BOOST_BITWISE_EQUAL_IMPL( L, R, WARN )

#define BOOST_WARN_CLOSE	(		L,
			R,
			T
	)

Value:

BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::check_is_close, "", WARN, CHECK_CLOSE, \
        (L)(R)(::boost::test_tools::percent_tolerance(T)) )

#define BOOST_WARN_CLOSE_FRACTION	(		L,
			R,
			T
	)

Value:

BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::check_is_close, "", WARN, CHECK_CLOSE_FRACTION, \
    (L)(R)(::boost::test_tools::fraction_tolerance(T)) )

#define BOOST_WARN_EQUAL	(		L,
			R
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::equal_impl_frwd(), "", WARN, CHECK_EQUAL, (L)(R) )

#define BOOST_WARN_EQUAL_COLLECTIONS	(		L_begin,
			L_end,
			R_begin,
			R_end
	)		BOOST_EQUAL_COLLECTIONS_IMPL( L_begin, L_end, R_begin, R_end, WARN )

#define BOOST_WARN_EXCEPTION	(		S,
			E,
			P
	)		BOOST_CHECK_THROW_IMPL( S, E, P( ex ), "incorrect exception ", WARN )

#define BOOST_WARN_GE	(		L,
			R
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::ge_impl(), "", WARN, CHECK_GE, (L)(R) )

#define BOOST_WARN_GT	(		L,
			R
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::gt_impl(), "", WARN, CHECK_GT, (L)(R) )

#define BOOST_WARN_LE	(		L,
			R
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::le_impl(), "", WARN, CHECK_LE, (L)(R) )

#define BOOST_WARN_LT	(		L,
			R
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::lt_impl(), "", WARN, CHECK_LT, (L)(R) )

#define BOOST_WARN_MESSAGE	(		P,
			M
	)		BOOST_CHECK_IMPL( (P), M, WARN, CHECK_MSG )

#define BOOST_WARN_NE	(		L,
			R
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::tt_detail::ne_impl(), "", WARN, CHECK_NE, (L)(R) )

#define BOOST_WARN_NO_THROW

(

S

)

BOOST_CHECK_NO_THROW_IMPL( S, WARN )

#define BOOST_WARN_PREDICATE	(		P,
			ARGS
	)		BOOST_CHECK_WITH_ARGS_IMPL( P, BOOST_TEST_STRINGIZE( P ), WARN, CHECK_PRED_WITH_ARGS, ARGS )

#define BOOST_WARN_SMALL	(		FPV,
			T
	)		BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::check_is_small, "", WARN, CHECK_SMALL, (FPV)(T) )

#define BOOST_WARN_THROW	(		S,
			E
	)		BOOST_CHECK_THROW_IMPL( S, E, true, "exception ", WARN )

#define FUNC_PARAMS	(		z,
			m,
			dummy
	)

Value:

, BOOST_JOIN( Arg, m ) const& BOOST_JOIN( arg, m )                                 \
 , char const* BOOST_JOIN( BOOST_JOIN( arg, m ), _descr )                           \

#define IMPL_FRWD	(		z,
			n,
			dummy
	)

Value:

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& check_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                                                                          \
    check_impl( P( BOOST_PP_REPEAT_ ## z( BOOST_PP_ADD( n, 1 ), PRED_PARAMS, _ ) ), \
                check_descr, file_name, line_num, tl, ct,                           \
                BOOST_PP_ADD( n, 1 )                                                \
                BOOST_PP_REPEAT_ ## z( BOOST_PP_ADD( n, 1 ), ARG_INFO, _ )          \
    );                                                                              \
}                                                                                   \

#define PRED_PARAMS	(		z,
			m,
			dummy
	)		BOOST_PP_COMMA_IF( m ) BOOST_JOIN( arg, m )

#define TEMPL_PARAMS	(		z,
			m,
			dummy
	)		, typename BOOST_JOIN( Arg, m )