mirror of
https://github.com/mat007/turtle.git
synced 2026-06-22 12:13:43 +00:00
Preview of clang-format changes and CI
This commit is contained in:
Alexander Grund
parent
bfd1701fcb
commit
805e3b02bf
98 changed files with 6339 additions and 11357 deletions
|
|
@ -10,414 +10,379 @@
|
|||
#include <boost/test/auto_unit_test.hpp>
|
||||
#include <boost/typeof/typeof.hpp>
|
||||
|
||||
BOOST_AUTO_TEST_CASE( all_comparison_constraints_can_be_instanciated )
|
||||
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 );
|
||||
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 )
|
||||
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 );
|
||||
!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 )
|
||||
BOOST_AUTO_TEST_CASE(constraints_can_be_combined_using_the_or_operator)
|
||||
{
|
||||
mock::less( 0 ) || mock::greater( 0 );
|
||||
mock::less(0) || mock::greater(0);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( constraints_can_be_combined_using_the_and_operator )
|
||||
BOOST_AUTO_TEST_CASE(constraints_can_be_combined_using_the_and_operator)
|
||||
{
|
||||
mock::less( 0 ) && mock::greater( 0 );
|
||||
mock::less(0) && mock::greater(0);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( equal_constraint )
|
||||
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" ) );
|
||||
BOOST_CHECK(mock::equal(std::string("string")).c_("string"));
|
||||
BOOST_CHECK(!mock::equal(std::string("string")).c_("not string"));
|
||||
{
|
||||
std::string s;
|
||||
BOOST_AUTO( c, mock::equal( boost::cref( s ) ) );
|
||||
BOOST_AUTO(c, mock::equal(boost::cref(s)));
|
||||
s = "string";
|
||||
BOOST_CHECK( c.c_( "string" ) );
|
||||
BOOST_CHECK(c.c_("string"));
|
||||
}
|
||||
#ifdef MOCK_SMART_PTR
|
||||
{
|
||||
std::unique_ptr< int > i;
|
||||
std::unique_ptr< int > j( new int( 3 ) );
|
||||
BOOST_CHECK( ! mock::equal( i ).c_( j ) );
|
||||
BOOST_CHECK( ! mock::equal( j ).c_( i ) );
|
||||
BOOST_CHECK( mock::equal( i ).c_( i ) );
|
||||
BOOST_CHECK( mock::equal( j ).c_( j ) );
|
||||
std::unique_ptr<int> i;
|
||||
std::unique_ptr<int> j(new int(3));
|
||||
BOOST_CHECK(!mock::equal(i).c_(j));
|
||||
BOOST_CHECK(!mock::equal(j).c_(i));
|
||||
BOOST_CHECK(mock::equal(i).c_(i));
|
||||
BOOST_CHECK(mock::equal(j).c_(j));
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( equal_constraint_deref )
|
||||
BOOST_AUTO_TEST_CASE(equal_constraint_deref){{int i = 3;
|
||||
BOOST_CHECK(mock::equal(3).c_(&i));
|
||||
BOOST_CHECK(!mock::equal(7).c_(&i));
|
||||
}
|
||||
{
|
||||
{
|
||||
int i = 3;
|
||||
BOOST_CHECK( mock::equal( 3 ).c_( &i ) );
|
||||
BOOST_CHECK( ! mock::equal( 7 ).c_( &i ) );
|
||||
}
|
||||
{
|
||||
int* i = 0;
|
||||
BOOST_CHECK( ! mock::equal( 3 ).c_( i ) );
|
||||
}
|
||||
int* i = 0;
|
||||
BOOST_CHECK(!mock::equal(3).c_(i));
|
||||
}
|
||||
#ifdef MOCK_SMART_PTR
|
||||
{
|
||||
std::unique_ptr< int > j( new int( 3 ) );
|
||||
BOOST_CHECK( mock::equal( 3 ).c_( j ) );
|
||||
std::unique_ptr< int > i;
|
||||
BOOST_CHECK( ! mock::equal( 3 ).c_( i ) );
|
||||
}
|
||||
{
|
||||
std::unique_ptr<int> j(new int(3));
|
||||
BOOST_CHECK(mock::equal(3).c_(j));
|
||||
std::unique_ptr<int> i;
|
||||
BOOST_CHECK(!mock::equal(3).c_(i));
|
||||
}
|
||||
#endif // MOCK_SMART_PTR
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( same_constraint )
|
||||
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 );
|
||||
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 ) );
|
||||
}
|
||||
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 ) );
|
||||
}
|
||||
{
|
||||
std::nullptr_t p;
|
||||
BOOST_CHECK(mock::same(p).c_(p));
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( assign_constraint )
|
||||
BOOST_AUTO_TEST_CASE(assign_constraint)
|
||||
{
|
||||
{
|
||||
int i = 0;
|
||||
BOOST_CHECK( mock::assign( 3 ).c_( i ) );
|
||||
BOOST_CHECK_EQUAL( 3, i );
|
||||
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 );
|
||||
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 );
|
||||
BOOST_CHECK(mock::assign(&j).c_(i));
|
||||
BOOST_CHECK_EQUAL(&j, i);
|
||||
}
|
||||
{
|
||||
int* i = 0;
|
||||
const int j = 1;
|
||||
BOOST_CHECK( ! mock::assign( j ).c_( i ) );
|
||||
BOOST_CHECK( ! i );
|
||||
BOOST_CHECK(!mock::assign(j).c_(i));
|
||||
BOOST_CHECK(!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 );
|
||||
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 );
|
||||
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 );
|
||||
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 );
|
||||
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 );
|
||||
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_CHECK(c.c_(i));
|
||||
BOOST_CHECK_EQUAL(j, i);
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( retrieve_constraint )
|
||||
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 );
|
||||
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 );
|
||||
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 );
|
||||
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 );
|
||||
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 );
|
||||
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 );
|
||||
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 );
|
||||
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 );
|
||||
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 );
|
||||
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 );
|
||||
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 );
|
||||
BOOST_CHECK(mock::retrieve(i).c_(j));
|
||||
BOOST_CHECK_EQUAL(i, &j);
|
||||
}
|
||||
#endif
|
||||
#ifdef MOCK_SMART_PTR
|
||||
{
|
||||
std::unique_ptr< int > i;
|
||||
std::unique_ptr< int > j( new int( 3 ) );
|
||||
BOOST_CHECK( mock::retrieve( i ).c_( boost::move( j ) ) );
|
||||
BOOST_REQUIRE( i );
|
||||
BOOST_CHECK_EQUAL( 3, *i );
|
||||
BOOST_CHECK( !j );
|
||||
std::unique_ptr<int> i;
|
||||
std::unique_ptr<int> j(new int(3));
|
||||
BOOST_CHECK(mock::retrieve(i).c_(boost::move(j)));
|
||||
BOOST_REQUIRE(i);
|
||||
BOOST_CHECK_EQUAL(3, *i);
|
||||
BOOST_CHECK(!j);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
namespace
|
||||
namespace {
|
||||
struct A
|
||||
{};
|
||||
struct B
|
||||
{
|
||||
struct A
|
||||
{
|
||||
};
|
||||
struct B
|
||||
{
|
||||
B& operator=( const A& )
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
}
|
||||
B& operator=(const A&) { return *this; }
|
||||
};
|
||||
} // namespace
|
||||
|
||||
BOOST_AUTO_TEST_CASE( retrieve_constraint_uses_assignment_operator )
|
||||
BOOST_AUTO_TEST_CASE(retrieve_constraint_uses_assignment_operator)
|
||||
{
|
||||
B b;
|
||||
const A a = A();
|
||||
mock::retrieve( b ).c_( a );
|
||||
mock::retrieve(b).c_(a);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( affirm_constraint )
|
||||
BOOST_AUTO_TEST_CASE(affirm_constraint)
|
||||
{
|
||||
{
|
||||
int* i = 0;
|
||||
int j;
|
||||
BOOST_CHECK( ! mock::affirm.c_( i ) );
|
||||
BOOST_CHECK( mock::affirm.c_( &j ) );
|
||||
BOOST_CHECK(!mock::affirm.c_(i));
|
||||
BOOST_CHECK(mock::affirm.c_(&j));
|
||||
}
|
||||
{
|
||||
#ifdef MOCK_SMART_PTR
|
||||
std::unique_ptr< int > i;
|
||||
std::unique_ptr< int > j( new int( 3 ) );
|
||||
BOOST_CHECK( ! mock::affirm.c_( i ) );
|
||||
BOOST_CHECK( mock::affirm.c_( j ) );
|
||||
std::unique_ptr<int> i;
|
||||
std::unique_ptr<int> j(new int(3));
|
||||
BOOST_CHECK(!mock::affirm.c_(i));
|
||||
BOOST_CHECK(mock::affirm.c_(j));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( negate_constraint )
|
||||
BOOST_AUTO_TEST_CASE(negate_constraint)
|
||||
{
|
||||
int* i = 0;
|
||||
int j;
|
||||
BOOST_CHECK( mock::negate.c_( i ) );
|
||||
BOOST_CHECK( ! mock::negate.c_( &j ) );
|
||||
BOOST_CHECK(mock::negate.c_(i));
|
||||
BOOST_CHECK(!mock::negate.c_(&j));
|
||||
}
|
||||
|
||||
namespace
|
||||
namespace {
|
||||
bool return_true()
|
||||
{
|
||||
bool return_true()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
bool return_false()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
bool return_false()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
BOOST_AUTO_TEST_CASE(call_constraint)
|
||||
{
|
||||
BOOST_CHECK(mock::call(&return_true).c_());
|
||||
BOOST_CHECK(!mock::call(&return_false).c_());
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( call_constraint )
|
||||
BOOST_AUTO_TEST_CASE(evaluate_constraint)
|
||||
{
|
||||
BOOST_CHECK( mock::call( &return_true ).c_() );
|
||||
BOOST_CHECK( ! mock::call( &return_false ).c_() );
|
||||
BOOST_CHECK(mock::evaluate.c_(&return_true));
|
||||
BOOST_CHECK(!mock::evaluate.c_(&return_false));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( evaluate_constraint )
|
||||
BOOST_AUTO_TEST_CASE(contain_constraint_with_const_char_ptr)
|
||||
{
|
||||
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" ) ) );
|
||||
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 ) );
|
||||
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" ) ) );
|
||||
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_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_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" ) ) );
|
||||
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 ) );
|
||||
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" ) ) );
|
||||
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_CHECK(!c.c_("this is a string"));
|
||||
BOOST_CHECK(!c.c_(std::string("this is a string")));
|
||||
}
|
||||
}
|
||||
|
||||
namespace
|
||||
namespace {
|
||||
struct type_with_overloaded_address_operator
|
||||
{
|
||||
struct type_with_overloaded_address_operator
|
||||
{
|
||||
void operator&() {}
|
||||
void operator&() const {}
|
||||
};
|
||||
}
|
||||
void operator&() {}
|
||||
void operator&() const {}
|
||||
};
|
||||
} // namespace
|
||||
|
||||
BOOST_AUTO_TEST_CASE( type_with_overloaded_address_operator_can_be_used_in_constraints )
|
||||
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 );
|
||||
mock::same(t).c_(t);
|
||||
mock::retrieve(t).c_(t);
|
||||
type_with_overloaded_address_operator* pt;
|
||||
mock::retrieve( pt ).c_( t );
|
||||
mock::retrieve(pt).c_(t);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( close_constraint )
|
||||
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_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_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_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_AUTO_TEST_CASE(small_constraint)
|
||||
{
|
||||
BOOST_CHECK( mock::small( 0.0001 ).c_( 0. ) );
|
||||
BOOST_CHECK( ! mock::small( 0.0001 ).c_( 12. ) );
|
||||
BOOST_CHECK(mock::small(0.0001).c_(0.));
|
||||
BOOST_CHECK(!mock::small(0.0001).c_(12.));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE( near_constraint )
|
||||
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 ) );
|
||||
BOOST_CHECK(mock::near(12.0, 0.0001).c_(12));
|
||||
BOOST_CHECK(!mock::near(12.0, 0.0001).c_(13));
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue