mirror of
https://github.com/catchorg/Catch2.git
synced 2025-08-01 12:55:40 +02:00
Stripped trailing whitespace from all source code lines
(replaces need for PRs #310 and #504)
This commit is contained in:
Phil Nash
@@ -16,7 +16,7 @@ TEST_CASE
|
||||
)
|
||||
{
|
||||
double d = 1.23;
|
||||
|
||||
|
||||
REQUIRE( d == Approx( 1.23 ) );
|
||||
REQUIRE( d != Approx( 1.22 ) );
|
||||
REQUIRE( d != Approx( 1.24 ) );
|
||||
@@ -34,7 +34,7 @@ TEST_CASE
|
||||
)
|
||||
{
|
||||
double d = 1.23;
|
||||
|
||||
|
||||
REQUIRE( d != Approx( 1.231 ) );
|
||||
REQUIRE( d == Approx( 1.231 ).epsilon( 0.1 ) );
|
||||
}
|
||||
@@ -71,7 +71,7 @@ TEST_CASE
|
||||
const double dZero = 0;
|
||||
const double dSmall = 0.00001;
|
||||
const double dMedium = 1.234;
|
||||
|
||||
|
||||
REQUIRE( 1.0f == Approx( 1 ) );
|
||||
REQUIRE( 0 == Approx( dZero) );
|
||||
REQUIRE( 0 == Approx( dSmall ).epsilon( 0.001 ) );
|
||||
@@ -87,14 +87,14 @@ TEST_CASE
|
||||
)
|
||||
{
|
||||
double d = 1.23;
|
||||
|
||||
|
||||
Approx approx = Approx::custom().epsilon( 0.005 );
|
||||
|
||||
|
||||
REQUIRE( d == approx( 1.23 ) );
|
||||
REQUIRE( d == approx( 1.22 ) );
|
||||
REQUIRE( d == approx( 1.24 ) );
|
||||
REQUIRE( d != approx( 1.25 ) );
|
||||
|
||||
|
||||
REQUIRE( approx( d ) == 1.23 );
|
||||
REQUIRE( approx( d ) == 1.22 );
|
||||
REQUIRE( approx( d ) == 1.24 );
|
||||
|
||||
@@ -30,13 +30,13 @@ SCENARIO( "Vector resizing affects size and capacity", "[vector][bdd][size][capa
|
||||
GIVEN( "an empty vector" ) {
|
||||
std::vector<int> v;
|
||||
REQUIRE( v.size() == 0 );
|
||||
|
||||
|
||||
WHEN( "it is made larger" ) {
|
||||
v.resize( 10 );
|
||||
THEN( "the size and capacity go up" ) {
|
||||
REQUIRE( v.size() == 10 );
|
||||
REQUIRE( v.capacity() >= 10 );
|
||||
|
||||
|
||||
AND_WHEN( "it is made smaller again" ) {
|
||||
v.resize( 5 );
|
||||
THEN( "the size goes down but the capacity stays the same" ) {
|
||||
@@ -46,7 +46,7 @@ SCENARIO( "Vector resizing affects size and capacity", "[vector][bdd][size][capa
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
WHEN( "we reserve more space" ) {
|
||||
v.reserve( 10 );
|
||||
THEN( "The capacity is increased but the size remains the same" ) {
|
||||
@@ -76,19 +76,19 @@ struct Fixture
|
||||
: d_counter(0)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
int counter()
|
||||
{
|
||||
return d_counter++;
|
||||
}
|
||||
|
||||
|
||||
int d_counter;
|
||||
};
|
||||
|
||||
|
||||
}
|
||||
|
||||
SCENARIO_METHOD(Fixture,
|
||||
"BDD tests requiring Fixtures to provide commonly-accessed data or methods",
|
||||
"BDD tests requiring Fixtures to provide commonly-accessed data or methods",
|
||||
"[bdd][fixtures]") {
|
||||
const int before(counter());
|
||||
GIVEN("No operations precede me") {
|
||||
|
||||
@@ -13,18 +13,18 @@ namespace
|
||||
class TestClass
|
||||
{
|
||||
std::string s;
|
||||
|
||||
|
||||
public:
|
||||
TestClass()
|
||||
: s( "hello" )
|
||||
{}
|
||||
|
||||
|
||||
void succeedingCase()
|
||||
{
|
||||
{
|
||||
REQUIRE( s == "hello" );
|
||||
}
|
||||
void failingCase()
|
||||
{
|
||||
{
|
||||
REQUIRE( s == "world" );
|
||||
}
|
||||
};
|
||||
@@ -38,20 +38,20 @@ METHOD_AS_TEST_CASE( TestClass::failingCase, "A METHOD_AS_TEST_CASE based test r
|
||||
struct Fixture
|
||||
{
|
||||
Fixture() : m_a( 1 ) {}
|
||||
|
||||
|
||||
int m_a;
|
||||
};
|
||||
|
||||
TEST_CASE_METHOD( Fixture, "A TEST_CASE_METHOD based test run that succeeds", "[class]" )
|
||||
{
|
||||
REQUIRE( m_a == 1 );
|
||||
{
|
||||
REQUIRE( m_a == 1 );
|
||||
}
|
||||
|
||||
// We should be able to write our tests within a different namespace
|
||||
namespace Inner
|
||||
{
|
||||
TEST_CASE_METHOD( Fixture, "A TEST_CASE_METHOD based test run that fails", "[.][class][failing]" )
|
||||
{
|
||||
REQUIRE( m_a == 2 );
|
||||
{
|
||||
REQUIRE( m_a == 2 );
|
||||
}
|
||||
}
|
||||
|
||||
@@ -22,7 +22,7 @@ struct TestData {
|
||||
float_nine_point_one( 9.1f ),
|
||||
double_pi( 3.1415926535 )
|
||||
{}
|
||||
|
||||
|
||||
int int_seven;
|
||||
std::string str_hello;
|
||||
float float_nine_point_one;
|
||||
@@ -37,7 +37,7 @@ struct TestDef {
|
||||
TestDef& operator[]( const std::string& ) {
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
};
|
||||
|
||||
// The "failing" tests all use the CHECK macro, which continues if the specific test fails.
|
||||
@@ -49,14 +49,14 @@ TEST_CASE( "Equality checks that should succeed", "" )
|
||||
|
||||
TestDef td;
|
||||
td + "hello" + "hello";
|
||||
|
||||
|
||||
TestData data;
|
||||
|
||||
|
||||
REQUIRE( data.int_seven == 7 );
|
||||
REQUIRE( data.float_nine_point_one == Approx( 9.1f ) );
|
||||
REQUIRE( data.double_pi == Approx( 3.1415926535 ) );
|
||||
REQUIRE( data.str_hello == "hello" );
|
||||
REQUIRE( "hello" == data.str_hello );
|
||||
REQUIRE( "hello" == data.str_hello );
|
||||
REQUIRE( data.str_hello.size() == 5 );
|
||||
|
||||
double x = 1.1 + 0.1 + 0.1;
|
||||
@@ -66,7 +66,7 @@ TEST_CASE( "Equality checks that should succeed", "" )
|
||||
TEST_CASE( "Equality checks that should fail", "[.][failing][!mayfail]" )
|
||||
{
|
||||
TestData data;
|
||||
|
||||
|
||||
CHECK( data.int_seven == 6 );
|
||||
CHECK( data.int_seven == 8 );
|
||||
CHECK( data.int_seven == 0 );
|
||||
@@ -87,7 +87,7 @@ TEST_CASE( "Equality checks that should fail", "[.][failing][!mayfail]" )
|
||||
TEST_CASE( "Inequality checks that should succeed", "" )
|
||||
{
|
||||
TestData data;
|
||||
|
||||
|
||||
REQUIRE( data.int_seven != 6 );
|
||||
REQUIRE( data.int_seven != 8 );
|
||||
REQUIRE( data.float_nine_point_one != Approx( 9.11f ) );
|
||||
@@ -104,7 +104,7 @@ TEST_CASE( "Inequality checks that should succeed", "" )
|
||||
TEST_CASE( "Inequality checks that should fail", "[.][failing]" )
|
||||
{
|
||||
TestData data;
|
||||
|
||||
|
||||
CHECK( data.int_seven != 7 );
|
||||
CHECK( data.float_nine_point_one != Approx( 9.1f ) );
|
||||
CHECK( data.double_pi != Approx( 3.1415926535 ) );
|
||||
@@ -116,7 +116,7 @@ TEST_CASE( "Inequality checks that should fail", "[.][failing]" )
|
||||
TEST_CASE( "Ordering comparison checks that should succeed", "" )
|
||||
{
|
||||
TestData data;
|
||||
|
||||
|
||||
REQUIRE( data.int_seven < 8 );
|
||||
REQUIRE( data.int_seven > 6 );
|
||||
REQUIRE( data.int_seven > 0 );
|
||||
@@ -126,14 +126,14 @@ TEST_CASE( "Ordering comparison checks that should succeed", "" )
|
||||
REQUIRE( data.int_seven >= 6 );
|
||||
REQUIRE( data.int_seven <= 7 );
|
||||
REQUIRE( data.int_seven <= 8 );
|
||||
|
||||
|
||||
REQUIRE( data.float_nine_point_one > 9 );
|
||||
REQUIRE( data.float_nine_point_one < 10 );
|
||||
REQUIRE( data.float_nine_point_one < 9.2 );
|
||||
|
||||
|
||||
REQUIRE( data.str_hello <= "hello" );
|
||||
REQUIRE( data.str_hello >= "hello" );
|
||||
|
||||
|
||||
REQUIRE( data.str_hello < "hellp" );
|
||||
REQUIRE( data.str_hello < "zebra" );
|
||||
REQUIRE( data.str_hello > "hellm" );
|
||||
@@ -143,7 +143,7 @@ TEST_CASE( "Ordering comparison checks that should succeed", "" )
|
||||
TEST_CASE( "Ordering comparison checks that should fail", "[.][failing]" )
|
||||
{
|
||||
TestData data;
|
||||
|
||||
|
||||
CHECK( data.int_seven > 7 );
|
||||
CHECK( data.int_seven < 7 );
|
||||
CHECK( data.int_seven > 8 );
|
||||
@@ -153,11 +153,11 @@ TEST_CASE( "Ordering comparison checks that should fail", "[.][failing]" )
|
||||
|
||||
CHECK( data.int_seven >= 8 );
|
||||
CHECK( data.int_seven <= 6 );
|
||||
|
||||
|
||||
CHECK( data.float_nine_point_one < 9 );
|
||||
CHECK( data.float_nine_point_one > 10 );
|
||||
CHECK( data.float_nine_point_one > 9.2 );
|
||||
|
||||
|
||||
CHECK( data.str_hello > "hello" );
|
||||
CHECK( data.str_hello < "hello" );
|
||||
CHECK( data.str_hello > "hellp" );
|
||||
@@ -178,7 +178,7 @@ TEST_CASE( "Comparisons with int literals don't warn when mixing signed/ unsigne
|
||||
unsigned long ul = 4;
|
||||
char c = 5;
|
||||
unsigned char uc = 6;
|
||||
|
||||
|
||||
REQUIRE( i == 1 );
|
||||
REQUIRE( ui == 2 );
|
||||
REQUIRE( l == 3 );
|
||||
@@ -215,7 +215,7 @@ TEST_CASE( "comparisons between int variables", "" )
|
||||
unsigned short unsigned_short_var = 1;
|
||||
unsigned int unsigned_int_var = 1;
|
||||
unsigned long unsigned_long_var = 1L;
|
||||
|
||||
|
||||
REQUIRE( long_var == unsigned_char_var );
|
||||
REQUIRE( long_var == unsigned_short_var );
|
||||
REQUIRE( long_var == unsigned_int_var );
|
||||
@@ -252,7 +252,7 @@ template<typename T>
|
||||
struct Ex
|
||||
{
|
||||
Ex( T ){}
|
||||
|
||||
|
||||
bool operator == ( const T& ) const { return true; }
|
||||
T operator * ( const T& ) const { return T(); }
|
||||
};
|
||||
@@ -273,13 +273,13 @@ TEST_CASE( "Pointers can be compared to null", "" )
|
||||
{
|
||||
TestData* p = CATCH_NULL;
|
||||
TestData* pNULL = CATCH_NULL;
|
||||
|
||||
|
||||
REQUIRE( p == CATCH_NULL );
|
||||
REQUIRE( p == pNULL );
|
||||
|
||||
|
||||
TestData data;
|
||||
p = &data;
|
||||
|
||||
|
||||
REQUIRE( p != CATCH_NULL );
|
||||
|
||||
const TestData* cp = p;
|
||||
@@ -290,7 +290,7 @@ TEST_CASE( "Pointers can be compared to null", "" )
|
||||
|
||||
REQUIRE( returnsNull() == CATCH_NULL );
|
||||
REQUIRE( returnsConstNull() == CATCH_NULL );
|
||||
|
||||
|
||||
REQUIRE( CATCH_NULL != p );
|
||||
}
|
||||
|
||||
@@ -304,7 +304,7 @@ TEST_CASE( "Pointers can be compared to null", "" )
|
||||
TEST_CASE( "'Not' checks that should succeed", "" )
|
||||
{
|
||||
bool falseValue = false;
|
||||
|
||||
|
||||
REQUIRE( false == false );
|
||||
REQUIRE( true == true );
|
||||
REQUIRE( !false );
|
||||
@@ -320,15 +320,15 @@ TEST_CASE( "'Not' checks that should succeed", "" )
|
||||
TEST_CASE( "'Not' checks that should fail", "[.][failing]" )
|
||||
{
|
||||
bool trueValue = true;
|
||||
|
||||
|
||||
CHECK( false != false );
|
||||
CHECK( true != true );
|
||||
CHECK( !true );
|
||||
CHECK_FALSE( true );
|
||||
|
||||
|
||||
CHECK( !trueValue );
|
||||
CHECK_FALSE( trueValue );
|
||||
|
||||
|
||||
CHECK( !(1 == 1) );
|
||||
CHECK_FALSE( 1 == 1 );
|
||||
}
|
||||
|
||||
@@ -96,12 +96,12 @@ public:
|
||||
CustomException( const std::string& msg )
|
||||
: m_msg( msg )
|
||||
{}
|
||||
|
||||
|
||||
std::string getMessage() const
|
||||
{
|
||||
return m_msg;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
std::string m_msg;
|
||||
};
|
||||
|
||||
@@ -19,10 +19,10 @@ inline int multiply( int a, int b )
|
||||
CATCH_TEST_CASE( "Generators over two ranges", "[generators]" )
|
||||
{
|
||||
using namespace Catch::Generators;
|
||||
|
||||
|
||||
int i = CATCH_GENERATE( between( 1, 5 ).then( values( 15, 20, 21 ).then( 36 ) ) );
|
||||
int j = CATCH_GENERATE( between( 100, 107 ) );
|
||||
|
||||
|
||||
CATCH_REQUIRE( multiply( i, 2 ) == i*2 );
|
||||
CATCH_REQUIRE( multiply( j, 2 ) == j*2 );
|
||||
}
|
||||
@@ -32,11 +32,11 @@ struct IntPair { int first, second; };
|
||||
CATCH_TEST_CASE( "Generator over a range of pairs", "[generators]" )
|
||||
{
|
||||
using namespace Catch::Generators;
|
||||
|
||||
|
||||
IntPair p[] = { { 0, 1 }, { 2, 3 } };
|
||||
|
||||
|
||||
IntPair* i = CATCH_GENERATE( between( p, &p[1] ) );
|
||||
|
||||
|
||||
CATCH_REQUIRE( i->first == i->second-1 );
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -38,7 +38,7 @@ TEST_CASE( "INFO gets logged on failure, even if captured before successful asse
|
||||
CHECK( a == 2 );
|
||||
|
||||
INFO( "this message should be logged" );
|
||||
|
||||
|
||||
CHECK( a == 1 );
|
||||
|
||||
INFO( "and this, but later" );
|
||||
@@ -85,7 +85,7 @@ TEST_CASE( "Standard output from all sections is reported", "[messages][.]" )
|
||||
{
|
||||
std::cout << "Message from section one" << std::endl;
|
||||
}
|
||||
|
||||
|
||||
SECTION( "two", "" )
|
||||
{
|
||||
std::cout << "Message from section two" << std::endl;
|
||||
|
||||
@@ -21,7 +21,7 @@ TEST_CASE( "random SECTION tests", "[.][sections][failing]" )
|
||||
{
|
||||
int a = 1;
|
||||
int b = 2;
|
||||
|
||||
|
||||
SECTION( "s1", "doesn't equal" )
|
||||
{
|
||||
REQUIRE( a != b );
|
||||
@@ -38,7 +38,7 @@ TEST_CASE( "nested SECTION tests", "[.][sections][failing]" )
|
||||
{
|
||||
int a = 1;
|
||||
int b = 2;
|
||||
|
||||
|
||||
SECTION( "s1", "doesn't equal" )
|
||||
{
|
||||
REQUIRE( a != b );
|
||||
@@ -55,7 +55,7 @@ TEST_CASE( "more nested SECTION tests", "[sections][failing][.]" )
|
||||
{
|
||||
int a = 1;
|
||||
int b = 2;
|
||||
|
||||
|
||||
SECTION( "s1", "doesn't equal" )
|
||||
{
|
||||
SECTION( "s2", "equal" )
|
||||
@@ -82,7 +82,7 @@ TEST_CASE( "even more nested SECTION tests", "[sections]" )
|
||||
{
|
||||
SUCCEED(""); // avoid failing due to no tests
|
||||
}
|
||||
|
||||
|
||||
SECTION( "e (leaf)", "" )
|
||||
{
|
||||
SUCCEED(""); // avoid failing due to no tests
|
||||
@@ -98,14 +98,14 @@ TEST_CASE( "even more nested SECTION tests", "[sections]" )
|
||||
TEST_CASE( "looped SECTION tests", "[.][failing][sections]" )
|
||||
{
|
||||
int a = 1;
|
||||
|
||||
|
||||
for( int b = 0; b < 10; ++b )
|
||||
{
|
||||
std::ostringstream oss;
|
||||
oss << "b is currently: " << b;
|
||||
SECTION( "s1", oss.str() )
|
||||
{
|
||||
CHECK( b > a );
|
||||
CHECK( b > a );
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -113,18 +113,18 @@ TEST_CASE( "looped SECTION tests", "[.][failing][sections]" )
|
||||
TEST_CASE( "looped tests", "[.][failing]" )
|
||||
{
|
||||
static const int fib[] = { 1, 1, 2, 3, 5, 8, 13, 21 };
|
||||
|
||||
|
||||
for( size_t i=0; i < sizeof(fib)/sizeof(int); ++i )
|
||||
{
|
||||
INFO( "Testing if fib[" << i << "] (" << fib[i] << ") is even" );
|
||||
CHECK( ( fib[i] % 2 ) == 0 );
|
||||
CHECK( ( fib[i] % 2 ) == 0 );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "Sends stuff to stdout and stderr", "[.]" )
|
||||
{
|
||||
std::cout << "A string sent directly to stdout" << std::endl;
|
||||
|
||||
|
||||
std::cerr << "A string sent directly to stderr" << std::endl;
|
||||
}
|
||||
|
||||
@@ -162,7 +162,7 @@ inline bool testCheckedElse( bool flag )
|
||||
{
|
||||
CHECKED_ELSE( flag )
|
||||
return false;
|
||||
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -191,13 +191,13 @@ TEST_CASE( "xmlentitycheck", "" )
|
||||
TEST_CASE( "send a single char to INFO", "[failing][.]" )
|
||||
{
|
||||
INFO(3);
|
||||
REQUIRE(false);
|
||||
REQUIRE(false);
|
||||
}
|
||||
|
||||
TEST_CASE( "atomic if", "[failing][0]")
|
||||
{
|
||||
size_t x = 0;
|
||||
|
||||
|
||||
if( x )
|
||||
REQUIRE(x > 0);
|
||||
else
|
||||
@@ -211,7 +211,7 @@ inline const char* testStringForMatching()
|
||||
|
||||
TEST_CASE("String matchers", "[matchers]" )
|
||||
{
|
||||
REQUIRE_THAT( testStringForMatching(), Contains( "string" ) );
|
||||
REQUIRE_THAT( testStringForMatching(), Contains( "string" ) );
|
||||
CHECK_THAT( testStringForMatching(), Contains( "abc" ) );
|
||||
|
||||
CHECK_THAT( testStringForMatching(), StartsWith( "this" ) );
|
||||
@@ -297,38 +297,38 @@ TEST_CASE( "second tag", "[tag2]" )
|
||||
TEST_CASE( "vectors can be sized and resized", "[vector]" ) {
|
||||
|
||||
std::vector<int> v( 5 );
|
||||
|
||||
|
||||
REQUIRE( v.size() == 5 );
|
||||
REQUIRE( v.capacity() >= 5 );
|
||||
|
||||
|
||||
SECTION( "resizing bigger changes size and capacity", "" ) {
|
||||
v.resize( 10 );
|
||||
|
||||
|
||||
REQUIRE( v.size() == 10 );
|
||||
REQUIRE( v.capacity() >= 10 );
|
||||
}
|
||||
SECTION( "resizing smaller changes size but not capacity", "" ) {
|
||||
v.resize( 0 );
|
||||
|
||||
|
||||
REQUIRE( v.size() == 0 );
|
||||
REQUIRE( v.capacity() >= 5 );
|
||||
|
||||
|
||||
SECTION( "We can use the 'swap trick' to reset the capacity", "" ) {
|
||||
std::vector<int> empty;
|
||||
empty.swap( v );
|
||||
|
||||
|
||||
REQUIRE( v.capacity() == 0 );
|
||||
}
|
||||
}
|
||||
SECTION( "reserving bigger changes capacity but not size", "" ) {
|
||||
v.reserve( 10 );
|
||||
|
||||
|
||||
REQUIRE( v.size() == 5 );
|
||||
REQUIRE( v.capacity() >= 10 );
|
||||
}
|
||||
SECTION( "reserving smaller does not change size or capacity", "" ) {
|
||||
v.reserve( 0 );
|
||||
|
||||
|
||||
REQUIRE( v.size() == 5 );
|
||||
REQUIRE( v.capacity() >= 5 );
|
||||
}
|
||||
@@ -426,7 +426,7 @@ TEST_CASE( "XmlEncode" ) {
|
||||
#ifdef CATCH_CONFIG_CPP11_LONG_LONG
|
||||
TEST_CASE( "long long" ) {
|
||||
long long l = std::numeric_limits<long long>::max();
|
||||
|
||||
|
||||
REQUIRE( l == std::numeric_limits<long long>::max() );
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -12,13 +12,13 @@
|
||||
namespace Catch
|
||||
{
|
||||
class LocalContext {
|
||||
|
||||
|
||||
public:
|
||||
TrackerContext& operator()() const {
|
||||
return TrackerContext::instance();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
} // namespace Catch
|
||||
|
||||
inline Catch::TrackerContext& C_A_T_C_H_Context() {
|
||||
@@ -37,11 +37,11 @@ using namespace Catch;
|
||||
//}
|
||||
|
||||
TEST_CASE( "Tracker", "" ) {
|
||||
|
||||
|
||||
TrackerContext ctx;
|
||||
ctx.startRun();
|
||||
ctx.startCycle();
|
||||
|
||||
|
||||
ITracker& testCase = SectionTracker::acquire( ctx, "Testcase" );
|
||||
REQUIRE( testCase.isOpen() );
|
||||
|
||||
@@ -57,13 +57,13 @@ TEST_CASE( "Tracker", "" ) {
|
||||
REQUIRE( ctx.completedCycle() );
|
||||
REQUIRE( testCase.isSuccessfullyCompleted() );
|
||||
}
|
||||
|
||||
|
||||
SECTION( "fail one section", "" ) {
|
||||
s1.fail();
|
||||
REQUIRE( s1.isComplete() );
|
||||
REQUIRE( s1.isSuccessfullyCompleted() == false );
|
||||
REQUIRE( testCase.isComplete() == false );
|
||||
|
||||
|
||||
testCase.close();
|
||||
REQUIRE( ctx.completedCycle() );
|
||||
REQUIRE( testCase.isSuccessfullyCompleted() == false );
|
||||
@@ -72,10 +72,10 @@ TEST_CASE( "Tracker", "" ) {
|
||||
ctx.startCycle();
|
||||
ITracker& testCase2 = SectionTracker::acquire( ctx, "Testcase" );
|
||||
REQUIRE( testCase2.isOpen() );
|
||||
|
||||
|
||||
ITracker& s1b = SectionTracker::acquire( ctx, "S1" );
|
||||
REQUIRE( s1b.isOpen() == false );
|
||||
|
||||
|
||||
testCase2.close();
|
||||
REQUIRE( ctx.completedCycle() );
|
||||
REQUIRE( testCase.isComplete() );
|
||||
@@ -85,7 +85,7 @@ TEST_CASE( "Tracker", "" ) {
|
||||
ctx.startCycle();
|
||||
ITracker& testCase2 = SectionTracker::acquire( ctx, "Testcase" );
|
||||
REQUIRE( testCase2.isOpen() );
|
||||
|
||||
|
||||
ITracker& s1b = SectionTracker::acquire( ctx, "S1" );
|
||||
REQUIRE( s1b.isOpen() == false );
|
||||
|
||||
@@ -94,19 +94,19 @@ TEST_CASE( "Tracker", "" ) {
|
||||
|
||||
s2.close();
|
||||
REQUIRE( ctx.completedCycle() );
|
||||
|
||||
|
||||
testCase2.close();
|
||||
REQUIRE( testCase.isComplete() );
|
||||
REQUIRE( testCase.isSuccessfullyCompleted() );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
SECTION( "successfully close one section, then find another", "" ) {
|
||||
s1.close();
|
||||
|
||||
|
||||
ITracker& s2 = SectionTracker::acquire( ctx, "S2" );
|
||||
REQUIRE( s2.isOpen() == false );
|
||||
|
||||
|
||||
testCase.close();
|
||||
REQUIRE( testCase.isComplete() == false );
|
||||
|
||||
@@ -114,7 +114,7 @@ TEST_CASE( "Tracker", "" ) {
|
||||
ctx.startCycle();
|
||||
ITracker& testCase2 = SectionTracker::acquire( ctx, "Testcase" );
|
||||
REQUIRE( testCase2.isOpen() );
|
||||
|
||||
|
||||
ITracker& s1b = SectionTracker::acquire( ctx, "S1" );
|
||||
REQUIRE( s1b.isOpen() == false );
|
||||
|
||||
@@ -122,14 +122,14 @@ TEST_CASE( "Tracker", "" ) {
|
||||
REQUIRE( s2b.isOpen() );
|
||||
|
||||
REQUIRE( ctx.completedCycle() == false );
|
||||
|
||||
|
||||
SECTION ("Successfully close S2") {
|
||||
s2b.close();
|
||||
REQUIRE( ctx.completedCycle() );
|
||||
|
||||
REQUIRE( s2b.isSuccessfullyCompleted() );
|
||||
REQUIRE( testCase2.isComplete() == false );
|
||||
|
||||
|
||||
testCase2.close();
|
||||
REQUIRE( testCase2.isSuccessfullyCompleted() );
|
||||
}
|
||||
@@ -139,7 +139,7 @@ TEST_CASE( "Tracker", "" ) {
|
||||
|
||||
REQUIRE( s2b.isComplete() );
|
||||
REQUIRE( s2b.isSuccessfullyCompleted() == false );
|
||||
|
||||
|
||||
testCase2.close();
|
||||
REQUIRE( testCase2.isSuccessfullyCompleted() == false );
|
||||
|
||||
@@ -147,19 +147,19 @@ TEST_CASE( "Tracker", "" ) {
|
||||
ctx.startCycle();
|
||||
ITracker& testCase3 = SectionTracker::acquire( ctx, "Testcase" );
|
||||
REQUIRE( testCase3.isOpen() );
|
||||
|
||||
|
||||
ITracker& s1c = SectionTracker::acquire( ctx, "S1" );
|
||||
REQUIRE( s1c.isOpen() == false );
|
||||
|
||||
|
||||
ITracker& s2c = SectionTracker::acquire( ctx, "S2" );
|
||||
REQUIRE( s2c.isOpen() == false );
|
||||
|
||||
|
||||
testCase3.close();
|
||||
REQUIRE( testCase3.isSuccessfullyCompleted() );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
SECTION( "open a nested section", "" ) {
|
||||
ITracker& s2 = SectionTracker::acquire( ctx, "S2" );
|
||||
REQUIRE( s2.isOpen() );
|
||||
@@ -167,15 +167,15 @@ TEST_CASE( "Tracker", "" ) {
|
||||
s2.close();
|
||||
REQUIRE( s2.isComplete() );
|
||||
REQUIRE( s1.isComplete() == false );
|
||||
|
||||
|
||||
s1.close();
|
||||
REQUIRE( s1.isComplete() );
|
||||
REQUIRE( testCase.isComplete() == false );
|
||||
|
||||
|
||||
testCase.close();
|
||||
REQUIRE( testCase.isComplete() );
|
||||
}
|
||||
|
||||
|
||||
SECTION( "start a generator", "" ) {
|
||||
IndexTracker& g1 = IndexTracker::acquire( ctx, "G1", 2 );
|
||||
REQUIRE( g1.isOpen() );
|
||||
@@ -195,17 +195,17 @@ TEST_CASE( "Tracker", "" ) {
|
||||
ctx.startCycle();
|
||||
ITracker& testCase2 = SectionTracker::acquire( ctx, "Testcase" );
|
||||
REQUIRE( testCase2.isOpen() );
|
||||
|
||||
|
||||
ITracker& s1b = SectionTracker::acquire( ctx, "S1" );
|
||||
REQUIRE( s1b.isOpen() );
|
||||
|
||||
|
||||
|
||||
|
||||
IndexTracker& g1b = IndexTracker::acquire( ctx, "G1", 2 );
|
||||
REQUIRE( g1b.isOpen() );
|
||||
REQUIRE( g1b.index() == 1 );
|
||||
|
||||
|
||||
REQUIRE( s1.isComplete() == false );
|
||||
|
||||
|
||||
s1b.close();
|
||||
REQUIRE( s1b.isComplete() );
|
||||
REQUIRE( g1b.isComplete() );
|
||||
@@ -225,98 +225,98 @@ TEST_CASE( "Tracker", "" ) {
|
||||
|
||||
testCase.close();
|
||||
REQUIRE( testCase.isComplete() == false );
|
||||
|
||||
|
||||
SECTION( "Re-enter for second generation", "" ) {
|
||||
ctx.startCycle();
|
||||
ITracker& testCase2 = SectionTracker::acquire( ctx, "Testcase" );
|
||||
REQUIRE( testCase2.isOpen() );
|
||||
|
||||
|
||||
ITracker& s1b = SectionTracker::acquire( ctx, "S1" );
|
||||
REQUIRE( s1b.isOpen() );
|
||||
|
||||
|
||||
// generator - next value
|
||||
IndexTracker& g1b = IndexTracker::acquire( ctx, "G1", 2 );
|
||||
REQUIRE( g1b.isOpen() );
|
||||
REQUIRE( g1b.index() == 1 );
|
||||
|
||||
|
||||
// inner section again
|
||||
ITracker& s2b = SectionTracker::acquire( ctx, "S2" );
|
||||
REQUIRE( s2b.isOpen() );
|
||||
|
||||
|
||||
s2b.close();
|
||||
REQUIRE( s2b.isComplete() );
|
||||
|
||||
|
||||
s1b.close();
|
||||
REQUIRE( g1b.isComplete() );
|
||||
REQUIRE( s1b.isComplete() );
|
||||
|
||||
|
||||
testCase2.close();
|
||||
REQUIRE( testCase2.isComplete() );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
SECTION( "Fail an inner section", "" ) {
|
||||
ITracker& s2 = SectionTracker::acquire( ctx, "S2" );
|
||||
REQUIRE( s2.isOpen() );
|
||||
|
||||
|
||||
s2.fail();
|
||||
REQUIRE( s2.isComplete() );
|
||||
REQUIRE( s2.isSuccessfullyCompleted() == false );
|
||||
|
||||
|
||||
s1.close();
|
||||
REQUIRE( s1.isComplete() == false );
|
||||
|
||||
|
||||
testCase.close();
|
||||
REQUIRE( testCase.isComplete() == false );
|
||||
|
||||
|
||||
SECTION( "Re-enter for second generation", "" ) {
|
||||
ctx.startCycle();
|
||||
ITracker& testCase2 = SectionTracker::acquire( ctx, "Testcase" );
|
||||
REQUIRE( testCase2.isOpen() );
|
||||
|
||||
|
||||
ITracker& s1b = SectionTracker::acquire( ctx, "S1" );
|
||||
REQUIRE( s1b.isOpen() );
|
||||
|
||||
|
||||
// generator - still same value
|
||||
IndexTracker& g1b = IndexTracker::acquire( ctx, "G1", 2 );
|
||||
REQUIRE( g1b.isOpen() );
|
||||
REQUIRE( g1b.index() == 0 );
|
||||
|
||||
|
||||
// inner section again - this time won't open
|
||||
ITracker& s2b = SectionTracker::acquire( ctx, "S2" );
|
||||
REQUIRE( s2b.isOpen() == false );
|
||||
|
||||
|
||||
s1b.close();
|
||||
REQUIRE( g1b.isComplete() == false );
|
||||
REQUIRE( s1b.isComplete() == false );
|
||||
|
||||
|
||||
testCase2.close();
|
||||
REQUIRE( testCase2.isComplete() == false );
|
||||
|
||||
|
||||
// Another cycle - now should complete
|
||||
ctx.startCycle();
|
||||
ITracker& testCase3 = SectionTracker::acquire( ctx, "Testcase" );
|
||||
REQUIRE( testCase3.isOpen() );
|
||||
|
||||
|
||||
ITracker& s1c = SectionTracker::acquire( ctx, "S1" );
|
||||
REQUIRE( s1c.isOpen() );
|
||||
|
||||
|
||||
// generator - now next value
|
||||
IndexTracker& g1c = IndexTracker::acquire( ctx, "G1", 2 );
|
||||
REQUIRE( g1c.isOpen() );
|
||||
REQUIRE( g1c.index() == 1 );
|
||||
|
||||
|
||||
// inner section - now should open again
|
||||
ITracker& s2c = SectionTracker::acquire( ctx, "S2" );
|
||||
REQUIRE( s2c.isOpen() );
|
||||
|
||||
|
||||
s2c.close();
|
||||
REQUIRE( s2c.isComplete() );
|
||||
|
||||
|
||||
s1c.close();
|
||||
REQUIRE( g1c.isComplete() );
|
||||
REQUIRE( s1c.isComplete() );
|
||||
|
||||
|
||||
testCase3.close();
|
||||
REQUIRE( testCase3.isComplete() );
|
||||
}
|
||||
|
||||
@@ -49,13 +49,13 @@ TEST_CASE( "Process can be configured on command line", "[config][command-line]"
|
||||
SECTION( "default - no arguments", "" ) {
|
||||
const char* argv[] = { "test" };
|
||||
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
|
||||
|
||||
|
||||
CHECK( config.shouldDebugBreak == false );
|
||||
CHECK( config.abortAfter == -1 );
|
||||
CHECK( config.noThrow == false );
|
||||
CHECK( config.reporterNames.empty() );
|
||||
}
|
||||
|
||||
|
||||
SECTION( "test lists", "" ) {
|
||||
SECTION( "1 test", "Specify one test case using" ) {
|
||||
const char* argv[] = { "test", "test1" };
|
||||
@@ -84,24 +84,24 @@ TEST_CASE( "Process can be configured on command line", "[config][command-line]"
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
SECTION( "reporter", "" ) {
|
||||
SECTION( "-r/console", "" ) {
|
||||
const char* argv[] = { "test", "-r", "console" };
|
||||
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
|
||||
|
||||
|
||||
REQUIRE( config.reporterNames[0] == "console" );
|
||||
}
|
||||
SECTION( "-r/xml", "" ) {
|
||||
const char* argv[] = { "test", "-r", "xml" };
|
||||
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
|
||||
|
||||
|
||||
REQUIRE( config.reporterNames[0] == "xml" );
|
||||
}
|
||||
SECTION( "-r xml and junit", "" ) {
|
||||
const char* argv[] = { "test", "-r", "xml", "-r", "junit" };
|
||||
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
|
||||
|
||||
|
||||
REQUIRE( config.reporterNames.size() == 2 );
|
||||
REQUIRE( config.reporterNames[0] == "xml" );
|
||||
REQUIRE( config.reporterNames[1] == "junit" );
|
||||
@@ -109,26 +109,26 @@ TEST_CASE( "Process can be configured on command line", "[config][command-line]"
|
||||
SECTION( "--reporter/junit", "" ) {
|
||||
const char* argv[] = { "test", "--reporter", "junit" };
|
||||
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
|
||||
|
||||
|
||||
REQUIRE( config.reporterNames[0] == "junit" );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
SECTION( "debugger", "" ) {
|
||||
SECTION( "-b", "" ) {
|
||||
const char* argv[] = { "test", "-b" };
|
||||
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
|
||||
|
||||
|
||||
REQUIRE( config.shouldDebugBreak == true );
|
||||
}
|
||||
SECTION( "--break", "" ) {
|
||||
const char* argv[] = { "test", "--break" };
|
||||
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
|
||||
|
||||
|
||||
REQUIRE( config.shouldDebugBreak );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
SECTION( "abort", "" ) {
|
||||
SECTION( "-a aborts after first failure", "" ) {
|
||||
const char* argv[] = { "test", "-a" };
|
||||
@@ -151,7 +151,7 @@ TEST_CASE( "Process can be configured on command line", "[config][command-line]"
|
||||
REQUIRE_THAT( parseIntoConfigAndReturnError( argv, config ), Contains( "-x" ) );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
SECTION( "nothrow", "" ) {
|
||||
SECTION( "-e", "" ) {
|
||||
const char* argv[] = { "test", "-e" };
|
||||
@@ -217,7 +217,7 @@ TEST_CASE( "Long strings can be wrapped", "[wrap]" ) {
|
||||
SECTION( "plain string", "" ) {
|
||||
// guide: 123456789012345678
|
||||
std::string testString = "one two three four";
|
||||
|
||||
|
||||
SECTION( "No wrapping", "" ) {
|
||||
CHECK( Text( testString, TextAttributes().setWidth( 80 ) ).toString() == testString );
|
||||
CHECK( Text( testString, TextAttributes().setWidth( 18 ) ).toString() == testString );
|
||||
@@ -261,14 +261,14 @@ TEST_CASE( "Long strings can be wrapped", "[wrap]" ) {
|
||||
.setInitialIndent( 1 ) );
|
||||
CHECK( text.toString() == " one two\n three\n four" );
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
SECTION( "With newlines", "" ) {
|
||||
|
||||
|
||||
// guide: 1234567890123456789
|
||||
std::string testString = "one two\nthree four";
|
||||
|
||||
|
||||
SECTION( "No wrapping" , "" ) {
|
||||
CHECK( Text( testString, TextAttributes().setWidth( 80 ) ).toString() == testString );
|
||||
CHECK( Text( testString, TextAttributes().setWidth( 18 ) ).toString() == testString );
|
||||
@@ -288,17 +288,17 @@ TEST_CASE( "Long strings can be wrapped", "[wrap]" ) {
|
||||
CHECK( Text( testString, TextAttributes().setWidth( 6 ) ).toString() == "one\ntwo\nthree\nfour" );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
SECTION( "With tabs", "" ) {
|
||||
|
||||
// guide: 1234567890123456789
|
||||
std::string testString = "one two \tthree four five six";
|
||||
|
||||
|
||||
CHECK( Text( testString, TextAttributes().setWidth( 15 ) ).toString()
|
||||
== "one two three\n four\n five\n six" );
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
using namespace Catch;
|
||||
@@ -324,7 +324,7 @@ public:
|
||||
ColourString( std::string const& _string, std::vector<ColourIndex> const& _colours )
|
||||
: string( _string ), colours( _colours )
|
||||
{}
|
||||
|
||||
|
||||
ColourString& addColour( Colour::Code colour, int _index ) {
|
||||
colours.push_back( ColourIndex( colour,
|
||||
resolveRelativeIndex( _index ),
|
||||
@@ -337,7 +337,7 @@ public:
|
||||
resolveLastRelativeIndex( _toIndex ) ) );
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
void writeToStream( std::ostream& _stream ) const {
|
||||
std::size_t last = 0;
|
||||
for( std::size_t i = 0; i < colours.size(); ++i ) {
|
||||
@@ -351,7 +351,7 @@ public:
|
||||
last = index.toIndex;
|
||||
}
|
||||
if( last < string.size() )
|
||||
_stream << string.substr( last );
|
||||
_stream << string.substr( last );
|
||||
}
|
||||
friend std::ostream& operator << ( std::ostream& _stream, ColourString const& _colourString ) {
|
||||
_colourString.writeToStream( _stream );
|
||||
@@ -408,7 +408,7 @@ TEST_CASE( "replaceInPlace", "" ) {
|
||||
|
||||
// !TBD: This will be folded into Text class
|
||||
TEST_CASE( "Strings can be rendered with colour", "[.colour]" ) {
|
||||
|
||||
|
||||
{
|
||||
ColourString cs( "hello" );
|
||||
cs .addColour( Colour::Red, 0 )
|
||||
@@ -420,19 +420,19 @@ TEST_CASE( "Strings can be rendered with colour", "[.colour]" ) {
|
||||
{
|
||||
ColourString cs( "hello" );
|
||||
cs .addColour( Colour::Blue, 1, -2 );
|
||||
|
||||
|
||||
Catch::cout() << cs << std::endl;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
TEST_CASE( "Text can be formatted using the Text class", "" ) {
|
||||
|
||||
|
||||
CHECK( Text( "hi there" ).toString() == "hi there" );
|
||||
|
||||
|
||||
TextAttributes narrow;
|
||||
narrow.setWidth( 6 );
|
||||
|
||||
|
||||
CHECK( Text( "hi there", narrow ).toString() == "hi\nthere" );
|
||||
}
|
||||
|
||||
@@ -445,5 +445,5 @@ TEST_CASE( "Long text is truncted", "[Text][Truncated]" ) {
|
||||
oss << longLine << longLine << "\n";
|
||||
Text t( oss.str() );
|
||||
CHECK_THAT( t.toString(), EndsWith( "... message truncated due to excessive size" ) );
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -25,7 +25,7 @@ namespace Catch
|
||||
std::ostringstream oss;
|
||||
oss << "std::pair( " << value.first << ", " << value.second << " )";
|
||||
return oss.str();
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@@ -38,7 +38,7 @@ TEST_CASE
|
||||
{
|
||||
std::pair<int, int> aNicePair( 1, 2 );
|
||||
|
||||
REQUIRE( (std::pair<int, int>( 1, 2 )) == aNicePair );
|
||||
REQUIRE( (std::pair<int, int>( 1, 2 )) == aNicePair );
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
@@ -62,7 +62,7 @@ TEST_CASE
|
||||
/*
|
||||
int a = 1;
|
||||
int b = 2;
|
||||
|
||||
|
||||
// This only captures part of the expression, but issues a warning about the rest
|
||||
REQUIRE( a+1 == b-1 );
|
||||
*/
|
||||
@@ -85,38 +85,38 @@ TEST_CASE
|
||||
"[Tricky][failing][.]"
|
||||
)
|
||||
{
|
||||
|
||||
|
||||
Opaque o1, o2;
|
||||
o1.val = 7;
|
||||
o2.val = 8;
|
||||
|
||||
|
||||
CHECK( &o1 == &o2 );
|
||||
CHECK( o1 == o2 );
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
TEST_CASE
|
||||
(
|
||||
(
|
||||
"string literals of different sizes can be compared",
|
||||
"[Tricky][failing][.]"
|
||||
)
|
||||
{
|
||||
REQUIRE( std::string( "first" ) == "second" );
|
||||
|
||||
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
TEST_CASE
|
||||
(
|
||||
(
|
||||
"An expression with side-effects should only be evaluated once",
|
||||
"[Tricky]"
|
||||
)
|
||||
{
|
||||
int i = 7;
|
||||
|
||||
|
||||
REQUIRE( i++ == 7 );
|
||||
REQUIRE( i++ == 8 );
|
||||
|
||||
|
||||
}
|
||||
|
||||
namespace A {
|
||||
@@ -167,8 +167,8 @@ TEST_CASE
|
||||
*/
|
||||
|
||||
namespace ObjectWithConversions
|
||||
{
|
||||
struct Object
|
||||
{
|
||||
struct Object
|
||||
{
|
||||
operator unsigned int() {return 0xc0000000;}
|
||||
};
|
||||
@@ -179,31 +179,31 @@ namespace ObjectWithConversions
|
||||
"Operators at different namespace levels not hijacked by Koenig lookup",
|
||||
"[Tricky]"
|
||||
)
|
||||
{
|
||||
{
|
||||
Object o;
|
||||
REQUIRE(0xc0000000 == o );
|
||||
}
|
||||
}
|
||||
|
||||
namespace ObjectWithNonConstEqualityOperator
|
||||
namespace ObjectWithNonConstEqualityOperator
|
||||
{
|
||||
struct Test
|
||||
{
|
||||
Test( unsigned int v )
|
||||
: m_value(v)
|
||||
: m_value(v)
|
||||
{}
|
||||
|
||||
|
||||
bool operator==( const Test&rhs )
|
||||
{
|
||||
{
|
||||
return (m_value == rhs.m_value);
|
||||
}
|
||||
bool operator==( const Test&rhs ) const
|
||||
{
|
||||
{
|
||||
return (m_value != rhs.m_value);
|
||||
}
|
||||
unsigned int m_value;
|
||||
};
|
||||
|
||||
|
||||
TEST_CASE("Demonstrate that a non-const == is not used", "[Tricky]" )
|
||||
{
|
||||
Test t( 1 );
|
||||
@@ -226,7 +226,7 @@ namespace EnumBitFieldTests
|
||||
struct Obj
|
||||
{
|
||||
Obj():prop(&p){}
|
||||
|
||||
|
||||
int p;
|
||||
int* prop;
|
||||
};
|
||||
@@ -284,11 +284,11 @@ TEST_CASE( "(unimplemented) static bools can be evaluated", "[Tricky]" )
|
||||
/*
|
||||
TEST_CASE( "Tests with the same name are not allowed", "[Tricky]" )
|
||||
{
|
||||
|
||||
|
||||
}
|
||||
TEST_CASE( "Tests with the same name are not allowed", "[Tricky]" )
|
||||
{
|
||||
|
||||
|
||||
}
|
||||
*/
|
||||
|
||||
@@ -317,13 +317,13 @@ TEST_CASE( "Assertions then sections", "[Tricky]" )
|
||||
{
|
||||
// This was causing a failure due to the way the console reporter was handling
|
||||
// the current section
|
||||
|
||||
|
||||
REQUIRE( Catch::alwaysTrue() );
|
||||
|
||||
|
||||
SECTION( "A section", "" )
|
||||
{
|
||||
REQUIRE( Catch::alwaysTrue() );
|
||||
|
||||
|
||||
SECTION( "Another section", "" )
|
||||
{
|
||||
REQUIRE( Catch::alwaysTrue() );
|
||||
|
||||
Reference in New Issue
Block a user