//  (C) Copyright Gennadiy Rozental 2001-2005.

//  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: test_tools.hpp,v $

//

//  Version     : $Revision: 1.60.2.7 $

//

//  Description : contains definition for all test tools in test toolbox

// ***************************************************************************

#ifndef BOOST_TEST_TEST_TOOLS_HPP_012705GER

#define BOOST_TEST_TEST_TOOLS_HPP_012705GER

// Boost.Test

#include <boost/test/predicate_result.hpp>

#include <boost/test/unit_test_log.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>

// Boost

#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>

// STL

#include <cstddef>          // for std::size_t

#include <iosfwd>

#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

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

    ::boost::test_tools::tt_detail::func(                    \

        P,                                                   \

        ::boost::wrap_stringstream().ref() << check_descr,   \

        BOOST_TEST_L(__FILE__),                              \

        (std::size_t)__LINE__,                               \

        ::boost::test_tools::tt_detail::TL,                  \

        ::boost::test_tools::tt_detail::CT                   \

/**/

//____________________________________________________________________________//

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

do {                                                                \

    BOOST_TEST_PASSPOINT();                                         \

    BOOST_TEST_TOOL_IMPL( check_impl, P, check_descr, TL, CT ), 0 );\

} while( ::boost::test_tools::dummy_cond )                          \

/**/

//____________________________________________________________________________//

#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 )  \

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_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 )                                                   \

    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_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 )                                                          \

    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_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 )

//____________________________________________________________________________//

// The argument version of the following macros are causing "Internal Compiler Errors"

// on MSVC 6.5 when inlining is turned on (i.e. usually in release builds)

#if BOOST_WORKAROUND(BOOST_MSVC, <=1200) && defined(NDEBUG)

#define BOOST_WARN_EQUAL( L, R ) BOOST_WARN( (L) == (R) )

#define BOOST_CHECK_EQUAL( L, R ) BOOST_CHECK( (L) == (R) )

#define BOOST_REQUIRE_EQUAL( L, R ) BOOST_REQUIRE( (L) == (R) )

#else

#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) )

#endif

//____________________________________________________________________________//

#define BOOST_WARN_CLOSE( L, R, T ) \

    BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::check_is_close, "", WARN, CHECK_CLOSE, \

        (L)(R)(::boost::test_tools::percent_tolerance(T)) )

#define BOOST_CHECK_CLOSE( L, R, T ) \

    BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::check_is_close, "", CHECK, CHECK_CLOSE, \

        (L)(R)(::boost::test_tools::percent_tolerance(T)) )

#define BOOST_REQUIRE_CLOSE( L, R, T ) \

    BOOST_CHECK_WITH_ARGS_IMPL( ::boost::test_tools::check_is_close, "", REQUIRE, CHECK_CLOSE, \

        (L)(R)(::boost::test_tools::percent_tolerance(T)) )

//____________________________________________________________________________//

#define BOOST_WARN_CLOSE_FRACTION( L, R, T ) \

    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_CHECK_CLOSE_FRACTION( L, R, T ) \

    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_REQUIRE_CLOSE_FRACTION( L, R, T ) \

    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_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 )      \

    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_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 )                                    \

    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_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) )

//____________________________________________________________________________//

// ***************************** //

// deprecated interface

#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 )

namespace boost {

namespace test_tools {

typedef unit_test::const_string      const_string;

namespace { bool dummy_cond = false; }

namespace tt_detail {

// ************************************************************************** //

// **************              tools classification            ************** //

// ************************************************************************** //

enum check_type {

    CHECK_PRED, 

    CHECK_MSG,

    CHECK_EQUAL,

    CHECK_CLOSE,

    CHECK_CLOSE_FRACTION,

    CHECK_SMALL,

    CHECK_BITWISE_EQUAL,

    CHECK_PRED_WITH_ARGS,

    CHECK_EQUAL_COLL

};

enum tool_level {

    WARN, CHECK, REQUIRE, PASS

};

// ************************************************************************** //

// **************               log print helper               ************** //

// ************************************************************************** //

template<typename T>

struct print_log_value {

    void    operator()( std::ostream& ostr, T const& t )

    {

        typedef typename mpl::or_<is_array<T>,is_function<T>,is_abstract<T> >::type couldnt_use_nl;

        set_precision( ostr, couldnt_use_nl() );

        ostr << t; // by default print the value

    }

    void set_precision( std::ostream& ostr, mpl::false_ )

    {

        if( std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::radix == 2 )

            ostr.precision( 2 + std::numeric_limits<T>::digits * 301/1000 ); 

    }

    void set_precision( std::ostream&, mpl::true_ ) {}

};

//____________________________________________________________________________//

#define BOOST_TEST_DONT_PRINT_LOG_VALUE( the_type )                 \

namespace boost { namespace test_tools { namespace tt_detail {      \

template<>                                                          \

struct print_log_value<the_type > {                                 \

    void operator()( std::ostream& ostr, the_type const& t ) {}     \

};                                                                  \

}}}                                                                 \

/**/

//____________________________________________________________________________//

#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))

template<typename T, std::size_t N >

struct print_log_value< T[N] > {

    void    operator()( std::ostream& ostr, T const* t )

    {

        ostr << t;

    }

};

#endif

//____________________________________________________________________________//

template<>

struct BOOST_TEST_DECL print_log_value<char> {

    void    operator()( std::ostream& ostr, char t );

};

//____________________________________________________________________________//

template<>

struct BOOST_TEST_DECL print_log_value<unsigned char> {

    void    operator()( std::ostream& ostr, unsigned char t );

};

//____________________________________________________________________________//

template<>

struct BOOST_TEST_DECL print_log_value<char const*> {

    void    operator()( std::ostream& ostr, char const* t );

};

//____________________________________________________________________________//

template<>

struct BOOST_TEST_DECL print_log_value<wchar_t const*> {

    void    operator()( std::ostream& ostr, wchar_t const* t );

};

//____________________________________________________________________________//

template<typename T>

struct print_helper_t {

    explicit    print_helper_t( T const& t ) : m_t( t ) {}

    T const&    m_t;

};

//____________________________________________________________________________//

#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) 

// Borland suffers premature pointer decay passing arrays by reference

template<typename T, std::size_t N >

struct print_helper_t< T[N] > {

    explicit    print_helper_t( T const * t ) : m_t( t ) {}

    T const *   m_t;

};

#endif

//____________________________________________________________________________//

template<typename T>

inline print_helper_t<T> print_helper( T const& t )

{

    return print_helper_t<T>( t );

}

#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x580) 

template<typename T, std::size_t N>

inline print_helper_t<T*> print_helper( T (&t)[N] )

{

    return print_helper_t<T*>( &t[0] );

}

#endif

//____________________________________________________________________________//

template<typename T>

inline std::ostream& 

operator<<( std::ostream& ostr, print_helper_t<T> const& ph )

{

    print_log_value<T>()( ostr, ph.m_t );

    return ostr;

}

//____________________________________________________________________________//

// ************************************************************************** //

// **************            TOOL BOX Implementation           ************** //

// ************************************************************************** //

BOOST_TEST_DECL 

void check_impl( predicate_result const& pr, wrap_stringstream& check_descr,

                 const_string file_name, std::size_t line_num,

                 tool_level tl, check_type ct,

                 std::size_t num_args, ... );

//____________________________________________________________________________//

#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 )                                    \

    , (boost::wrap_stringstream().ref()                                             \

        << ::boost::test_tools::tt_detail::                                         \

            print_helper( BOOST_JOIN( arg, m ) )).str().c_str()                     \

/**/

#define IMPL_FRWD( z, n, dummy )                                                    \

template<typename Pred                                                              \

         BOOST_PP_REPEAT_ ## z( BOOST_PP_ADD( n, 1 ), TEMPL_PARAMS, _ )>            \

inline void                                                                         \

check_frwd( Pred P, wrap_stringstream& 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, _ )           \

)                                                                                   \

{                                                                                   \

    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, _ )          \

    );                                                                              \

}                                                                                   \

/**/

#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

//____________________________________________________________________________//

template <class Left, class Right>

predicate_result equal_impl( Left const& left, Right const& right )

{

    return left == right;

}

//____________________________________________________________________________//

predicate_result        BOOST_TEST_DECL equal_impl( char const* left, char const* right );

inline predicate_result BOOST_TEST_DECL equal_impl( char* left, char const* right ) { return equal_impl( (char const*)left, (char const*)right ); }

inline predicate_result BOOST_TEST_DECL equal_impl( char const* left, char* right ) { return equal_impl( (char const*)left, (char const*)right ); }

inline predicate_result BOOST_TEST_DECL equal_impl( char* left, char* right )       { return equal_impl( (char const*)left, (char const*)right ); }

#if !defined( BOOST_NO_CWCHAR )

predicate_result        equal_impl( wchar_t const* left, wchar_t const* right );

inline predicate_result equal_impl( wchar_t* left, wchar_t const* right ) { return equal_impl( (wchar_t const*)left, (wchar_t const*)right ); }

inline predicate_result equal_impl( wchar_t const* left, wchar_t* right ) { return equal_impl( (wchar_t const*)left, (wchar_t const*)right ); }

inline predicate_result equal_impl( wchar_t* left, wchar_t* right )       { return equal_impl( (wchar_t const*)left, (wchar_t const*)right ); }

#endif

//____________________________________________________________________________//

//

// Declaring this class as exported causes linker errors when building

// the serialisation tests with VC6, disable this for now. (JM 2006/10/30)

struct /*BOOST_TEST_DECL*/ equal_impl_frwd {

    template <typename Left, typename Right>

    inline predicate_result

    call_impl( Left const& left, Right const& right, mpl::false_ ) const

    {

        return equal_impl( left, right );

    }

    template <typename Left, typename Right>

    inline predicate_result

    call_impl( Left const& left, Right const& right, mpl::true_ ) const

    {

        return (*this)( right, &left[0] );

    }

    template <typename Left, typename Right>

    inline predicate_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() );

    }

};

//____________________________________________________________________________//

template <typename Left, typename Right>

inline predicate_result

equal_coll_impl( Left left_begin, Left left_end, Right right_begin, Right right_end )

{

    predicate_result    res( 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 ) {

            res = false;

            res.message() << "\nMismatch in a position " << pos << ": "  << *left_begin << " != " << *right_begin;

        }

    }

    if( left_begin != left_end ) {

        std::size_t r_size = pos;

        while( left_begin != left_end ) {

            ++pos;

            ++left_begin;

        }

        res = false;

        res.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;

        }

        res = false;

        res.message() << "\nCollections size mismatch: " << l_size << " != " << pos;

    }

    return res;

}

//____________________________________________________________________________//

template <class Left, class Right>

inline predicate_result

bitwise_equal_impl( Left const& left, Right const& right )

{

    predicate_result    res( true );

    std::size_t left_bit_size  = sizeof(Left)*CHAR_BIT;

    std::size_t right_bit_size = sizeof(Right)*CHAR_BIT;

    static Left const  L1( 1 );

    static Right const R1( 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 & ( L1 << counter ) ) != ( right & ( R1 << counter ) ) ) {

            res = false;

            res.message() << "\nMismatch in a position " << counter;

        }

    }

    if( left_bit_size != right_bit_size ) {

        res = false;

        res.message() << "\nOperands bit sizes mismatch: " << left_bit_size << " != " << right_bit_size;

    }

    return res;

}

//____________________________________________________________________________//

bool BOOST_TEST_DECL is_defined_impl( const_string symbol_name, const_string symbol_value );

//____________________________________________________________________________//

} // namespace tt_detail

} // namespace test_tools

namespace test_toolbox = test_tools;

} // namespace boost

//____________________________________________________________________________//

#include <boost/test/detail/enable_warnings.hpp>

// ***************************************************************************

//  Revision History :

//

//  $Log: test_tools.hpp,v $

//  Revision 1.60.2.7  2007/02/22 17:57:29  speedsnail

//  Make the msvc-6.5 hack even more specific, i.e. apply only in release builds.

//

//  Revision 1.60.2.6  2006/12/16 15:02:16  speedsnail

//  Merged from HEAD

//

//  Revision 1.60.2.5  2006/11/14 21:33:26  jhunold

//  Merge from HEAD: Add missing export macros for print_log_value<>

//

//  Revision 1.60.2.4  2006/11/14 07:35:43  jhunold

//  Merge from HEAD: Removed wrong export declarations.

//

//  Revision 1.60.2.3  2006/11/13 20:06:57  jhunold

//  Merge from HEAD:

//  Added missing export declarations.

//

//  Revision 1.60.2.2  2006/10/30 18:37:36  johnmaddock

//  Patch for serialisation test failures.

//

//  Revision 1.60.2.1  2006/07/24 00:43:17  gennaro_prota

//  Tentative fix for Sun C++ 5.8 (don't add more specialized print_helper function template)

//

//  Revision 1.60  2006/03/19 07:27:11  rogeeff

//  avoid warning

//

//  Revision 1.59  2006/03/03 17:39:46  rogeeff

//  paaspoint added to check throw

//

//  Revision 1.58  2006/02/06 10:04:55  rogeeff

//  BOOST_TEST_MODULE - master test suite name

//

//  Revision 1.57  2006/01/28 07:00:47  rogeeff

//  sunpro port

//

//  Revision 1.56  2005/12/19 03:08:30  rogeeff

//  added is_abstract to guard numeric_limits instantiation

//

//  Revision 1.55  2005/12/14 05:20:41  rogeeff

//  dll support introduced

//  BOOST_TEST_PASSPOINT() introduced

//  BOOST_MESSAGE depricated. Use BOOST_TEST_MESSAGE instead

//  BOOST_CHECKPOINT is depricated. Use BOOST_TEST_CHECKPOINT intead

//

//  Revision 1.54  2005/06/07 04:38:20  rogeeff

//  borland fix

//

//  Revision 1.53  2005/05/11 04:51:14  rogeeff

//  borlard portability fix

//

//  Revision 1.52  2005/03/22 07:08:47  rogeeff

//  string comparisons streamlined

//  precision settings made portable

//

//  Revision 1.51  2005/02/21 10:23:54  rogeeff

//  major issue with TT redesign causing TT to reevaluate it's arguments fixed

//  FP precision extended

//

//  Revision 1.50  2005/02/20 08:27:06  rogeeff

//  This a major update for Boost.Test framework. See release docs for complete list of fixes/updates

//

//  Revision 1.49  2005/02/01 06:40:06  rogeeff

//  copyright update

//  old log entries removed

//  minor stylistic changes

//  deprecated tools removed

//

//  Revision 1.48  2005/01/30 03:32:57  rogeeff

//  Test Tools completely reworked:

//    interfaces streamlined to provide 3 version for each tool

//    implementation reworked to use single vararg formatter function

//    CHECK_COLLECTION now expect 4 arguments

//    BITWISE_EQUAL renamed to CHECK_BITWISE_EQUAL but still provided as deprecated

//    CHECK_COLLECTION interface changed to use PP_SEQ and as a result support arbitrary number of predicate arguments

//    most of templates eliminated

//    deprecated tools removed

//    print_helper object generator added

//

// ***************************************************************************

#endif // BOOST_TEST_TEST_TOOLS_HPP_012705GER