3rd-party
/
catch2
mirror of https://github.com/catchorg/Catch2.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Make merge easier

This commit is contained in:
Malcolm Noyes 2013-12-09 15:14:47 +00:00
parent 2a14dffe97
commit 37b057187d
8 changed files with 827 additions and 1036 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
projects/SelfTest/ClassTests.cpp
View File

@ -8,32 +8,28 @@
#include "catch.hpp" #include "catch.hpp"
namespace ClassTests class TestClass
{ {
class TestClass std::string s;
public:
TestClass()
: s( "hello" )
{}
void succeedingCase()
{ {
std::string s; REQUIRE( s == "hello" );
}
void failingCase()
{
REQUIRE( s == "world" );
}
};
public: // Note: TestClass conflicts with template class with same name in VS2012 native tests
TestClass() METHOD_AS_TEST_CASE( TestClass::succeedingCase, "./succeeding/TestClass/succeedingCase", "A method based test run that succeeds [class]" )
: s( "hello" ) METHOD_AS_TEST_CASE( TestClass::failingCase, "./failing/TestClass/failingCase", "A method based test run that fails [class]" )
{}
void succeedingCase()
{
REQUIRE( s == "hello" );
}
void failingCase()
{
REQUIRE( s == "world" );
}
};
// Note: TestClass conflicts with template class with same name in VS2012 native tests
METHOD_AS_TEST_CASE( ClassTests::TestClass::succeedingCase, "./succeeding/TestClass/succeedingCase", "A method based test run that succeeds [class]" )
METHOD_AS_TEST_CASE( ClassTests::TestClass::failingCase, "./failing/TestClass/failingCase", "A method based test run that fails [class]" )
}
struct Fixture struct Fixture
{ {

479
projects/SelfTest/ConditionTests.cpp
View File

@ -42,167 +42,165 @@ struct TestDef {
// The "failing" tests all use the CHECK macro, which continues if the specific test fails. // The "failing" tests all use the CHECK macro, which continues if the specific test fails.
// This allows us to see all results, even if an earlier check fails // This allows us to see all results, even if an earlier check fails
namespace ConditionTests { // Equality tests
TEST_CASE( "./succeeding/conditions/equality",
"Equality checks that should succeed" )
{
// Equality tests TestDef td;
TEST_CASE( "./succeeding/conditions/equality", td + "hello" + "hello";
"Equality checks that should succeed" )
{
TestDef td; TestData data;
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( data.str_hello.size() == 5 );
REQUIRE( data.int_seven == 7 ); double x = 1.1 + 0.1 + 0.1;
REQUIRE( data.float_nine_point_one == Approx( 9.1f ) ); REQUIRE( x == Approx( 1.3 ) );
REQUIRE( data.double_pi == Approx( 3.1415926535 ) ); }
REQUIRE( data.str_hello == "hello" );
REQUIRE( "hello" == data.str_hello );
REQUIRE( data.str_hello.size() == 5 );
double x = 1.1 + 0.1 + 0.1; TEST_CASE( "./failing/conditions/equality",
REQUIRE( x == Approx( 1.3 ) ); "Equality checks that should fail" )
} {
TestData data;
TEST_CASE( "./failing/conditions/equality", CHECK( data.int_seven == 6 );
"Equality checks that should fail" ) CHECK( data.int_seven == 8 );
{ CHECK( data.int_seven == 0 );
TestData data; CHECK( data.float_nine_point_one == Approx( 9.11f ) );
CHECK( data.float_nine_point_one == Approx( 9.0f ) );
CHECK( data.float_nine_point_one == Approx( 1 ) );
CHECK( data.float_nine_point_one == Approx( 0 ) );
CHECK( data.double_pi == Approx( 3.1415 ) );
CHECK( data.str_hello == "goodbye" );
CHECK( data.str_hello == "hell" );
CHECK( data.str_hello == "hello1" );
CHECK( data.str_hello.size() == 6 );
CHECK( data.int_seven == 6 ); double x = 1.1 + 0.1 + 0.1;
CHECK( data.int_seven == 8 ); CHECK( x == Approx( 1.301 ) );
CHECK( data.int_seven == 0 ); }
CHECK( data.float_nine_point_one == Approx( 9.11f ) );
CHECK( data.float_nine_point_one == Approx( 9.0f ) );
CHECK( data.float_nine_point_one == Approx( 1 ) );
CHECK( data.float_nine_point_one == Approx( 0 ) );
CHECK( data.double_pi == Approx( 3.1415 ) );
CHECK( data.str_hello == "goodbye" );
CHECK( data.str_hello == "hell" );
CHECK( data.str_hello == "hello1" );
CHECK( data.str_hello.size() == 6 );
double x = 1.1 + 0.1 + 0.1; TEST_CASE( "./succeeding/conditions/inequality",
CHECK( x == Approx( 1.301 ) ); "Inequality checks that should succeed" )
} {
TestData data;
TEST_CASE( "./succeeding/conditions/inequality", REQUIRE( data.int_seven != 6 );
"Inequality checks that should succeed" ) REQUIRE( data.int_seven != 8 );
{ REQUIRE( data.float_nine_point_one != Approx( 9.11f ) );
TestData data; REQUIRE( data.float_nine_point_one != Approx( 9.0f ) );
REQUIRE( data.float_nine_point_one != Approx( 1 ) );
REQUIRE( data.float_nine_point_one != Approx( 0 ) );
REQUIRE( data.double_pi != Approx( 3.1415 ) );
REQUIRE( data.str_hello != "goodbye" );
REQUIRE( data.str_hello != "hell" );
REQUIRE( data.str_hello != "hello1" );
REQUIRE( data.str_hello.size() != 6 );
}
REQUIRE( data.int_seven != 6 ); TEST_CASE( "./failing/conditions/inequality",
REQUIRE( data.int_seven != 8 ); "Inequality checks that should fails" )
REQUIRE( data.float_nine_point_one != Approx( 9.11f ) ); {
REQUIRE( data.float_nine_point_one != Approx( 9.0f ) ); TestData data;
REQUIRE( data.float_nine_point_one != Approx( 1 ) );
REQUIRE( data.float_nine_point_one != Approx( 0 ) );
REQUIRE( data.double_pi != Approx( 3.1415 ) );
REQUIRE( data.str_hello != "goodbye" );
REQUIRE( data.str_hello != "hell" );
REQUIRE( data.str_hello != "hello1" );
REQUIRE( data.str_hello.size() != 6 );
}
TEST_CASE( "./failing/conditions/inequality", CHECK( data.int_seven != 7 );
"Inequality checks that should fails" ) CHECK( data.float_nine_point_one != Approx( 9.1f ) );
{ CHECK( data.double_pi != Approx( 3.1415926535 ) );
TestData data; CHECK( data.str_hello != "hello" );
CHECK( data.str_hello.size() != 5 );
}
CHECK( data.int_seven != 7 ); // Ordering comparison tests
CHECK( data.float_nine_point_one != Approx( 9.1f ) ); TEST_CASE( "./succeeding/conditions/ordered",
CHECK( data.double_pi != Approx( 3.1415926535 ) ); "Ordering comparison checks that should succeed" )
CHECK( data.str_hello != "hello" ); {
CHECK( data.str_hello.size() != 5 ); TestData data;
}
// Ordering comparison tests REQUIRE( data.int_seven < 8 );
TEST_CASE( "./succeeding/conditions/ordered", REQUIRE( data.int_seven > 6 );
"Ordering comparison checks that should succeed" ) REQUIRE( data.int_seven > 0 );
{ REQUIRE( data.int_seven > -1 );
TestData data;
REQUIRE( data.int_seven < 8 ); REQUIRE( data.int_seven >= 7 );
REQUIRE( data.int_seven > 6 ); REQUIRE( data.int_seven >= 6 );
REQUIRE( data.int_seven > 0 ); REQUIRE( data.int_seven <= 7 );
REQUIRE( data.int_seven > -1 ); REQUIRE( data.int_seven <= 8 );
REQUIRE( data.int_seven >= 7 ); REQUIRE( data.float_nine_point_one > 9 );
REQUIRE( data.int_seven >= 6 ); REQUIRE( data.float_nine_point_one < 10 );
REQUIRE( data.int_seven <= 7 ); REQUIRE( data.float_nine_point_one < 9.2 );
REQUIRE( data.int_seven <= 8 );
REQUIRE( data.float_nine_point_one > 9 ); REQUIRE( data.str_hello <= "hello" );
REQUIRE( data.float_nine_point_one < 10 ); REQUIRE( data.str_hello >= "hello" );
REQUIRE( data.float_nine_point_one < 9.2 );
REQUIRE( data.str_hello <= "hello" ); REQUIRE( data.str_hello < "hellp" );
REQUIRE( data.str_hello >= "hello" ); REQUIRE( data.str_hello < "zebra" );
REQUIRE( data.str_hello > "hellm" );
REQUIRE( data.str_hello > "a" );
}
REQUIRE( data.str_hello < "hellp" ); TEST_CASE( "./failing/conditions/ordered",
REQUIRE( data.str_hello < "zebra" ); "Ordering comparison checks that should fail" )
REQUIRE( data.str_hello > "hellm" ); {
REQUIRE( data.str_hello > "a" ); TestData data;
}
TEST_CASE( "./failing/conditions/ordered", CHECK( data.int_seven > 7 );
"Ordering comparison checks that should fail" ) CHECK( data.int_seven < 7 );
{ CHECK( data.int_seven > 8 );
TestData data; CHECK( data.int_seven < 6 );
CHECK( data.int_seven < 0 );
CHECK( data.int_seven < -1 );
CHECK( data.int_seven > 7 ); CHECK( data.int_seven >= 8 );
CHECK( data.int_seven < 7 ); CHECK( data.int_seven <= 6 );
CHECK( data.int_seven > 8 );
CHECK( data.int_seven < 6 );
CHECK( data.int_seven < 0 );
CHECK( data.int_seven < -1 );
CHECK( data.int_seven >= 8 ); CHECK( data.float_nine_point_one < 9 );
CHECK( data.int_seven <= 6 ); CHECK( data.float_nine_point_one > 10 );
CHECK( data.float_nine_point_one > 9.2 );
CHECK( data.float_nine_point_one < 9 ); CHECK( data.str_hello > "hello" );
CHECK( data.float_nine_point_one > 10 ); CHECK( data.str_hello < "hello" );
CHECK( data.float_nine_point_one > 9.2 ); CHECK( data.str_hello > "hellp" );
CHECK( data.str_hello > "z" );
CHECK( data.str_hello < "hellm" );
CHECK( data.str_hello < "a" );
CHECK( data.str_hello > "hello" ); CHECK( data.str_hello >= "z" );
CHECK( data.str_hello < "hello" ); CHECK( data.str_hello <= "a" );
CHECK( data.str_hello > "hellp" ); }
CHECK( data.str_hello > "z" );
CHECK( data.str_hello < "hellm" );
CHECK( data.str_hello < "a" );
CHECK( data.str_hello >= "z" ); // Comparisons with int literals
CHECK( data.str_hello <= "a" ); TEST_CASE( "./succeeding/conditions/int literals",
} "Comparisons with int literals don't warn when mixing signed/ unsigned" )
{
int i = 1;
unsigned int ui = 2;
long l = 3;
unsigned long ul = 4;
char c = 5;
unsigned char uc = 6;
// Comparisons with int literals REQUIRE( i == 1 );
TEST_CASE( "./succeeding/conditions/int literals", REQUIRE( ui == 2 );
"Comparisons with int literals don't warn when mixing signed/ unsigned" ) REQUIRE( l == 3 );
{ REQUIRE( ul == 4 );
int i = 1; REQUIRE( c == 5 );
unsigned int ui = 2; REQUIRE( uc == 6 );
long l = 3;
unsigned long ul = 4;
char c = 5;
unsigned char uc = 6;
REQUIRE( i == 1 ); REQUIRE( 1 == i );
REQUIRE( ui == 2 ); REQUIRE( 2 == ui );
REQUIRE( l == 3 ); REQUIRE( 3 == l );
REQUIRE( ul == 4 ); REQUIRE( 4 == ul );
REQUIRE( c == 5 ); REQUIRE( 5 == c );
REQUIRE( uc == 6 ); REQUIRE( 6 == uc );
REQUIRE( 1 == i ); REQUIRE( (std::numeric_limits<unsigned long>::max)() > ul );
REQUIRE( 2 == ui ); }
REQUIRE( 3 == l );
REQUIRE( 4 == ul );
REQUIRE( 5 == c );
REQUIRE( 6 == uc );
REQUIRE( (std::numeric_limits<unsigned long>::max)() > ul );
}
// Disable warnings about sign conversions for the next two tests // Disable warnings about sign conversions for the next two tests
// (as we are deliberately invoking them) // (as we are deliberately invoking them)
@ -216,63 +214,63 @@ namespace ConditionTests {
#pragma warning(disable:4389) // '==' : signed/unsigned mismatch #pragma warning(disable:4389) // '==' : signed/unsigned mismatch
#endif #endif
TEST_CASE( "./succeeding/conditions//long_to_unsigned_x", TEST_CASE( "./succeeding/conditions//long_to_unsigned_x",
"comparisons between int variables" ) "comparisons between int variables" )
{ {
long long_var = 1L; long long_var = 1L;
unsigned char unsigned_char_var = 1; unsigned char unsigned_char_var = 1;
unsigned short unsigned_short_var = 1; unsigned short unsigned_short_var = 1;
unsigned int unsigned_int_var = 1; unsigned int unsigned_int_var = 1;
unsigned long unsigned_long_var = 1L; unsigned long unsigned_long_var = 1L;
REQUIRE( long_var == unsigned_char_var ); REQUIRE( long_var == unsigned_char_var );
REQUIRE( long_var == unsigned_short_var ); REQUIRE( long_var == unsigned_short_var );
REQUIRE( long_var == unsigned_int_var ); REQUIRE( long_var == unsigned_int_var );
REQUIRE( long_var == unsigned_long_var ); REQUIRE( long_var == unsigned_long_var );
} }
TEST_CASE( "./succeeding/conditions/const ints to int literal", TEST_CASE( "./succeeding/conditions/const ints to int literal",
"comparisons between const int variables" ) "comparisons between const int variables" )
{ {
const unsigned char unsigned_char_var = 1; const unsigned char unsigned_char_var = 1;
const unsigned short unsigned_short_var = 1; const unsigned short unsigned_short_var = 1;
const unsigned int unsigned_int_var = 1; const unsigned int unsigned_int_var = 1;
const unsigned long unsigned_long_var = 1L; const unsigned long unsigned_long_var = 1L;
REQUIRE( unsigned_char_var == 1 ); REQUIRE( unsigned_char_var == 1 );
REQUIRE( unsigned_short_var == 1 ); REQUIRE( unsigned_short_var == 1 );
REQUIRE( unsigned_int_var == 1 ); REQUIRE( unsigned_int_var == 1 );
REQUIRE( unsigned_long_var == 1 ); REQUIRE( unsigned_long_var == 1 );
} }
TEST_CASE( "./succeeding/conditions/negative ints", TEST_CASE( "./succeeding/conditions/negative ints",
"Comparisons between unsigned ints and negative signed ints match c++ standard behaviour" ) "Comparisons between unsigned ints and negative signed ints match c++ standard behaviour" )
{ {
CHECK( ( -1 > 2u ) ); CHECK( ( -1 > 2u ) );
CHECK( -1 > 2u ); CHECK( -1 > 2u );
CHECK( ( 2u < -1 ) ); CHECK( ( 2u < -1 ) );
CHECK( 2u < -1 ); CHECK( 2u < -1 );
const int minInt = (std::numeric_limits<int>::min)(); const int minInt = (std::numeric_limits<int>::min)();
CHECK( ( minInt > 2u ) ); CHECK( ( minInt > 2u ) );
CHECK( minInt > 2u ); CHECK( minInt > 2u );
} }
template<typename T> template<typename T>
struct Ex struct Ex
{ {
Ex( T ){} Ex( T ){}
bool operator == ( const T& ) const { return true; } bool operator == ( const T& ) const { return true; }
T operator * ( const T& ) const { return T(); } T operator * ( const T& ) const { return T(); }
}; };
TEST_CASE( "./succeeding/conditions/computed ints", TEST_CASE( "./succeeding/conditions/computed ints",
"Comparisons between ints where one side is computed" ) "Comparisons between ints where one side is computed" )
{ {
CHECK( 54 == 6*9 ); CHECK( 54 == 6*9 );
} }
#ifdef __GNUC__ #ifdef __GNUC__
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
@ -281,70 +279,69 @@ namespace ConditionTests {
inline const char* returnsConstNull(){ return NULL; } inline const char* returnsConstNull(){ return NULL; }
inline char* returnsNull(){ return NULL; } inline char* returnsNull(){ return NULL; }
TEST_CASE( "./succeeding/conditions/ptr", TEST_CASE( "./succeeding/conditions/ptr",
"Pointers can be compared to null" ) "Pointers can be compared to null" )
{ {
TestData* p = NULL; TestData* p = NULL;
TestData* pNULL = NULL; TestData* pNULL = NULL;
REQUIRE( p == NULL ); REQUIRE( p == NULL );
REQUIRE( p == pNULL ); REQUIRE( p == pNULL );
TestData data; TestData data;
p = &data; p = &data;
REQUIRE( p != NULL ); REQUIRE( p != NULL );
const TestData* cp = p; const TestData* cp = p;
REQUIRE( cp != NULL ); REQUIRE( cp != NULL );
const TestData* const cpc = p; const TestData* const cpc = p;
REQUIRE( cpc != NULL ); REQUIRE( cpc != NULL );
REQUIRE( returnsNull() == NULL ); REQUIRE( returnsNull() == NULL );
REQUIRE( returnsConstNull() == NULL ); REQUIRE( returnsConstNull() == NULL );
REQUIRE( NULL != p ); REQUIRE( NULL != p );
} }
// Not (!) tests // Not (!) tests
// The problem with the ! operator is that it has right-to-left associativity. // The problem with the ! operator is that it has right-to-left associativity.
// This means we can't isolate it when we decompose. The simple REQUIRE( !false ) form, therefore, // This means we can't isolate it when we decompose. The simple REQUIRE( !false ) form, therefore,
// cannot have the operand value extracted. The test will work correctly, and the situation // cannot have the operand value extracted. The test will work correctly, and the situation
// is detected and a warning issued. // is detected and a warning issued.
// An alternative form of the macros (CHECK_FALSE and REQUIRE_FALSE) can be used instead to capture // An alternative form of the macros (CHECK_FALSE and REQUIRE_FALSE) can be used instead to capture
// the operand value. // the operand value.
TEST_CASE( "./succeeding/conditions/not", TEST_CASE( "./succeeding/conditions/not",
"'Not' checks that should succeed" ) "'Not' checks that should succeed" )
{ {
bool falseValue = false; bool falseValue = false;
REQUIRE( false == false ); REQUIRE( false == false );
REQUIRE( true == true ); REQUIRE( true == true );
REQUIRE( !false ); REQUIRE( !false );
REQUIRE_FALSE( false ); REQUIRE_FALSE( false );
REQUIRE( !falseValue ); REQUIRE( !falseValue );
REQUIRE_FALSE( falseValue ); REQUIRE_FALSE( falseValue );
REQUIRE( !(1 == 2) ); REQUIRE( !(1 == 2) );
REQUIRE_FALSE( 1 == 2 ); REQUIRE_FALSE( 1 == 2 );
} }
TEST_CASE( "./failing/conditions/not", TEST_CASE( "./failing/conditions/not",
"'Not' checks that should fail" ) "'Not' checks that should fail" )
{ {
bool trueValue = true; bool trueValue = true;
CHECK( false != false ); CHECK( false != false );
CHECK( true != true ); CHECK( true != true );
CHECK( !true ); CHECK( !true );
CHECK_FALSE( true ); CHECK_FALSE( true );
CHECK( !trueValue ); CHECK( !trueValue );
CHECK_FALSE( trueValue ); CHECK_FALSE( trueValue );
CHECK( !(1 == 1) ); CHECK( !(1 == 1) );
CHECK_FALSE( 1 == 1 ); CHECK_FALSE( 1 == 1 );
}
} }

220
projects/SelfTest/ExceptionTests.cpp
View File

@ -28,120 +28,116 @@ namespace
} }
} }
namespace ExceptionTests TEST_CASE( "./succeeding/exceptions/explicit", "When checked exceptions are thrown they can be expected or unexpected" )
{ {
REQUIRE_THROWS_AS( thisThrows(), std::domain_error );
REQUIRE_NOTHROW( thisDoesntThrow() );
REQUIRE_THROWS( thisThrows() );
}
TEST_CASE( "./succeeding/exceptions/explicit", "When checked exceptions are thrown they can be expected or unexpected" ) TEST_CASE( "./failing/exceptions/explicit", "When checked exceptions are thrown they can be expected or unexpected" )
{
CHECK_THROWS_AS( thisThrows(), std::string );
CHECK_THROWS_AS( thisDoesntThrow(), std::domain_error );
CHECK_NOTHROW( thisThrows() );
}
TEST_CASE( "./failing/exceptions/implicit", "When unchecked exceptions are thrown they are always failures" )
{
if( Catch::isTrue( true ) )
throw std::domain_error( "unexpected exception" );
}
TEST_CASE( "./failing/exceptions/implicit/2", "An unchecked exception reports the line of the last assertion" )
{
CHECK( 1 == 1 );
if( Catch::isTrue( true ) )
throw std::domain_error( "unexpected exception" );
}
TEST_CASE( "./failing/exceptions/implicit/3", "When unchecked exceptions are thrown they are always failures" )
{
SECTION( "section name", "" )
{ {
REQUIRE_THROWS_AS( thisThrows(), std::domain_error ); if( Catch::isTrue( true ) )
REQUIRE_NOTHROW( thisDoesntThrow() ); throw std::domain_error( "unexpected exception" );
REQUIRE_THROWS( thisThrows() );
}
TEST_CASE( "./failing/exceptions/explicit", "When checked exceptions are thrown they can be expected or unexpected" )
{
CHECK_THROWS_AS( thisThrows(), std::string );
CHECK_THROWS_AS( thisDoesntThrow(), std::domain_error );
CHECK_NOTHROW( thisThrows() );
}
TEST_CASE( "./failing/exceptions/implicit", "When unchecked exceptions are thrown they are always failures" )
{
if( Catch::isTrue( true ) )
throw std::domain_error( "unexpected exception" );
}
TEST_CASE( "./failing/exceptions/implicit/2", "An unchecked exception reports the line of the last assertion" )
{
CHECK( 1 == 1 );
if( Catch::isTrue( true ) )
throw std::domain_error( "unexpected exception" );
}
TEST_CASE( "./failing/exceptions/implicit/3", "When unchecked exceptions are thrown they are always failures" )
{
SECTION( "section name", "" )
{
if( Catch::isTrue( true ) )
throw std::domain_error( "unexpected exception" );
}
}
TEST_CASE( "./failing/exceptions/implicit/4", "When unchecked exceptions are thrown they are always failures" )
{
CHECK( thisThrows() == 0 );
}
TEST_CASE( "./succeeding/exceptions/implicit", "When unchecked exceptions are thrown, but caught, they do not affect the test" )
{
try
{
throw std::domain_error( "unexpected exception" );
}
catch(...)
{
}
}
class CustomException
{
public:
CustomException( const std::string& msg )
: m_msg( msg )
{}
std::string getMessage() const
{
return m_msg;
}
private:
std::string m_msg;
};
CATCH_TRANSLATE_EXCEPTION( CustomException& ex )
{
return ex.getMessage();
}
CATCH_TRANSLATE_EXCEPTION( double& ex )
{
return Catch::toString( ex );
}
TEST_CASE( "./failing/exceptions/custom", "Unexpected custom exceptions can be translated" )
{
if( Catch::isTrue( true ) )
throw CustomException( "custom exception" );
}
inline void throwCustom() {
if( Catch::isTrue( true ) )
throw CustomException( "custom exception - not std" );
}
TEST_CASE( "./failing/exceptions/custom/nothrow", "Custom exceptions can be translated when testing for nothrow" )
{
REQUIRE_NOTHROW( throwCustom() );
}
TEST_CASE( "./failing/exceptions/custom/throw", "Custom exceptions can be translated when testing for throwing as something else" )
{
REQUIRE_THROWS_AS( throwCustom(), std::exception );
}
TEST_CASE( "./failing/exceptions/custom/double", "Unexpected custom exceptions can be translated" )
{
if( Catch::isTrue( true ) )
throw double( 3.14 );
}
inline int thisFunctionNotImplemented( int ) {
CATCH_NOT_IMPLEMENTED;
}
TEST_CASE( "./succeeding/exceptions/notimplemented", "" )
{
REQUIRE_THROWS( thisFunctionNotImplemented( 7 ) );
} }
} }
TEST_CASE( "./failing/exceptions/implicit/4", "When unchecked exceptions are thrown they are always failures" )
{
CHECK( thisThrows() == 0 );
}
TEST_CASE( "./succeeding/exceptions/implicit", "When unchecked exceptions are thrown, but caught, they do not affect the test" )
{
try
{
throw std::domain_error( "unexpected exception" );
}
catch(...)
{
}
}
class CustomException
{
public:
CustomException( const std::string& msg )
: m_msg( msg )
{}
std::string getMessage() const
{
return m_msg;
}
private:
std::string m_msg;
};
CATCH_TRANSLATE_EXCEPTION( CustomException& ex )
{
return ex.getMessage();
}
CATCH_TRANSLATE_EXCEPTION( double& ex )
{
return Catch::toString( ex );
}
TEST_CASE( "./failing/exceptions/custom", "Unexpected custom exceptions can be translated" )
{
if( Catch::isTrue( true ) )
throw CustomException( "custom exception" );
}
inline void throwCustom() {
if( Catch::isTrue( true ) )
throw CustomException( "custom exception - not std" );
}
TEST_CASE( "./failing/exceptions/custom/nothrow", "Custom exceptions can be translated when testing for nothrow" )
{
REQUIRE_NOTHROW( throwCustom() );
}
TEST_CASE( "./failing/exceptions/custom/throw", "Custom exceptions can be translated when testing for throwing as something else" )
{
REQUIRE_THROWS_AS( throwCustom(), std::exception );
}
TEST_CASE( "./failing/exceptions/custom/double", "Unexpected custom exceptions can be translated" )
{
if( Catch::isTrue( true ) )
throw double( 3.14 );
}
inline int thisFunctionNotImplemented( int ) {
CATCH_NOT_IMPLEMENTED;
}
TEST_CASE( "./succeeding/exceptions/notimplemented", "" )
{
REQUIRE_THROWS( thisFunctionNotImplemented( 7 ) );
}

158
projects/SelfTest/MessageTests.cpp
View File

@ -8,99 +8,95 @@
#include "catch.hpp" #include "catch.hpp"
namespace MessageTests TEST_CASE( "./succeeding/message", "INFO and WARN do not abort tests" )
{ {
INFO( "this is a " << "message" ); // This should output the message if a failure occurs
WARN( "this is a " << "warning" ); // This should always output the message but then continue
}
TEST_CASE( "./succeeding/succeed", "SUCCEED counts as a test pass" )
{
SUCCEED( "this is a " << "success" );
}
TEST_CASE( "./succeeding/message", "INFO and WARN do not abort tests" ) TEST_CASE( "./failing/message/info/1", "INFO gets logged on failure" )
{
INFO( "this message should be logged" );
INFO( "so should this" );
int a = 2;
REQUIRE( a == 1 );
}
TEST_CASE( "./mixed/message/info/2", "INFO gets logged on failure" )
{
INFO( "this message may be logged later" );
int a = 2;
CHECK( a == 2 );
INFO( "this message should be logged" );
CHECK( a == 1 );
INFO( "and this, but later" );
CHECK( a == 0 );
INFO( "but not this" );
CHECK( a == 2 );
}
TEST_CASE( "./failing/message/fail", "FAIL aborts the test" )
{
if( Catch::isTrue( true ) )
FAIL( "This is a " << "failure" ); // This should output the message and abort
}
TEST_CASE( "./failing/message/sections", "Output from all sections is reported" )
{
SECTION( "one", "" )
{ {
INFO( "this is a " << "message" ); // This should output the message if a failure occurs FAIL( "Message from section one" );
WARN( "this is a " << "warning" ); // This should always output the message but then continue
}
TEST_CASE( "./succeeding/succeed", "SUCCEED counts as a test pass" )
{
SUCCEED( "this is a " << "success" );
} }
TEST_CASE( "./failing/message/info/1", "INFO gets logged on failure" ) SECTION( "two", "" )
{ {
INFO( "this message should be logged" ); FAIL( "Message from section two" );
INFO( "so should this" ); }
int a = 2; }
REQUIRE( a == 1 );
TEST_CASE( "./succeeding/message/sections/stdout", "Output from all sections is reported" )
{
SECTION( "one", "" )
{
std::cout << "Message from section one" << std::endl;
} }
TEST_CASE( "./mixed/message/info/2", "INFO gets logged on failure" ) SECTION( "two", "" )
{ {
INFO( "this message may be logged later" ); std::cout << "Message from section two" << std::endl;
int a = 2;
CHECK( a == 2 );
INFO( "this message should be logged" );
CHECK( a == 1 );
INFO( "and this, but later" );
CHECK( a == 0 );
INFO( "but not this" );
CHECK( a == 2 );
} }
}
TEST_CASE( "./failing/message/fail", "FAIL aborts the test" ) TEST_CASE( "./mixed/message/scoped", "" )
{
for( int i=0; i<100; i++ )
{ {
if( Catch::isTrue( true ) ) SCOPED_INFO( "current counter " << i );
FAIL( "This is a " << "failure" ); // This should output the message and abort SCOPED_CAPTURE( i );
REQUIRE( i < 10 );
} }
}
TEST_CASE( "./failing/message/sections", "Output from all sections is reported" ) TEST_CASE( "./succeeding/nofail", "The NO_FAIL macro reports a failure but does not fail the test" )
{ {
SECTION( "one", "" ) CHECK_NOFAIL( 1 == 2 );
{ }
FAIL( "Message from section one" );
}
SECTION( "two", "" ) TEST_CASE( "just info", "[info][isolated info][.]" )
{ {
FAIL( "Message from section two" ); INFO( "this should never be seen" );
} }
} TEST_CASE( "just failure", "[fail][isolated info][.]" )
{
TEST_CASE( "./succeeding/message/sections/stdout", "Output from all sections is reported" ) FAIL( "Previous info should not be seen" );
{ }
SECTION( "one", "" )
{
std::cout << "Message from section one" << std::endl;
}
SECTION( "two", "" )
{
std::cout << "Message from section two" << std::endl;
}
}
TEST_CASE( "./mixed/message/scoped", "" )
{
for( int i=0; i<100; i++ )
{
SCOPED_INFO( "current counter " << i );
SCOPED_CAPTURE( i );
REQUIRE( i < 10 );
}
}
TEST_CASE( "./succeeding/nofail", "The NO_FAIL macro reports a failure but does not fail the test" )
{
CHECK_NOFAIL( 1 == 2 );
}
TEST_CASE( "just info", "[info][isolated info][.]" )
{
INFO( "this should never be seen" );
}
TEST_CASE( "just failure", "[fail][isolated info][.]" )
{
FAIL( "Previous info should not be seen" );
}
}

602
projects/SelfTest/MiscTests.cpp
View File

@ -11,360 +11,356 @@
#include <iostream> #include <iostream>
namespace MiscTests TEST_CASE( "./succeeding/Misc/Sections", "random SECTION tests" )
{ {
int a = 1;
int b = 2;
TEST_CASE( "./succeeding/Misc/Sections", "random SECTION tests" ) SECTION( "s1", "doesn't equal" )
{ {
int a = 1; REQUIRE( a != b );
int b = 2; REQUIRE( b != a );
}
SECTION( "s1", "doesn't equal" ) SECTION( "s2", "not equal" )
{ {
REQUIRE( a != b ); REQUIRE( a != b);
REQUIRE( b != a ); }
} }
TEST_CASE( "./succeeding/Misc/Sections/nested", "nested SECTION tests" )
{
int a = 1;
int b = 2;
SECTION( "s1", "doesn't equal" )
{
REQUIRE( a != b );
REQUIRE( b != a );
SECTION( "s2", "not equal" ) SECTION( "s2", "not equal" )
{ {
REQUIRE( a != b); REQUIRE( a != b);
} }
} }
}
TEST_CASE( "./succeeding/Misc/Sections/nested", "nested SECTION tests" ) TEST_CASE( "./mixed/Misc/Sections/nested2", "nested SECTION tests" )
{
int a = 1;
int b = 2;
SECTION( "s1", "doesn't equal" )
{ {
int a = 1; SECTION( "s2", "equal" )
int b = 2; {
REQUIRE( a == b );
}
SECTION( "s1", "doesn't equal" ) SECTION( "s3", "not equal" )
{ {
REQUIRE( a != b ); REQUIRE( a != b );
REQUIRE( b != a ); }
SECTION( "s4", "less than" )
SECTION( "s2", "not equal" ) {
{ REQUIRE( a < b );
REQUIRE( a != b);
}
} }
} }
}
TEST_CASE( "./mixed/Misc/Sections/nested2", "nested SECTION tests" ) TEST_CASE( "./Sections/nested/a/b", "nested SECTION tests" )
{
SECTION( "c", "" )
{ {
int a = 1; SECTION( "d (leaf)", "" )
int b = 2;
SECTION( "s1", "doesn't equal" )
{ {
SECTION( "s2", "equal" )
{
REQUIRE( a == b );
}
SECTION( "s3", "not equal" )
{
REQUIRE( a != b );
}
SECTION( "s4", "less than" )
{
REQUIRE( a < b );
}
}
}
TEST_CASE( "./Sections/nested/a/b", "nested SECTION tests" )
{
SECTION( "c", "" )
{
SECTION( "d (leaf)", "" )
{
}
SECTION( "e (leaf)", "" )
{
}
} }
SECTION( "f (leaf)", "" ) SECTION( "e (leaf)", "" )
{ {
} }
} }
TEST_CASE( "./mixed/Misc/Sections/loops", "looped SECTION tests" ) SECTION( "f (leaf)", "" )
{ {
int a = 1; }
}
for( int b = 0; b < 10; ++b ) TEST_CASE( "./mixed/Misc/Sections/loops", "looped SECTION tests" )
{
int a = 1;
for( int b = 0; b < 10; ++b )
{
std::ostringstream oss;
oss << "b is currently: " << b;
SECTION( "s1", oss.str() )
{ {
std::ostringstream oss; CHECK( b > a );
oss << "b is currently: " << b;
SECTION( "s1", oss.str() )
{
CHECK( b > a );
}
} }
} }
}
TEST_CASE( "./mixed/Misc/loops", "looped tests" ) TEST_CASE( "./mixed/Misc/loops", "looped tests" )
{
static const int fib[] = { 1, 1, 2, 3, 5, 8, 13, 21 };
for( size_t i=0; i < sizeof(fib)/sizeof(int); ++i )
{ {
static const int fib[] = { 1, 1, 2, 3, 5, 8, 13, 21 }; INFO( "Testing if fib[" << i << "] (" << fib[i] << ") is even" );
CHECK( ( fib[i] % 2 ) == 0 );
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 );
}
} }
}
TEST_CASE( "./succeeding/Misc/stdout,stderr", "Sends stuff to stdout and stderr" ) TEST_CASE( "./succeeding/Misc/stdout,stderr", "Sends stuff to stdout and stderr" )
{ {
std::cout << "Some information" << std::endl; std::cout << "Some information" << std::endl;
std::cerr << "An error" << std::endl; std::cerr << "An error" << std::endl;
} }
inline const char* makeString( bool makeNull ) inline const char* makeString( bool makeNull )
{ {
return makeNull ? NULL : "valid string"; return makeNull ? NULL : "valid string";
} }
TEST_CASE( "./succeeding/Misc/null strings", "" ) TEST_CASE( "./succeeding/Misc/null strings", "" )
{ {
REQUIRE( makeString( false ) != static_cast<char*>(NULL)); REQUIRE( makeString( false ) != static_cast<char*>(NULL));
REQUIRE( makeString( true ) == static_cast<char*>(NULL)); REQUIRE( makeString( true ) == static_cast<char*>(NULL));
} }
TEST_CASE( "./failing/info", "sends information to INFO" ) TEST_CASE( "./failing/info", "sends information to INFO" )
{ {
INFO( "hi" ); INFO( "hi" );
int i = 7; int i = 7;
CAPTURE( i ); CAPTURE( i );
REQUIRE( false ); REQUIRE( false );
} }
inline bool testCheckedIf( bool flag )
{
CHECKED_IF( flag )
return true;
else
return false;
}
TEST_CASE( "./succeeding/checkedif", "" )
{
REQUIRE( testCheckedIf( true ) );
}
TEST_CASE( "./failing/checkedif", "" )
{
REQUIRE( testCheckedIf( false ) );
}
inline bool testCheckedElse( bool flag )
{
CHECKED_ELSE( flag )
return false;
inline bool testCheckedIf( bool flag )
{
CHECKED_IF( flag )
return true; return true;
} else
return false;
}
TEST_CASE( "./succeeding/checkedelse", "" ) TEST_CASE( "./succeeding/checkedif", "" )
{ {
REQUIRE( testCheckedElse( true ) ); REQUIRE( testCheckedIf( true ) );
} }
TEST_CASE( "./failing/checkedelse", "" ) TEST_CASE( "./failing/checkedif", "" )
{ {
REQUIRE( testCheckedElse( false ) ); REQUIRE( testCheckedIf( false ) );
} }
TEST_CASE( "./misc/xmlentitycheck", "" ) inline bool testCheckedElse( bool flag )
{
CHECKED_ELSE( flag )
return false;
return true;
}
TEST_CASE( "./succeeding/checkedelse", "" )
{
REQUIRE( testCheckedElse( true ) );
}
TEST_CASE( "./failing/checkedelse", "" )
{
REQUIRE( testCheckedElse( false ) );
}
TEST_CASE( "./misc/xmlentitycheck", "" )
{
SECTION( "embedded xml", "<test>it should be possible to embed xml characters, such as <, \" or &, or even whole <xml>documents</xml> within an attribute</test>" )
{ {
SECTION( "embedded xml", "<test>it should be possible to embed xml characters, such as <, \" or &, or even whole <xml>documents</xml> within an attribute</test>" ) // No test
{ }
// No test SECTION( "encoded chars", "these should all be encoded: &&&\"\"\"<<<&\"<<&\"" )
} {
SECTION( "encoded chars", "these should all be encoded: &&&\"\"\"<<<&\"<<&\"" ) // No test
{ }
// No test }
TEST_CASE( "./manual/onechar", "send a single char to INFO" )
{
INFO(3);
REQUIRE(false);
}
TEST_CASE("./succeeding/atomic if", "")
{
size_t x = 0;
if( x )
REQUIRE(x > 0);
else
REQUIRE(x == 0);
}
inline const char* testStringForMatching()
{
return "this string contains 'abc' as a substring";
}
TEST_CASE("./succeeding/matchers", "")
{
REQUIRE_THAT( testStringForMatching(), Contains( "string" ) );
CHECK_THAT( testStringForMatching(), Contains( "abc" ) );
CHECK_THAT( testStringForMatching(), StartsWith( "this" ) );
CHECK_THAT( testStringForMatching(), EndsWith( "substring" ) );
}
TEST_CASE("./failing/matchers/Contains", "")
{
CHECK_THAT( testStringForMatching(), Contains( "not there" ) );
}
TEST_CASE("./failing/matchers/StartsWith", "")
{
CHECK_THAT( testStringForMatching(), StartsWith( "string" ) );
}
TEST_CASE("./failing/matchers/EndsWith", "")
{
CHECK_THAT( testStringForMatching(), EndsWith( "this" ) );
}
TEST_CASE("./failing/matchers/Equals", "")
{
CHECK_THAT( testStringForMatching(), Equals( "something else" ) );
}
TEST_CASE("string", "Equals with NULL")
{
REQUIRE_THAT("", Equals(NULL));
}
TEST_CASE("./succeeding/matchers/AllOf", "")
{
CHECK_THAT( testStringForMatching(), AllOf( Catch::Contains( "string" ), Catch::Contains( "abc" ) ) );
}
TEST_CASE("./succeeding/matchers/AnyOf", "")
{
CHECK_THAT( testStringForMatching(), AnyOf( Catch::Contains( "string" ), Catch::Contains( "not there" ) ) );
CHECK_THAT( testStringForMatching(), AnyOf( Catch::Contains( "not there" ), Catch::Contains( "string" ) ) );
}
TEST_CASE("./succeeding/matchers/Equals", "")
{
CHECK_THAT( testStringForMatching(), Equals( "this string contains 'abc' as a substring" ) );
}
inline unsigned int Factorial( unsigned int number )
{
// return number <= 1 ? number : Factorial(number-1)*number;
return number > 1 ? Factorial(number-1)*number : 1;
}
TEST_CASE( "Factorials are computed", "[factorial]" ) {
REQUIRE( Factorial(0) == 1 );
REQUIRE( Factorial(1) == 1 );
REQUIRE( Factorial(2) == 2 );
REQUIRE( Factorial(3) == 6 );
REQUIRE( Factorial(10) == 3628800 );
}
TEST_CASE( "empty", "An empty test with no assertions" )
{
}
TEST_CASE( "Nice descriptive name", "[tag1][tag2][tag3][.]" )
{
WARN( "This one ran" );
}
TEST_CASE( "first tag", "[tag1]" )
{
}
TEST_CASE( "second tag", "[tag2]" )
{
}
//
//TEST_CASE( "spawn a new process", "[.]" )
//{
// // !TBD Work in progress
// char line[200];
// FILE* output = popen("./CatchSelfTest ./failing/matchers/StartsWith", "r");
// while ( fgets(line, 199, output) )
// std::cout << line;
//}
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 );
TEST_CASE( "./manual/onechar", "send a single char to INFO" ) REQUIRE( v.size() == 5 );
{ REQUIRE( v.capacity() >= 10 );
INFO(3);
REQUIRE(false);
} }
SECTION( "reserving smaller does not change size or capacity", "" ) {
TEST_CASE("./succeeding/atomic if", "") v.reserve( 0 );
{
size_t x = 0;
if( x )
REQUIRE(x > 0);
else
REQUIRE(x == 0);
}
inline const char* testStringForMatching()
{
return "this string contains 'abc' as a substring";
}
TEST_CASE("./succeeding/matchers", "")
{
REQUIRE_THAT( testStringForMatching(), Contains( "string" ) );
CHECK_THAT( testStringForMatching(), Contains( "abc" ) );
CHECK_THAT( testStringForMatching(), StartsWith( "this" ) );
CHECK_THAT( testStringForMatching(), EndsWith( "substring" ) );
}
TEST_CASE("./failing/matchers/Contains", "")
{
CHECK_THAT( testStringForMatching(), Contains( "not there" ) );
}
TEST_CASE("./failing/matchers/StartsWith", "")
{
CHECK_THAT( testStringForMatching(), StartsWith( "string" ) );
}
TEST_CASE("./failing/matchers/EndsWith", "")
{
CHECK_THAT( testStringForMatching(), EndsWith( "this" ) );
}
TEST_CASE("./failing/matchers/Equals", "")
{
CHECK_THAT( testStringForMatching(), Equals( "something else" ) );
}
TEST_CASE("string", "Equals with NULL")
{
REQUIRE_THAT("", Equals(NULL));
}
TEST_CASE("./succeeding/matchers/AllOf", "")
{
CHECK_THAT( testStringForMatching(), AllOf( Catch::Contains( "string" ), Catch::Contains( "abc" ) ) );
}
TEST_CASE("./succeeding/matchers/AnyOf", "")
{
CHECK_THAT( testStringForMatching(), AnyOf( Catch::Contains( "string" ), Catch::Contains( "not there" ) ) );
CHECK_THAT( testStringForMatching(), AnyOf( Catch::Contains( "not there" ), Catch::Contains( "string" ) ) );
}
TEST_CASE("./succeeding/matchers/Equals", "")
{
CHECK_THAT( testStringForMatching(), Equals( "this string contains 'abc' as a substring" ) );
}
inline unsigned int Factorial( unsigned int number )
{
// return number <= 1 ? number : Factorial(number-1)*number;
return number > 1 ? Factorial(number-1)*number : 1;
}
TEST_CASE( "Factorials are computed", "[factorial]" ) {
REQUIRE( Factorial(0) == 1 );
REQUIRE( Factorial(1) == 1 );
REQUIRE( Factorial(2) == 2 );
REQUIRE( Factorial(3) == 6 );
REQUIRE( Factorial(10) == 3628800 );
}
TEST_CASE( "empty", "An empty test with no assertions" )
{
}
TEST_CASE( "Nice descriptive name", "[tag1][tag2][tag3][.]" )
{
WARN( "This one ran" );
}
TEST_CASE( "first tag", "[tag1]" )
{
}
TEST_CASE( "second tag", "[tag2]" )
{
}
//
//TEST_CASE( "spawn a new process", "[.]" )
//{
// // !TBD Work in progress
// char line[200];
// FILE* output = popen("./CatchSelfTest ./failing/matchers/StartsWith", "r");
// while ( fgets(line, 199, output) )
// std::cout << line;
//}
TEST_CASE( "vectors can be sized and resized", "[vector]" ) {
std::vector<int> v( 5 );
REQUIRE( v.size() == 5 ); REQUIRE( v.size() == 5 );
REQUIRE( v.capacity() >= 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 );
}
} }
// https://github.com/philsquared/Catch/issues/166
TEST_CASE("./failing/CatchSectionInfiniteLoop", "")
{
SECTION("Outer", "")
SECTION("Inner", "")
SUCCEED("that's not flying - that's failing in style");
FAIL("to infinity and beyond");
}
//#include "internal/catch_timer.h"
//
//TEST_CASE( "Timer", "[work-in-progress]" )
//{
// Catch::Timer t;
// t.start();
//
// std::cout << "starting..." << std::endl;
//
// double d = 0;
// for( int i = 0; i < 100000; ++i )
// for( int j = 0; j < 1000; ++j )
// d += (double)i*(double)j;
//
// double duration = t.getElapsedSeconds();
//
// std::cout << "finished in " << duration << std::endl;
//
// SUCCEED("yay");
//
//}
} }
// https://github.com/philsquared/Catch/issues/166
TEST_CASE("./failing/CatchSectionInfiniteLoop", "")
{
SECTION("Outer", "")
SECTION("Inner", "")
SUCCEED("that's not flying - that's failing in style");
FAIL("to infinity and beyond");
}
//#include "internal/catch_timer.h"
//
//TEST_CASE( "Timer", "[work-in-progress]" )
//{
// Catch::Timer t;
// t.start();
//
// std::cout << "starting..." << std::endl;
//
// double d = 0;
// for( int i = 0; i < 100000; ++i )
// for( int j = 0; j < 1000; ++j )
// d += (double)i*(double)j;
//
// double duration = t.getElapsedSeconds();
//
// std::cout << "finished in " << duration << std::endl;
//
// SUCCEED("yay");
//
//}

164
projects/SelfTest/TrickyTests.cpp
View File

@ -24,98 +24,94 @@ namespace Catch
} }
} }
namespace TrickTests ///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"./succeeding/Tricky/std::pair",
"Parsing a std::pair"
)
{
std::pair<int, int> aNicePair( 1, 2 );
REQUIRE( (std::pair<int, int>( 1, 2 )) == aNicePair );
}
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"./inprogress/failing/Tricky/trailing expression",
"Where the is more to the expression after the RHS"
)
{
// int a = 1, b = 2;
// REQUIRE( a == 2 || b == 2 );
WARN( "Uncomment the code in this test to check that it gives a sensible compiler error" );
}
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"./inprogress/failing/Tricky/compound lhs",
"Where the LHS is not a simple value"
)
{
/*
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 );
*/
WARN( "Uncomment the code in this test to check that it gives a sensible compiler error" );
}
struct Opaque
{
int val;
bool operator ==( const Opaque& o ) const
{
return val == o.val;
}
};
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"./failing/Tricky/non streamable type",
"A failing expression with a non streamable type is still captured"
)
{ {
/////////////////////////////////////////////////////////////////////////////// Opaque o1, o2;
TEST_CASE o1.val = 7;
( o2.val = 8;
"./succeeding/Tricky/std::pair",
"Parsing a std::pair"
)
{
std::pair<int, int> aNicePair( 1, 2 );
REQUIRE( (std::pair<int, int>( 1, 2 )) == aNicePair ); CHECK( &o1 == &o2 );
} CHECK( o1 == o2 );
}
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
TEST_CASE TEST_CASE
( (
"./inprogress/failing/Tricky/trailing expression", "./failing/string literals",
"Where the is more to the expression after the RHS" "string literals of different sizes can be compared"
) )
{ {
// int a = 1, b = 2; REQUIRE( std::string( "first" ) == "second" );
// REQUIRE( a == 2 || b == 2 );
WARN( "Uncomment the code in this test to check that it gives a sensible compiler error" );
}
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"./inprogress/failing/Tricky/compound lhs",
"Where the LHS is not a simple value"
)
{
/*
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 );
*/
WARN( "Uncomment the code in this test to check that it gives a sensible compiler error" );
}
struct Opaque ///////////////////////////////////////////////////////////////////////////////
{ TEST_CASE
int val; (
bool operator ==( const Opaque& o ) const "./succeeding/side-effects",
{ "An expression with side-effects should only be evaluated once"
return val == o.val; )
} {
}; int i = 7;
/////////////////////////////////////////////////////////////////////////////// REQUIRE( i++ == 7 );
TEST_CASE REQUIRE( i++ == 8 );
(
"./failing/Tricky/non streamable type",
"A failing expression with a non streamable type is still captured"
)
{
Opaque o1, o2;
o1.val = 7;
o2.val = 8;
CHECK( &o1 == &o2 );
CHECK( o1 == o2 );
}
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"./failing/string literals",
"string literals of different sizes can be compared"
)
{
REQUIRE( std::string( "first" ) == "second" );
}
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"./succeeding/side-effects",
"An expression with side-effects should only be evaluated once"
)
{
int i = 7;
REQUIRE( i++ == 7 );
REQUIRE( i++ == 8 );
}
} }
namespace A { namespace A {

62
projects/VS2010/TestCatch/TestCatch/TestCatch.vcxproj
View File

@ -94,11 +94,8 @@
<ClCompile Include="..\..\..\SelfTest\ApproxTests.cpp" /> <ClCompile Include="..\..\..\SelfTest\ApproxTests.cpp" />
<ClCompile Include="..\..\..\SelfTest\BDDTests.cpp" /> <ClCompile Include="..\..\..\SelfTest\BDDTests.cpp" />
<ClCompile Include="..\..\..\SelfTest\CmdLineTests.cpp" /> <ClCompile Include="..\..\..\SelfTest\CmdLineTests.cpp" />
<ClCompile Include="..\..\..\SelfTest\MessageInstantiationTests1.cpp" />
<ClCompile Include="..\..\..\SelfTest\MessageInstantiationTests2.cpp" />
<ClCompile Include="..\..\..\SelfTest\SectionTrackerTests.cpp" /> <ClCompile Include="..\..\..\SelfTest\SectionTrackerTests.cpp" />
<ClCompile Include="..\..\..\SelfTest\TestMain.cpp" /> <ClCompile Include="..\..\..\SelfTest\TestMain.cpp" />
<ClCompile Include="..\..\..\SelfTest\catch_self_test.cpp" />
<ClCompile Include="..\..\..\SelfTest\ClassTests.cpp" /> <ClCompile Include="..\..\..\SelfTest\ClassTests.cpp" />
<ClCompile Include="..\..\..\SelfTest\ConditionTests.cpp" /> <ClCompile Include="..\..\..\SelfTest\ConditionTests.cpp" />
<ClCompile Include="..\..\..\SelfTest\ExceptionTests.cpp" /> <ClCompile Include="..\..\..\SelfTest\ExceptionTests.cpp" />
@ -110,86 +107,41 @@
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="..\..\..\..\include\catch.hpp" /> <ClInclude Include="..\..\..\..\include\catch.hpp" />
<ClInclude Include="..\..\..\..\include\catch_objc.hpp" />
<ClInclude Include="..\..\..\..\include\catch_objc_main.hpp" />
<ClInclude Include="..\..\..\..\include\catch_runner.hpp" /> <ClInclude Include="..\..\..\..\include\catch_runner.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_approx.hpp" /> <ClInclude Include="..\..\..\..\include\catch_with_main.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_assertionresult.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_assertionresult.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_capture.hpp" /> <ClInclude Include="..\..\..\..\include\internal\catch_capture.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_commandline.hpp" /> <ClInclude Include="..\..\..\..\include\internal\catch_commandline.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_common.h" /> <ClInclude Include="..\..\..\..\include\internal\catch_common.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_compiler_capabilities.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_config.hpp" /> <ClInclude Include="..\..\..\..\include\internal\catch_config.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_console_colour.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_console_colour_impl.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_context.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_context_impl.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_debugger.hpp" /> <ClInclude Include="..\..\..\..\include\internal\catch_debugger.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_default_main.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_evaluate.hpp" /> <ClInclude Include="..\..\..\..\include\internal\catch_evaluate.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_exception_translator_registry.hpp" /> <ClInclude Include="..\..\..\..\include\internal\catch_exception_translator_registry.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_expressionresult_builder.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_expressionresult_builder.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_expression_decomposer.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_expression_lhs.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_generators.hpp" /> <ClInclude Include="..\..\..\..\include\internal\catch_generators.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_generators_impl.hpp" /> <ClInclude Include="..\..\..\..\include\internal\catch_generators_impl.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_impl.hpp" /> <ClInclude Include="..\..\..\..\include\internal\catch_hub.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_hub_impl.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_interfaces_capture.h" /> <ClInclude Include="..\..\..\..\include\internal\catch_interfaces_capture.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_interfaces_config.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_interfaces_exception.h" /> <ClInclude Include="..\..\..\..\include\internal\catch_interfaces_exception.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_interfaces_generators.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_interfaces_registry_hub.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_interfaces_reporter.h" /> <ClInclude Include="..\..\..\..\include\internal\catch_interfaces_reporter.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_interfaces_runner.h" /> <ClInclude Include="..\..\..\..\include\internal\catch_interfaces_runner.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_interfaces_testcase.h" /> <ClInclude Include="..\..\..\..\include\internal\catch_interfaces_testcase.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_legacy_reporter_adapter.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_legacy_reporter_adapter.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_list.hpp" /> <ClInclude Include="..\..\..\..\include\internal\catch_list.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_matchers.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_message.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_message.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_notimplemented_exception.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_notimplemented_exception.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_objc.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_objc_arc.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_option.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_platform.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_ptr.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_registry_hub.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_reporter_registrars.hpp" /> <ClInclude Include="..\..\..\..\include\internal\catch_reporter_registrars.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_reporter_registry.hpp" /> <ClInclude Include="..\..\..\..\include\internal\catch_reporter_registry.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_result_type.h" /> <ClInclude Include="..\..\..\..\include\internal\catch_result_type.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_resultinfo.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_runner_impl.hpp" /> <ClInclude Include="..\..\..\..\include\internal\catch_runner_impl.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_section.hpp" /> <ClInclude Include="..\..\..\..\include\internal\catch_section.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_self_test.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_sfinae.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_stream.hpp" /> <ClInclude Include="..\..\..\..\include\internal\catch_stream.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_streambuf.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_tags.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_test_case_info.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_test_case_info.hpp" /> <ClInclude Include="..\..\..\..\include\internal\catch_test_case_info.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_test_case_registry_impl.hpp" /> <ClInclude Include="..\..\..\..\include\internal\catch_test_case_registry_impl.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_test_case_tracker.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_test_registry.hpp" /> <ClInclude Include="..\..\..\..\include\internal\catch_test_registry.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_test_spec.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_text.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_text.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_timer.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_timer.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_tostring.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_totals.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_version.h" />
<ClInclude Include="..\..\..\..\include\internal\catch_version.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_vs_managed_impl.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_vs_native_impl.hpp" />
<ClInclude Include="..\..\..\..\include\internal\catch_xmlwriter.hpp" /> <ClInclude Include="..\..\..\..\include\internal\catch_xmlwriter.hpp" />
<ClInclude Include="..\..\..\..\include\reporters\catch_reporter_console.hpp" /> <ClInclude Include="..\..\..\..\include\reporters\catch_reporter_basic.hpp" />
<ClInclude Include="..\..\..\..\include\reporters\catch_reporter_junit.hpp" /> <ClInclude Include="..\..\..\..\include\reporters\catch_reporter_junit.hpp" />
<ClInclude Include="..\..\..\..\include\reporters\catch_reporter_xml.hpp" /> <ClInclude Include="..\..\..\..\include\reporters\catch_reporter_xml.hpp" />
<ClInclude Include="..\..\..\selftest\catch_self_test.hpp" />
</ItemGroup>
<ItemGroup>
<None Include="ReadMe.txt" />
</ItemGroup> </ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" /> <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets"> <ImportGroup Label="ExtensionTargets">

152
projects/VS2010/TestCatch/TestCatch/TestCatch.vcxproj.filters
View File

@ -7,9 +7,6 @@
<ClCompile Include="..\..\..\SelfTest\BDDTests.cpp"> <ClCompile Include="..\..\..\SelfTest\BDDTests.cpp">
<Filter>Sources</Filter> <Filter>Sources</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\..\..\SelfTest\catch_self_test.cpp">
<Filter>Sources</Filter>
</ClCompile>
<ClCompile Include="..\..\..\SelfTest\ClassTests.cpp"> <ClCompile Include="..\..\..\SelfTest\ClassTests.cpp">
<Filter>Sources</Filter> <Filter>Sources</Filter>
</ClCompile> </ClCompile>
@ -28,12 +25,6 @@
<ClCompile Include="..\..\..\SelfTest\GeneratorTests.cpp"> <ClCompile Include="..\..\..\SelfTest\GeneratorTests.cpp">
<Filter>Sources</Filter> <Filter>Sources</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\..\..\SelfTest\MessageInstantiationTests1.cpp">
<Filter>Sources</Filter>
</ClCompile>
<ClCompile Include="..\..\..\SelfTest\MessageInstantiationTests2.cpp">
<Filter>Sources</Filter>
</ClCompile>
<ClCompile Include="..\..\..\SelfTest\MessageTests.cpp"> <ClCompile Include="..\..\..\SelfTest\MessageTests.cpp">
<Filter>Sources</Filter> <Filter>Sources</Filter>
</ClCompile> </ClCompile>
@ -51,24 +42,9 @@
</ClCompile> </ClCompile>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="..\..\..\..\include\internal\catch_self_test.hpp">
<Filter>Sources</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\catch.hpp"> <ClInclude Include="..\..\..\..\include\catch.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_impl.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_approx.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_assertionresult.h">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_assertionresult.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_capture.hpp"> <ClInclude Include="..\..\..\..\include\internal\catch_capture.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
@ -78,48 +54,18 @@
<ClInclude Include="..\..\..\..\include\internal\catch_common.h"> <ClInclude Include="..\..\..\..\include\internal\catch_common.h">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_compiler_capabilities.h">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_config.hpp"> <ClInclude Include="..\..\..\..\include\internal\catch_config.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_console_colour.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_console_colour_impl.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_context.h">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_context_impl.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_debugger.hpp"> <ClInclude Include="..\..\..\..\include\internal\catch_debugger.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_default_main.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_evaluate.hpp"> <ClInclude Include="..\..\..\..\include\internal\catch_evaluate.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_exception_translator_registry.hpp"> <ClInclude Include="..\..\..\..\include\internal\catch_exception_translator_registry.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_expression_decomposer.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_expression_lhs.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_expressionresult_builder.h">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_expressionresult_builder.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_generators.hpp"> <ClInclude Include="..\..\..\..\include\internal\catch_generators.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
@ -132,18 +78,9 @@
<ClInclude Include="..\..\..\..\include\internal\catch_test_case_registry_impl.hpp"> <ClInclude Include="..\..\..\..\include\internal\catch_test_case_registry_impl.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_interfaces_config.h">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_interfaces_exception.h"> <ClInclude Include="..\..\..\..\include\internal\catch_interfaces_exception.h">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_interfaces_generators.h">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_interfaces_registry_hub.h">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_interfaces_reporter.h"> <ClInclude Include="..\..\..\..\include\internal\catch_interfaces_reporter.h">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
@ -153,51 +90,9 @@
<ClInclude Include="..\..\..\..\include\internal\catch_interfaces_testcase.h"> <ClInclude Include="..\..\..\..\include\internal\catch_interfaces_testcase.h">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_legacy_reporter_adapter.h">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_legacy_reporter_adapter.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_list.hpp"> <ClInclude Include="..\..\..\..\include\internal\catch_list.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_matchers.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_message.h">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_message.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_notimplemented_exception.h">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_notimplemented_exception.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_objc.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_objc_arc.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_option.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_platform.h">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_ptr.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_registry_hub.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\reporters\catch_reporter_console.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\reporters\catch_reporter_junit.hpp"> <ClInclude Include="..\..\..\..\include\reporters\catch_reporter_junit.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
@ -222,72 +117,39 @@
<ClInclude Include="..\..\..\..\include\internal\catch_section.hpp"> <ClInclude Include="..\..\..\..\include\internal\catch_section.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\selftest\catch_self_test.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_sfinae.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_stream.hpp"> <ClInclude Include="..\..\..\..\include\internal\catch_stream.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_streambuf.h">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_tags.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_test_case_info.h">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_test_case_info.hpp"> <ClInclude Include="..\..\..\..\include\internal\catch_test_case_info.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_test_case_tracker.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_xmlwriter.hpp"> <ClInclude Include="..\..\..\..\include\internal\catch_xmlwriter.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_test_registry.hpp"> <ClInclude Include="..\..\..\..\include\internal\catch_test_registry.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_test_spec.h"> <ClInclude Include="..\..\..\..\include\internal\catch_hub.h">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_text.h"> <ClInclude Include="..\..\..\..\include\catch_with_main.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_text.hpp"> <ClInclude Include="..\..\..\..\include\internal\catch_hub_impl.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_timer.h"> <ClInclude Include="..\..\..\..\include\catch_objc.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_timer.hpp"> <ClInclude Include="..\..\..\..\include\catch_objc_main.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_tostring.hpp"> <ClInclude Include="..\..\..\..\include\reporters\catch_reporter_basic.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_totals.hpp"> <ClInclude Include="..\..\..\..\include\internal\catch_resultinfo.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_version.h">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_version.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_vs_managed_impl.hpp">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\..\..\..\include\internal\catch_vs_native_impl.hpp">
<Filter>Headers</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<None Include="ReadMe.txt" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<Filter Include="Headers"> <Filter Include="Headers">