Boost  v1.57.0
doxygen for www.boost.org
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
Classes | Functions
boost::itest Namespace Reference

Classes

struct  location
 
class  manager
 
class  mock_object
 
class  mock_object_base
 
class  scope_guard
 

Functions

void BOOST_TEST_DECL exception_safety (unit_test::callback0<> const &F, unit_test::const_string test_name="")
 
void BOOST_TEST_DECL logged_expectations (unit_test::callback0<> const &F, unit_test::const_string log_file_name, bool test_or_log=true)
 
template<int i1, typename Base1 , int i2, typename Base2 >
bool operator!= (mock_object< i1, Base1 > const &, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
bool operator!= (mock_object< i, Base > const &, T const &)
 
template<int i, typename Base , typename T >
bool operator!= (T const &, mock_object< i, Base > const &)
 
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object< i1, Base1 > const & operator% (mock_object< i1, Base1 > const &mo, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator% (mock_object< i, Base > const &mo, T const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator% (T const &, mock_object< i, Base > const &mo)
 
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object< i1, Base1 > const & operator%= (mock_object< i1, Base1 > const &mo, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator%= (mock_object< i, Base > const &mo, T const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator%= (T const &, mock_object< i, Base > const &mo)
 
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object< i1, Base1 > const & operator& (mock_object< i1, Base1 > const &mo, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator& (mock_object< i, Base > const &mo, T const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator& (T const &, mock_object< i, Base > const &mo)
 
template<int i1, typename Base1 , int i2, typename Base2 >
bool operator&& (mock_object< i1, Base1 > const &, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
bool operator&& (mock_object< i, Base > const &, T const &)
 
template<int i, typename Base , typename T >
bool operator&& (T const &, mock_object< i, Base > const &)
 
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object< i1, Base1 > const & operator&= (mock_object< i1, Base1 > const &mo, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator&= (mock_object< i, Base > const &mo, T const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator&= (T const &, mock_object< i, Base > const &mo)
 
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object< i1, Base1 > const & operator* (mock_object< i1, Base1 > const &mo, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator* (mock_object< i, Base > const &mo, T const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator* (T const &, mock_object< i, Base > const &mo)
 
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object< i1, Base1 > const & operator*= (mock_object< i1, Base1 > const &mo, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator*= (mock_object< i, Base > const &mo, T const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator*= (T const &, mock_object< i, Base > const &mo)
 
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object< i1, Base1 > const & operator+ (mock_object< i1, Base1 > const &mo, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator+ (mock_object< i, Base > const &mo, T const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator+ (T const &, mock_object< i, Base > const &mo)
 
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object< i1, Base1 > const & operator+= (mock_object< i1, Base1 > const &mo, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator+= (mock_object< i, Base > const &mo, T const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator+= (T const &, mock_object< i, Base > const &mo)
 
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object< i1, Base1 > const & operator-= (mock_object< i1, Base1 > const &mo, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator-= (mock_object< i, Base > const &mo, T const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator-= (T const &, mock_object< i, Base > const &mo)
 
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object< i1, Base1 > const & operator->* (mock_object< i1, Base1 > const &mo, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator->* (mock_object< i, Base > const &mo, T const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator->* (T const &, mock_object< i, Base > const &mo)
 
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object< i1, Base1 > const & operator/ (mock_object< i1, Base1 > const &mo, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator/ (mock_object< i, Base > const &mo, T const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator/ (T const &, mock_object< i, Base > const &mo)
 
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object< i1, Base1 > const & operator/= (mock_object< i1, Base1 > const &mo, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator/= (mock_object< i, Base > const &mo, T const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator/= (T const &, mock_object< i, Base > const &mo)
 
template<int i1, typename Base1 , int i2, typename Base2 >
bool operator< (mock_object< i1, Base1 > const &, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
bool operator< (mock_object< i, Base > const &, T const &)
 
template<int i, typename Base , typename T >
bool operator< (T const &, mock_object< i, Base > const &)
 
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object< i1, Base1 > const & operator<<= (mock_object< i1, Base1 > const &mo, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator<<= (mock_object< i, Base > const &mo, T const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator<<= (T const &, mock_object< i, Base > const &mo)
 
template<int i1, typename Base1 , int i2, typename Base2 >
bool operator<= (mock_object< i1, Base1 > const &, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
bool operator<= (mock_object< i, Base > const &, T const &)
 
template<int i, typename Base , typename T >
bool operator<= (T const &, mock_object< i, Base > const &)
 
template<int i1, typename Base1 , int i2, typename Base2 >
bool operator== (mock_object< i1, Base1 > const &, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
bool operator== (mock_object< i, Base > const &, T const &)
 
template<int i, typename Base , typename T >
bool operator== (T const &, mock_object< i, Base > const &)
 
template<int i1, typename Base1 , int i2, typename Base2 >
bool operator> (mock_object< i1, Base1 > const &, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
bool operator> (mock_object< i, Base > const &, T const &)
 
template<int i, typename Base , typename T >
bool operator> (T const &, mock_object< i, Base > const &)
 
template<int i1, typename Base1 , int i2, typename Base2 >
bool operator>= (mock_object< i1, Base1 > const &, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
bool operator>= (mock_object< i, Base > const &, T const &)
 
template<int i, typename Base , typename T >
bool operator>= (T const &, mock_object< i, Base > const &)
 
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object< i1, Base1 > const & operator>>= (mock_object< i1, Base1 > const &mo, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator>>= (mock_object< i, Base > const &mo, T const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator>>= (T const &, mock_object< i, Base > const &mo)
 
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object< i1, Base1 > const & operator^ (mock_object< i1, Base1 > const &mo, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator^ (mock_object< i, Base > const &mo, T const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator^ (T const &, mock_object< i, Base > const &mo)
 
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object< i1, Base1 > const & operator^= (mock_object< i1, Base1 > const &mo, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator^= (mock_object< i, Base > const &mo, T const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator^= (T const &, mock_object< i, Base > const &mo)
 
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object< i1, Base1 > const & operator| (mock_object< i1, Base1 > const &mo, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator| (mock_object< i, Base > const &mo, T const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator| (T const &, mock_object< i, Base > const &mo)
 
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object< i1, Base1 > const & operator|= (mock_object< i1, Base1 > const &mo, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator|= (mock_object< i, Base > const &mo, T const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator|= (T const &, mock_object< i, Base > const &mo)
 
template<int i1, typename Base1 , int i2, typename Base2 >
bool operator|| (mock_object< i1, Base1 > const &, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
bool operator|| (mock_object< i, Base > const &, T const &)
 
template<int i, typename Base , typename T >
bool operator|| (T const &, mock_object< i, Base > const &)
 
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object< i1, Base1 > const & operator<< (mock_object< i1, Base1 > const &mo, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator<< (mock_object< i, Base > const &mo, T const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator<< (T const &, mock_object< i, Base > const &mo)
 
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object< i1, Base1 > const & operator>> (mock_object< i1, Base1 > const &mo, mock_object< i2, Base2 > const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator>> (mock_object< i, Base > const &mo, T const &)
 
template<int i, typename Base , typename T >
mock_object< i, Base > const & operator>> (T const &, mock_object< i, Base > const &mo)
 

Function Documentation

void BOOST_TEST_DECL boost::itest::exception_safety ( unit_test::callback0<> const &  F,
unit_test::const_string  test_name = "" 
)
void BOOST_TEST_DECL boost::itest::logged_expectations ( unit_test::callback0<> const &  F,
unit_test::const_string  log_file_name,
bool  test_or_log = true 
)
template<int i, typename Base , typename T >
bool boost::itest::operator!= ( mock_object< i, Base > const &  ,
T const &   
)
inline
template<int i, typename Base , typename T >
bool boost::itest::operator!= ( T const &  ,
mock_object< i, Base > const &   
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
bool boost::itest::operator!= ( mock_object< i1, Base1 > const &  ,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator% ( T const &  ,
mock_object< i, Base > const &  mo 
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object<i1,Base1> const& boost::itest::operator% ( mock_object< i1, Base1 > const &  mo,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator% ( mock_object< i, Base > const &  mo,
T const &   
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object<i1,Base1> const& boost::itest::operator%= ( mock_object< i1, Base1 > const &  mo,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator%= ( mock_object< i, Base > const &  mo,
T const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator%= ( T const &  ,
mock_object< i, Base > const &  mo 
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object<i1,Base1> const& boost::itest::operator& ( mock_object< i1, Base1 > const &  mo,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator& ( mock_object< i, Base > const &  mo,
T const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator& ( T const &  ,
mock_object< i, Base > const &  mo 
)
inline
template<int i, typename Base , typename T >
bool boost::itest::operator&& ( mock_object< i, Base > const &  ,
T const &   
)
inline
template<int i, typename Base , typename T >
bool boost::itest::operator&& ( T const &  ,
mock_object< i, Base > const &   
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
bool boost::itest::operator&& ( mock_object< i1, Base1 > const &  ,
mock_object< i2, Base2 > const &   
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object<i1,Base1> const& boost::itest::operator&= ( mock_object< i1, Base1 > const &  mo,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator&= ( mock_object< i, Base > const &  mo,
T const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator&= ( T const &  ,
mock_object< i, Base > const &  mo 
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object<i1,Base1> const& boost::itest::operator* ( mock_object< i1, Base1 > const &  mo,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator* ( mock_object< i, Base > const &  mo,
T const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator* ( T const &  ,
mock_object< i, Base > const &  mo 
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object<i1,Base1> const& boost::itest::operator*= ( mock_object< i1, Base1 > const &  mo,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator*= ( mock_object< i, Base > const &  mo,
T const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator*= ( T const &  ,
mock_object< i, Base > const &  mo 
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object<i1,Base1> const& boost::itest::operator+ ( mock_object< i1, Base1 > const &  mo,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator+ ( mock_object< i, Base > const &  mo,
T const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator+ ( T const &  ,
mock_object< i, Base > const &  mo 
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator+= ( T const &  ,
mock_object< i, Base > const &  mo 
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object<i1,Base1> const& boost::itest::operator+= ( mock_object< i1, Base1 > const &  mo,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator+= ( mock_object< i, Base > const &  mo,
T const &   
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object<i1,Base1> const& boost::itest::operator-= ( mock_object< i1, Base1 > const &  mo,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator-= ( mock_object< i, Base > const &  mo,
T const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator-= ( T const &  ,
mock_object< i, Base > const &  mo 
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object<i1,Base1> const& boost::itest::operator->* ( mock_object< i1, Base1 > const &  mo,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator->* ( mock_object< i, Base > const &  mo,
T const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator->* ( T const &  ,
mock_object< i, Base > const &  mo 
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object<i1,Base1> const& boost::itest::operator/ ( mock_object< i1, Base1 > const &  mo,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator/ ( mock_object< i, Base > const &  mo,
T const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator/ ( T const &  ,
mock_object< i, Base > const &  mo 
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object<i1,Base1> const& boost::itest::operator/= ( mock_object< i1, Base1 > const &  mo,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator/= ( mock_object< i, Base > const &  mo,
T const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator/= ( T const &  ,
mock_object< i, Base > const &  mo 
)
inline
template<int i, typename Base , typename T >
bool boost::itest::operator< ( T const &  ,
mock_object< i, Base > const &   
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
bool boost::itest::operator< ( mock_object< i1, Base1 > const &  ,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
bool boost::itest::operator< ( mock_object< i, Base > const &  ,
T const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator<< ( mock_object< i, Base > const &  mo,
T const &   
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object<i1,Base1> const& boost::itest::operator<< ( mock_object< i1, Base1 > const &  mo,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator<< ( T const &  ,
mock_object< i, Base > const &  mo 
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object<i1,Base1> const& boost::itest::operator<<= ( mock_object< i1, Base1 > const &  mo,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator<<= ( mock_object< i, Base > const &  mo,
T const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator<<= ( T const &  ,
mock_object< i, Base > const &  mo 
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
bool boost::itest::operator<= ( mock_object< i1, Base1 > const &  ,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
bool boost::itest::operator<= ( mock_object< i, Base > const &  ,
T const &   
)
inline
template<int i, typename Base , typename T >
bool boost::itest::operator<= ( T const &  ,
mock_object< i, Base > const &   
)
inline
template<int i, typename Base , typename T >
bool boost::itest::operator== ( mock_object< i, Base > const &  ,
T const &   
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
bool boost::itest::operator== ( mock_object< i1, Base1 > const &  ,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
bool boost::itest::operator== ( T const &  ,
mock_object< i, Base > const &   
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
bool boost::itest::operator> ( mock_object< i1, Base1 > const &  ,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
bool boost::itest::operator> ( mock_object< i, Base > const &  ,
T const &   
)
inline
template<int i, typename Base , typename T >
bool boost::itest::operator> ( T const &  ,
mock_object< i, Base > const &   
)
inline
template<int i, typename Base , typename T >
bool boost::itest::operator>= ( T const &  ,
mock_object< i, Base > const &   
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
bool boost::itest::operator>= ( mock_object< i1, Base1 > const &  ,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
bool boost::itest::operator>= ( mock_object< i, Base > const &  ,
T const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator>> ( T const &  ,
mock_object< i, Base > const &  mo 
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object<i1,Base1> const& boost::itest::operator>> ( mock_object< i1, Base1 > const &  mo,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator>> ( mock_object< i, Base > const &  mo,
T const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator>>= ( mock_object< i, Base > const &  mo,
T const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator>>= ( T const &  ,
mock_object< i, Base > const &  mo 
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object<i1,Base1> const& boost::itest::operator>>= ( mock_object< i1, Base1 > const &  mo,
mock_object< i2, Base2 > const &   
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object<i1,Base1> const& boost::itest::operator^ ( mock_object< i1, Base1 > const &  mo,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator^ ( mock_object< i, Base > const &  mo,
T const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator^ ( T const &  ,
mock_object< i, Base > const &  mo 
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator^= ( T const &  ,
mock_object< i, Base > const &  mo 
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object<i1,Base1> const& boost::itest::operator^= ( mock_object< i1, Base1 > const &  mo,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator^= ( mock_object< i, Base > const &  mo,
T const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator| ( T const &  ,
mock_object< i, Base > const &  mo 
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object<i1,Base1> const& boost::itest::operator| ( mock_object< i1, Base1 > const &  mo,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator| ( mock_object< i, Base > const &  mo,
T const &   
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
mock_object<i1,Base1> const& boost::itest::operator|= ( mock_object< i1, Base1 > const &  mo,
mock_object< i2, Base2 > const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator|= ( mock_object< i, Base > const &  mo,
T const &   
)
inline
template<int i, typename Base , typename T >
mock_object<i,Base> const& boost::itest::operator|= ( T const &  ,
mock_object< i, Base > const &  mo 
)
inline
template<int i, typename Base , typename T >
bool boost::itest::operator|| ( T const &  ,
mock_object< i, Base > const &   
)
inline
template<int i, typename Base , typename T >
bool boost::itest::operator|| ( mock_object< i, Base > const &  ,
T const &   
)
inline
template<int i1, typename Base1 , int i2, typename Base2 >
bool boost::itest::operator|| ( mock_object< i1, Base1 > const &  ,
mock_object< i2, Base2 > const &   
)
inline