boost/test
2
0
Fork 0
mirror of https://github.com/boostorg/test.git synced 2026-02-18 02:22:09 +00:00
Code Issues Projects Releases Wiki Activity

Porting the rvalue_ref fix to the unit tests

Browse Source
This commit is contained in:
Raffi Enficiaud
2016-01-26 23:24:49 +01:00
parent 541c6be2e7
commit a2e237d4b3
2 changed files with 39 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

109
test/writing-test-ts/assertion-construction-test.cpp
View File

@@ -27,7 +27,7 @@ namespace utf = boost::unit_test;
//____________________________________________________________________________//
#define EXPR_TYPE( E, expr ) auto const& E = assertion::seed() ->* expr
#define EXPR_TYPE( expr ) ( assertion::seed() ->* expr )
// some broken compilers do not implement properly decltype on expressions
// partial implementation of is_forward_iterable when decltype not available
@@ -138,41 +138,35 @@ BOOST_AUTO_TEST_CASE( test_basic_value_expression_construction )
using namespace boost::test_tools;
{
EXPR_TYPE( E_under_test, 1 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( 1 ).evaluate();
BOOST_TEST( res );
BOOST_TEST( res.message().is_empty() );
}
{
EXPR_TYPE( E_under_test, 0 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( 0 ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [(bool)0 is false]" );
}
{
EXPR_TYPE( E_under_test, true );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( true ).evaluate();
BOOST_TEST( res );
BOOST_TEST( res.message().is_empty() );
}
{
EXPR_TYPE( E_under_test, 1.5 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( 1.5 ).evaluate();
BOOST_TEST( res );
}
{
EXPR_TYPE( E_under_test, "abc" );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( "abc" ).evaluate();
BOOST_TEST( res );
}
{
EXPR_TYPE( E_under_test, 1>2 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( 1>2 ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [1 <= 2]" );
}
@@ -186,45 +180,39 @@ BOOST_AUTO_TEST_CASE( test_comparison_expression )
using namespace boost::test_tools;
{
EXPR_TYPE( E_under_test, 1>2 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( 1>2 ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [1 <= 2]" );
}
{
EXPR_TYPE( E_under_test, 100 < 50 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( 100 < 50 ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [100 >= 50]" );
}
{
EXPR_TYPE( E_under_test, 5 <= 4 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( 5 <= 4 ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [5 > 4]" );
}
{
EXPR_TYPE( E_under_test, 10>=20 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( 10>=20 ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [10 < 20]" );
}
{
int i = 10;
EXPR_TYPE( E_under_test, i != 10 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( i != 10 ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [10 == 10]" );
}
{
int i = 5;
EXPR_TYPE( E_under_test, i == 3 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( i == 3 ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [5 != 3]" );
}
@@ -239,8 +227,7 @@ BOOST_AUTO_TEST_CASE( test_arithmetic_ops )
{
int i = 3;
int j = 5;
EXPR_TYPE( E_under_test, i+j !=8 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( i+j !=8 ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [3 + 5 == 8]" );
}
@@ -248,16 +235,14 @@ BOOST_AUTO_TEST_CASE( test_arithmetic_ops )
{
int i = 3;
int j = 5;
EXPR_TYPE( E_under_test, 2*i-j > 1 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( 2*i-j > 1 ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [2 * 3 - 5 <= 1]" );
}
{
int j = 5;
EXPR_TYPE( E_under_test, 2<<j < 30 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( 2<<j < 30 ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [2 << 5 >= 30]" );
}
@@ -265,8 +250,7 @@ BOOST_AUTO_TEST_CASE( test_arithmetic_ops )
{
int i = 2;
int j = 5;
EXPR_TYPE( E_under_test, i&j );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( i&j ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [2 & 5]" );
}
@@ -274,16 +258,15 @@ BOOST_AUTO_TEST_CASE( test_arithmetic_ops )
{
int i = 3;
int j = 5;
EXPR_TYPE( E_under_test, i^j^6 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( i^j^6 ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [3 ^ 5 ^ 6]" );
}
// do not support
// EXPR_TYPE( E_under_test, 99/2 == 48 || 101/2 > 50 );
// EXPR_TYPE( E_under_test, a ? 100 < 50 : 25*2 == 50 );
// EXPR_TYPE( E_under_test, true,false );
// EXPR_TYPE( 99/2 == 48 || 101/2 > 50 );
// EXPR_TYPE( a ? 100 < 50 : 25*2 == 50 );
// EXPR_TYPE( true,false );
}
//____________________________________________________________________________//
@@ -330,8 +313,7 @@ BOOST_AUTO_TEST_CASE( test_objects )
Testee obj;
Testee::s_copy_counter = 0;
EXPR_TYPE( E_under_test, obj );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( obj ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [(bool)Testee is false]" );
BOOST_TEST( Testee::s_copy_counter == expected_copy_count );
@@ -341,8 +323,7 @@ BOOST_AUTO_TEST_CASE( test_objects )
Testee const obj;
Testee::s_copy_counter = 0;
EXPR_TYPE( E_under_test, obj );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( obj ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [(bool)Testee is false]" );
BOOST_TEST( Testee::s_copy_counter == expected_copy_count );
@@ -351,8 +332,7 @@ BOOST_AUTO_TEST_CASE( test_objects )
{
Testee::s_copy_counter = 0;
EXPR_TYPE( E_under_test, get_obj() );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( get_obj() ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [(bool)Testee is false]" );
BOOST_TEST( Testee::s_copy_counter == expected_copy_count );
@@ -361,8 +341,7 @@ BOOST_AUTO_TEST_CASE( test_objects )
{
Testee::s_copy_counter = 0;
EXPR_TYPE( E_under_test, get_const_obj() );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( get_const_obj() ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [(bool)Testee is false]" );
BOOST_TEST( Testee::s_copy_counter == expected_copy_count );
@@ -374,8 +353,7 @@ BOOST_AUTO_TEST_CASE( test_objects )
Testee t1;
Testee t2;
EXPR_TYPE( E_under_test, t1 != t2 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( t1 != t2 ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [Testee == Testee]" );
BOOST_TEST( Testee::s_copy_counter == 0 );
@@ -385,8 +363,7 @@ BOOST_AUTO_TEST_CASE( test_objects )
NC nc1;
NC nc2;
EXPR_TYPE( E_under_test, nc1 == nc2 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( nc1 == nc2 ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [NC != NC]" );
}
@@ -401,8 +378,7 @@ BOOST_AUTO_TEST_CASE( test_pointers )
{
Testee* ptr = 0;
EXPR_TYPE( E_under_test, ptr );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( ptr ).evaluate();
BOOST_TEST( !res );
}
@@ -410,8 +386,7 @@ BOOST_AUTO_TEST_CASE( test_pointers )
Testee obj1;
Testee obj2;
EXPR_TYPE( E_under_test, &obj1 == &obj2 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( &obj1 == &obj2 ).evaluate();
BOOST_TEST( !res );
}
@@ -419,8 +394,7 @@ BOOST_AUTO_TEST_CASE( test_pointers )
Testee obj;
Testee* ptr =&obj;
EXPR_TYPE( E_under_test, *ptr );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( *ptr ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [(bool)Testee is false]" );
}
@@ -430,15 +404,14 @@ BOOST_AUTO_TEST_CASE( test_pointers )
Testee* ptr =&obj;
bool Testee::* mem_ptr =&Testee::m_value;
EXPR_TYPE( E_under_test, ptr->*mem_ptr );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( ptr->*mem_ptr ).evaluate();
BOOST_TEST( !res );
}
// do not support
// Testee obj;
// bool Testee::* mem_ptr =&Testee::m_value;
// EXPR_TYPE( E_under_test, obj.*mem_ptr );
// EXPR_TYPE( obj.*mem_ptr );
}
//____________________________________________________________________________//
@@ -450,8 +423,7 @@ BOOST_AUTO_TEST_CASE( test_mutating_ops )
{
int j = 5;
EXPR_TYPE( E_under_test, j = 0 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( j = 0 ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [(bool)0 is false]" );
BOOST_TEST( j == 0 );
@@ -460,8 +432,7 @@ BOOST_AUTO_TEST_CASE( test_mutating_ops )
{
int j = 5;
EXPR_TYPE( E_under_test, j -= 5 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( j -= 5 ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [(bool)0 is false]" );
BOOST_TEST( j == 0 );
@@ -470,8 +441,7 @@ BOOST_AUTO_TEST_CASE( test_mutating_ops )
{
int j = 5;
EXPR_TYPE( E_under_test, j *= 0 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( j *= 0 ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [(bool)0 is false]" );
BOOST_TEST( j == 0 );
@@ -480,8 +450,7 @@ BOOST_AUTO_TEST_CASE( test_mutating_ops )
{
int j = 5;
EXPR_TYPE( E_under_test, j /= 10 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( j /= 10 ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [(bool)0 is false]" );
BOOST_TEST( j == 0 );
@@ -490,8 +459,7 @@ BOOST_AUTO_TEST_CASE( test_mutating_ops )
{
int j = 4;
EXPR_TYPE( E_under_test, j %= 2 );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( j %= 2 ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [(bool)0 is false]" );
BOOST_TEST( j == 0 );
@@ -500,8 +468,7 @@ BOOST_AUTO_TEST_CASE( test_mutating_ops )
{
int j = 5;
EXPR_TYPE( E_under_test, j ^= j );
predicate_result const& res = E_under_test.evaluate();
predicate_result const& res = EXPR_TYPE( j ^= j ).evaluate();
BOOST_TEST( !res );
BOOST_TEST( res.message() == " [(bool)0 is false]" );
BOOST_TEST( j == 0 );

3
test/writing-test-ts/collection-comparison-test.cpp
View File

@@ -21,8 +21,7 @@ BOOST_TEST_SPECIALIZED_COLLECTION_COMPARE(std::vector<int>)
{ \
BOOST_TEST_INFO( "validating operator " #op ); \
bool expected = (c1 op c2); \
auto const& E_under_test = tt::assertion::seed()->* c1 op c2 ; \
auto const& res = E_under_test.evaluate(); \
auto const& res = (tt::assertion::seed()->* c1 op c2).evaluate(); \
BOOST_TEST( expected == !!res ); \
} \
/**/