mirror of
https://github.com/mat007/turtle.git
synced 2026-06-22 12:13:43 +00:00
4f5090c109
git-svn-id: https://svn.code.sf.net/p/turtle/code/trunk@672 860be788-9bd5-4423-9f1e-828f051e677b
369 lines
9.6 KiB
C++
369 lines
9.6 KiB
C++
// http://turtle.sourceforge.net
|
|
//
|
|
// Copyright Mathieu Champlon 2008
|
|
//
|
|
// 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)
|
|
|
|
#include <turtle/constraints.hpp>
|
|
#include <boost/test/auto_unit_test.hpp>
|
|
|
|
BOOST_AUTO_TEST_CASE( all_comparison_constraints_can_be_instanciated )
|
|
{
|
|
mock::equal( 0 );
|
|
mock::less( 0 );
|
|
mock::greater( 0 );
|
|
mock::less_equal( 0 );
|
|
mock::greater_equal( 0 );
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( constraints_can_be_negated_using_the_not_operator )
|
|
{
|
|
! mock::any;
|
|
! mock::affirm;
|
|
! mock::negate;
|
|
! mock::evaluate;
|
|
! mock::equal( 0 );
|
|
! mock::less( 0 );
|
|
! mock::greater( 0 );
|
|
! mock::less_equal( 0 );
|
|
! mock::greater_equal( 0 );
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( constraints_can_be_combined_using_the_or_operator )
|
|
{
|
|
mock::less( 0 ) || mock::greater( 0 );
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( constraints_can_be_combined_using_the_and_operator )
|
|
{
|
|
mock::less( 0 ) && mock::greater( 0 );
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( equal_constraint )
|
|
{
|
|
BOOST_CHECK( mock::equal( std::string( "string" ) ).c_( "string" ) );
|
|
BOOST_CHECK( ! mock::equal( std::string( "string" ) ).c_( "not string" ) );
|
|
{
|
|
std::string s;
|
|
mock::constraint<
|
|
mock::detail::equal<
|
|
boost::reference_wrapper< const std::string >
|
|
>
|
|
> c = mock::equal( boost::cref( s ) );
|
|
s = "string";
|
|
BOOST_CHECK( c.c_( "string" ) );
|
|
}
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( same_constraint )
|
|
{
|
|
{
|
|
int i = 0;
|
|
int j = 0;
|
|
BOOST_CHECK_EQUAL( i, j );
|
|
BOOST_CHECK( ! mock::same( i ).c_( j ) );
|
|
BOOST_CHECK( mock::same( i ).c_( i ) );
|
|
}
|
|
{
|
|
int i = 0;
|
|
int j = 0;
|
|
BOOST_CHECK_EQUAL( i, j );
|
|
mock::constraint<
|
|
mock::detail::same<
|
|
const boost::reference_wrapper< const int >
|
|
>
|
|
> c = mock::same( boost::cref( i ) );
|
|
BOOST_CHECK( ! c.c_( j ) );
|
|
BOOST_CHECK( c.c_( i ) );
|
|
}
|
|
#ifdef MOCK_NULLPTR
|
|
{
|
|
std::nullptr_t p;
|
|
BOOST_CHECK( mock::same( p ).c_( p ) );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( assign_constraint )
|
|
{
|
|
{
|
|
int i = 0;
|
|
BOOST_CHECK( mock::assign( 3 ).c_( i ) );
|
|
BOOST_CHECK_EQUAL( 3, i );
|
|
}
|
|
{
|
|
int i = 0;
|
|
BOOST_CHECK( mock::assign( 3 ).c_( &i ) );
|
|
BOOST_CHECK_EQUAL( 3, i );
|
|
}
|
|
{
|
|
const int* i = 0;
|
|
const int j = 1;
|
|
BOOST_CHECK( mock::assign( &j ).c_( i ) );
|
|
BOOST_CHECK_EQUAL( &j, i );
|
|
}
|
|
{
|
|
int i = 0;
|
|
int j = 1;
|
|
mock::constraint<
|
|
mock::detail::assign<
|
|
boost::reference_wrapper< const int >
|
|
>
|
|
> c = mock::assign( boost::cref( j ) );
|
|
BOOST_CHECK( c.c_( i ) );
|
|
BOOST_CHECK_EQUAL( 1, i );
|
|
j = 3;
|
|
BOOST_CHECK( c.c_( i ) );
|
|
BOOST_CHECK_EQUAL( 3, i );
|
|
}
|
|
{
|
|
int i = 0;
|
|
int j = 1;
|
|
mock::constraint<
|
|
mock::detail::assign<
|
|
boost::reference_wrapper< const int >
|
|
>
|
|
> c = mock::assign( boost::cref( j ) );
|
|
BOOST_CHECK( c.c_( &i ) );
|
|
BOOST_CHECK_EQUAL( 1, i );
|
|
j = 3;
|
|
BOOST_CHECK( c.c_( &i ) );
|
|
BOOST_CHECK_EQUAL( 3, i );
|
|
}
|
|
{
|
|
const int* i = 0;
|
|
int k = 1;
|
|
int* j = &k;
|
|
mock::constraint<
|
|
mock::detail::assign<
|
|
boost::reference_wrapper< int* const >
|
|
>
|
|
> c = mock::assign( boost::cref( j ) );
|
|
BOOST_CHECK( c.c_( i ) );
|
|
BOOST_CHECK_EQUAL( j, i );
|
|
j = 0;
|
|
BOOST_CHECK( c.c_( i ) );
|
|
BOOST_CHECK_EQUAL( j, i );
|
|
}
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( retrieve_constraint )
|
|
{
|
|
{
|
|
int i = 0;
|
|
const int j = 1;
|
|
BOOST_CHECK( mock::retrieve( i ).c_( j ) );
|
|
BOOST_CHECK_EQUAL( i, j );
|
|
}
|
|
{
|
|
int* i = 0;
|
|
int j = 1;
|
|
BOOST_CHECK( mock::retrieve( i ).c_( &j ) );
|
|
BOOST_CHECK_EQUAL( i, &j );
|
|
}
|
|
{
|
|
const int* i = 0;
|
|
const int j = 1;
|
|
BOOST_CHECK( mock::retrieve( i ).c_( j ) );
|
|
BOOST_CHECK_EQUAL( i, &j );
|
|
}
|
|
{
|
|
const int* i = 0;
|
|
int j = 1;
|
|
BOOST_CHECK( mock::retrieve( i ).c_( j ) );
|
|
BOOST_CHECK_EQUAL( i, &j );
|
|
}
|
|
{
|
|
int* i = 0;
|
|
int j = 1;
|
|
BOOST_CHECK( mock::retrieve( i ).c_( j ) );
|
|
BOOST_CHECK_EQUAL( i, &j );
|
|
}
|
|
{
|
|
const int* i = 0;
|
|
const int j = 1;
|
|
BOOST_CHECK( mock::retrieve( i ).c_( j ) );
|
|
BOOST_CHECK_EQUAL( i, &j );
|
|
}
|
|
{
|
|
int** i = 0;
|
|
int* j = 0;
|
|
BOOST_CHECK( mock::retrieve( i ).c_( j ) );
|
|
BOOST_CHECK_EQUAL( i, &j );
|
|
}
|
|
{
|
|
const int** i = 0;
|
|
const int* j = 0;
|
|
BOOST_CHECK( mock::retrieve( i ).c_( j ) );
|
|
BOOST_CHECK_EQUAL( i, &j );
|
|
}
|
|
{
|
|
int i = 0;
|
|
const int j = 1;
|
|
BOOST_CHECK( mock::retrieve( boost::ref( i ) ).c_( j ) );
|
|
BOOST_CHECK_EQUAL( i, j );
|
|
}
|
|
{
|
|
const int* i = 0;
|
|
const int j = 1;
|
|
BOOST_CHECK( mock::retrieve( boost::ref( i ) ).c_( j ) );
|
|
BOOST_CHECK_EQUAL( i, &j );
|
|
}
|
|
#ifdef MOCK_NULLPTR
|
|
{
|
|
std::nullptr_t* i = 0;
|
|
std::nullptr_t j;
|
|
BOOST_CHECK( mock::retrieve( i ).c_( j ) );
|
|
BOOST_CHECK_EQUAL( i, &j );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
namespace
|
|
{
|
|
struct A
|
|
{
|
|
};
|
|
struct B
|
|
{
|
|
B& operator=( const A& )
|
|
{
|
|
return *this;
|
|
}
|
|
};
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( retrieve_constraint_uses_assignment_operator )
|
|
{
|
|
B b;
|
|
const A a = A();
|
|
mock::retrieve( b ).c_( a );
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( affirm_constraint )
|
|
{
|
|
int* i = 0;
|
|
int j;
|
|
BOOST_CHECK( ! mock::affirm.c_( i ) );
|
|
BOOST_CHECK( mock::affirm.c_( &j ) );
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( negate_constraint )
|
|
{
|
|
int* i = 0;
|
|
int j;
|
|
BOOST_CHECK( mock::negate.c_( i ) );
|
|
BOOST_CHECK( ! mock::negate.c_( &j ) );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
bool return_true()
|
|
{
|
|
return true;
|
|
}
|
|
bool return_false()
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( call_constraint )
|
|
{
|
|
BOOST_CHECK( mock::call( &return_true ).c_() );
|
|
BOOST_CHECK( ! mock::call( &return_false ).c_() );
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( evaluate_constraint )
|
|
{
|
|
BOOST_CHECK( mock::evaluate.c_( &return_true ) );
|
|
BOOST_CHECK( ! mock::evaluate.c_( &return_false ) );
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( contain_constraint_with_const_char_ptr )
|
|
{
|
|
BOOST_CHECK( mock::contain( "string" ).c_( "this is a string" ) );
|
|
BOOST_CHECK( mock::contain( "string" ).c_( std::string( "this is a string" ) ) );
|
|
BOOST_CHECK( ! mock::contain( "not found" ).c_( "this is a string" ) );
|
|
BOOST_CHECK( ! mock::contain( "not found" ).c_( std::string( "this is a string" ) ) );
|
|
{
|
|
const char* s = 0;
|
|
mock::constraint<
|
|
mock::detail::contain<
|
|
boost::reference_wrapper< const char* const >
|
|
>
|
|
> c = mock::contain( boost::cref( s ) );
|
|
s = "string";
|
|
BOOST_CHECK( c.c_( "this is a string" ) );
|
|
BOOST_CHECK( c.c_( std::string( "this is a string" ) ) );
|
|
s = "not found";
|
|
BOOST_CHECK( ! c.c_( "this is a string" ) );
|
|
BOOST_CHECK( ! c.c_( std::string( "this is a string" ) ) );
|
|
}
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( contain_constraint_with_strings )
|
|
{
|
|
BOOST_CHECK( mock::contain( std::string( "string" ) ).c_( "this is a string" ) );
|
|
BOOST_CHECK( mock::contain( std::string( "string" ) ).c_( std::string( "this is a string" ) ) );
|
|
BOOST_CHECK( ! mock::contain( std::string( "not found" ) ).c_( "this is a string" ) );
|
|
BOOST_CHECK( ! mock::contain( std::string( "not found" ) ).c_( std::string( "this is a string" ) ) );
|
|
{
|
|
std::string s;
|
|
mock::constraint<
|
|
mock::detail::contain<
|
|
boost::reference_wrapper< const std::string >
|
|
>
|
|
> c = mock::contain( boost::cref( s ) );
|
|
s = "string";
|
|
BOOST_CHECK( c.c_( "this is a string" ) );
|
|
BOOST_CHECK( c.c_( std::string( "this is a string" ) ) );
|
|
s = "not found";
|
|
BOOST_CHECK( ! c.c_( "this is a string" ) );
|
|
BOOST_CHECK( ! c.c_( std::string( "this is a string" ) ) );
|
|
}
|
|
}
|
|
|
|
namespace
|
|
{
|
|
struct type_with_overloaded_address_operator
|
|
{
|
|
void operator&() {}
|
|
void operator&() const {}
|
|
};
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( type_with_overloaded_address_operator_can_be_used_in_constraints )
|
|
{
|
|
type_with_overloaded_address_operator t;
|
|
mock::same( t ).c_( t );
|
|
mock::retrieve( t ).c_( t );
|
|
type_with_overloaded_address_operator* pt;
|
|
mock::retrieve( pt ).c_( t );
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( close_constraint )
|
|
{
|
|
BOOST_CHECK( mock::close( 12.0, 0.0001 ).c_( 12 ) );
|
|
BOOST_CHECK( ! mock::close( 12.0, 0.0001 ).c_( 13 ) );
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( close_fraction_constraint )
|
|
{
|
|
BOOST_CHECK( mock::close_fraction( 12.0, 0.0001 ).c_( 12 ) );
|
|
BOOST_CHECK( ! mock::close_fraction( 12.0, 0.0001 ).c_( 13 ) );
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( small_constraint )
|
|
{
|
|
BOOST_CHECK( mock::small( 0.0001 ).c_( 0. ) );
|
|
BOOST_CHECK( ! mock::small( 0.0001 ).c_( 12. ) );
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE( near_constraint )
|
|
{
|
|
BOOST_CHECK( mock::near( 12.0, 0.0001 ).c_( 12 ) );
|
|
BOOST_CHECK( ! mock::near( 12.0, 0.0001 ).c_( 13 ) );
|
|
}
|