3rd-party/catch2
1
0
Fork 0
mirror of https://github.com/catchorg/Catch2.git synced 2025-08-01 12:55:40 +02:00
Code Issues Packages Projects Releases Wiki Activity

Stripped trailing whitespace from all source code lines

Browse Source 
(replaces need for PRs #310 and #504)
This commit is contained in:
Phil Nash
2015-11-04 18:01:28 +00:00
parent 8c32b49d5f
commit e91738103c
47 changed files with 398 additions and 398 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
projects/SelfTest/ApproxTests.cpp
View File

@@ -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 );

14
projects/SelfTest/BDDTests.cpp
View File

@@ -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") {

18
projects/SelfTest/ClassTests.cpp
View File

@@ -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 );
}
}

52
projects/SelfTest/ConditionTests.cpp
View File

@@ -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 );
}

4
projects/SelfTest/ExceptionTests.cpp
View File

@@ -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;
};

12
projects/SelfTest/GeneratorTests.cpp
View File

@@ -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 );
}

4
projects/SelfTest/MessageTests.cpp
View File

@@ -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;

44
projects/SelfTest/MiscTests.cpp
View File

@@ -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

106
projects/SelfTest/PartTrackerTests.cpp
View File

@@ -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() );
}

62
projects/SelfTest/TestMain.cpp
View File

@@ -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" ) );
}

50
projects/SelfTest/TrickyTests.cpp
View File

@@ -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() );

26
projects/runners/iTchRunner/internal/iTchRunnerAppDelegate.h
View File

@@ -13,7 +13,7 @@
@interface iTchRunnerAppDelegate : NSObject <UIApplicationDelegate>
@interface iTchRunnerAppDelegate : NSObject <UIApplicationDelegate>
{
UIWindow *window;
}
@@ -25,15 +25,15 @@
///////////////////////////////////////////////////////////////////////////////
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
[window setUserInteractionEnabled:YES];
[window setMultipleTouchEnabled:YES];
CGRect screenRect = [[UIScreen mainScreen] applicationFrame];
iTchRunnerMainView* view = [[iTchRunnerMainView alloc] initWithFrame:screenRect];
[window addSubview:view];
[window makeKeyAndVisible];
arcSafeRelease( view );
@@ -42,7 +42,7 @@
}
///////////////////////////////////////////////////////////////////////////////
- (void)dealloc
- (void)dealloc
{
#if !CATCH_ARC_ENABLED
[window release];
@@ -52,7 +52,7 @@
///////////////////////////////////////////////////////////////////////////////
- (void)applicationWillResignActive:(UIApplication *)application
- (void)applicationWillResignActive:(UIApplication *)application
{
/*
Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
@@ -62,17 +62,17 @@
///////////////////////////////////////////////////////////////////////////////
- (void)applicationDidEnterBackground:(UIApplication *)application
- (void)applicationDidEnterBackground:(UIApplication *)application
{
/*
Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
If your application supports background execution, called instead of applicationWillTerminate: when the user quits.
*/
}
///////////////////////////////////////////////////////////////////////////////
- (void)applicationWillEnterForeground:(UIApplication *)application
- (void)applicationWillEnterForeground:(UIApplication *)application
{
/*
Called as part of transition from the background to the inactive state: here you can undo many of the changes made on entering the background.
@@ -81,7 +81,7 @@
///////////////////////////////////////////////////////////////////////////////
- (void)applicationDidBecomeActive:(UIApplication *)application
- (void)applicationDidBecomeActive:(UIApplication *)application
{
/*
Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
@@ -90,7 +90,7 @@
///////////////////////////////////////////////////////////////////////////////
- (void)applicationWillTerminate:(UIApplication *)application
- (void)applicationWillTerminate:(UIApplication *)application
{
/*
Called when the application is about to terminate.
@@ -100,7 +100,7 @@
///////////////////////////////////////////////////////////////////////////////
- (void)applicationDidReceiveMemoryWarning:(UIApplication *)application
- (void)applicationDidReceiveMemoryWarning:(UIApplication *)application
{
/*
Free up as much memory as possible by purging cached data objects that can be recreated (or reloaded from disk) later.

10
projects/runners/iTchRunner/internal/iTchRunnerMainView.h
View File

@@ -33,7 +33,7 @@
///////////////////////////////////////////////////////////////////////////////
-(id) initWithFrame:(CGRect)frame
{
if ((self = [super initWithFrame:frame]))
if ((self = [super initWithFrame:frame]))
{
// Initialization code
self.backgroundColor = [UIColor blackColor];
@@ -64,7 +64,7 @@
///////////////////////////////////////////////////////////////////////////////
-(void) showAlert
{
{
UIActionSheet* menu = [[UIActionSheet alloc] initWithTitle:@"Options"
delegate:self
cancelButtonTitle:nil
@@ -72,7 +72,7 @@
otherButtonTitles:@"Run all tests", nil];
[menu showInView: self];
arcSafeRelease( menu );
}
// This is a copy & paste from Catch::Runner2 to get us bootstrapped (this is due to all be
@@ -144,7 +144,7 @@ inline Catch::Totals runTestsForGroup( Catch::RunContext& context, const Catch::
{
const Catch::AssertionResult& resultInfo = *pResultInfo;
std::ostringstream oss;
if( resultInfo.hasExpression() )
{
oss << resultInfo.getExpression();
@@ -174,7 +174,7 @@ inline Catch::Totals runTestsForGroup( Catch::RunContext& context, const Catch::
default:
break;
}
if( resultInfo.hasExpression() )
{
oss << " for: " << resultInfo.getExpandedExpression();

22
projects/runners/iTchRunner/internal/iTchRunnerReporter.h
View File

@@ -13,7 +13,7 @@
@protocol iTchRunnerDelegate
-(void) testWasRun: (const Catch::AssertionResult*) result;
-(void) testWasRun: (const Catch::AssertionResult*) result;
@end
@@ -38,14 +38,14 @@ namespace Catch
{
return true;
}
///////////////////////////////////////////////////////////////////////////
static std::string getDescription
()
{
return "Captures results for iOS runner";
}
///////////////////////////////////////////////////////////////////////////
size_t getSucceeded
()
@@ -53,7 +53,7 @@ namespace Catch
{
return m_totals.assertions.passed;
}
///////////////////////////////////////////////////////////////////////////
size_t getFailed
()
@@ -61,20 +61,20 @@ namespace Catch
{
return m_totals.assertions.failed;
}
///////////////////////////////////////////////////////////////////////////
void reset()
{
m_totals = Totals();
}
private: // IReporter
///////////////////////////////////////////////////////////////////////////
virtual void StartTesting
()
{}
///////////////////////////////////////////////////////////////////////////
virtual void EndTesting
(
@@ -83,7 +83,7 @@ namespace Catch
{
m_totals = totals;
}
///////////////////////////////////////////////////////////////////////////
virtual void Result
(
@@ -92,7 +92,7 @@ namespace Catch
{
[m_delegate testWasRun: &result];
}
///////////////////////////////////////////////////////////////////////////
// Deliberately unimplemented:
virtual void StartGroup( const std::string& ){}
@@ -107,7 +107,7 @@ namespace Catch
private:
Totals m_totals;
id<iTchRunnerDelegate> m_delegate;
};
}