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

Converted all test case names to "modern" style (freeform text + tags)

This commit is contained in:
Phil Nash 2013-11-19 07:21:03 +00:00
parent a9fd5b3f14
commit 337dc25ed7
17 changed files with 587 additions and 1217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/internal/catch_test_case_info.hpp
View File

@ -22,7 +22,7 @@ namespace Catch {
SourceLineInfo const& _lineInfo )
{
std::string desc = _descOrTags;
bool isHidden( startsWith( _name, "./" ) );
bool isHidden( startsWith( _name, "./" ) ); // Legacy support
std::set<std::string> tags;
TagExtracter( tags ).parse( desc );
if( tags.find( "hide" ) != tags.end() || tags.find( "." ) != tags.end() )

4
include/internal/catch_test_case_registry_impl.hpp
View File

@ -42,8 +42,8 @@ namespace Catch {
else {
TestCase const& prev = *m_functions.find( testCase );
std::cerr << "error: TEST_CASE( \"" << name << "\" ) already defined.\n"
<< "\tFirst seen at " << SourceLineInfo( prev.getTestCaseInfo().lineInfo ) << "\n"
<< "\tRedefined at " << SourceLineInfo( testCase.getTestCaseInfo().lineInfo ) << std::endl;
<< "\tFirst seen at " << prev.getTestCaseInfo().lineInfo << "\n"
<< "\tRedefined at " << testCase.getTestCaseInfo().lineInfo << std::endl;
exit(1);
}
}

24
projects/SelfTest/ApproxTests.cpp
View File

@ -11,8 +11,8 @@
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"./succeeding/Approx/simple",
"Some simple comparisons between doubles"
"Some simple comparisons between doubles",
"[Approx]"
)
{
double d = 1.23;
@ -29,8 +29,8 @@ TEST_CASE
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"./succeeding/Approx/epsilon",
"Approximate comparisons with different epsilons"
"Approximate comparisons with different epsilons",
"[Approx]"
)
{
double d = 1.23;
@ -42,8 +42,8 @@ TEST_CASE
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"./succeeding/Approx/float",
"Approximate comparisons with floats"
"Approximate comparisons with floats",
"[Approx]"
)
{
REQUIRE( 1.23f == Approx( 1.23f ) );
@ -53,8 +53,8 @@ TEST_CASE
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"./succeeding/Approx/int",
"Approximate comparisons with ints"
"Approximate comparisons with ints",
"[Approx]"
)
{
REQUIRE( 1 == Approx( 1 ) );
@ -64,8 +64,8 @@ TEST_CASE
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"./succeeding/Approx/mixed",
"Approximate comparisons with mixed numeric types"
"Approximate comparisons with mixed numeric types",
"[Approx]"
)
{
const double dZero = 0;
@ -82,8 +82,8 @@ TEST_CASE
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"./succeeding/Approx/custom",
"Use a custom approx"
"Use a custom approx",
"[Approx][custom]"
)
{
double d = 1.23;

112
projects/SelfTest/Baselines/console.std.approved.txt
View File

@ -4,7 +4,7 @@ CatchSelfTest is a <version> host application.
Run with -? for options
-------------------------------------------------------------------------------
./failing/TestClass/failingCase
A METHOD_AS_TEST_CASE based test run that fails
-------------------------------------------------------------------------------
ClassTests.cpp:<line number>
...............................................................................
@ -15,7 +15,7 @@ with expansion:
"hello" == "world"
-------------------------------------------------------------------------------
./failing/Fixture/failingCase
A TEST_CASE_METHOD based test run that fails
-------------------------------------------------------------------------------
ClassTests.cpp:<line number>
...............................................................................
@ -26,7 +26,7 @@ with expansion:
1 == 2
-------------------------------------------------------------------------------
./failing/conditions/equality
Equality checks that should fail]
-------------------------------------------------------------------------------
ConditionTests.cpp:<line number>
...............................................................................
@ -97,7 +97,7 @@ with expansion:
1.3 == Approx( 1.301 )
-------------------------------------------------------------------------------
./failing/conditions/inequality
Inequality checks that should fails
-------------------------------------------------------------------------------
ConditionTests.cpp:<line number>
...............................................................................
@ -128,7 +128,7 @@ with expansion:
5 != 5
-------------------------------------------------------------------------------
./failing/conditions/ordered
Ordering comparison checks that should fail
-------------------------------------------------------------------------------
ConditionTests.cpp:<line number>
...............................................................................
@ -229,7 +229,7 @@ with expansion:
"hello" <= "a"
-------------------------------------------------------------------------------
./failing/conditions/not
'Not' checks that should fail
-------------------------------------------------------------------------------
ConditionTests.cpp:<line number>
...............................................................................
@ -269,7 +269,7 @@ with expansion:
!(1 == 1)
-------------------------------------------------------------------------------
./failing/exceptions/explicit
Expected exceptions that don't throw or unexpected exceptions fail the test
-------------------------------------------------------------------------------
ExceptionTests.cpp:<line number>
...............................................................................
@ -289,7 +289,7 @@ due to unexpected exception with message:
expected exception
-------------------------------------------------------------------------------
./failing/exceptions/implicit
When unchecked exceptions are thrown directly they are always failures
-------------------------------------------------------------------------------
ExceptionTests.cpp:<line number>
...............................................................................
@ -299,7 +299,7 @@ due to unexpected exception with message:
unexpected exception
-------------------------------------------------------------------------------
./failing/exceptions/implicit/2
An unchecked exception reports the line of the last assertion
-------------------------------------------------------------------------------
ExceptionTests.cpp:<line number>
...............................................................................
@ -310,7 +310,7 @@ due to unexpected exception with message:
unexpected exception
-------------------------------------------------------------------------------
./failing/exceptions/implicit/3
When unchecked exceptions are thrown from sections they are always failures
section name
-------------------------------------------------------------------------------
ExceptionTests.cpp:<line number>
@ -321,7 +321,7 @@ due to unexpected exception with message:
unexpected exception
-------------------------------------------------------------------------------
./failing/exceptions/implicit/4
When unchecked exceptions are thrown from functions they are always failures
-------------------------------------------------------------------------------
ExceptionTests.cpp:<line number>
...............................................................................
@ -332,7 +332,7 @@ due to unexpected exception with message:
expected exception
-------------------------------------------------------------------------------
./failing/exceptions/custom
Unexpected custom exceptions can be translated
-------------------------------------------------------------------------------
ExceptionTests.cpp:<line number>
...............................................................................
@ -342,7 +342,7 @@ due to unexpected exception with message:
custom exception
-------------------------------------------------------------------------------
./failing/exceptions/custom/nothrow
Custom exceptions can be translated when testing for nothrow
-------------------------------------------------------------------------------
ExceptionTests.cpp:<line number>
...............................................................................
@ -353,7 +353,7 @@ due to unexpected exception with message:
custom exception - not std
-------------------------------------------------------------------------------
./failing/exceptions/custom/throw
Custom exceptions can be translated when testing for throwing as something else
-------------------------------------------------------------------------------
ExceptionTests.cpp:<line number>
...............................................................................
@ -364,7 +364,7 @@ due to unexpected exception with message:
custom exception - not std
-------------------------------------------------------------------------------
./failing/exceptions/custom/double
Unexpected exceptions can be translated
-------------------------------------------------------------------------------
ExceptionTests.cpp:<line number>
...............................................................................
@ -374,7 +374,7 @@ due to unexpected exception with message:
3.14
-------------------------------------------------------------------------------
./succeeding/message
INFO and WARN do not abort tests
-------------------------------------------------------------------------------
MessageTests.cpp:<line number>
...............................................................................
@ -384,7 +384,7 @@ warning:
this is a warning
-------------------------------------------------------------------------------
./failing/message/info/1
INFO gets logged on failure
-------------------------------------------------------------------------------
MessageTests.cpp:<line number>
...............................................................................
@ -398,7 +398,7 @@ with messages:
so should this
-------------------------------------------------------------------------------
./mixed/message/info/2
INFO gets logged on failure, even if captured before successful assertions
-------------------------------------------------------------------------------
MessageTests.cpp:<line number>
...............................................................................
@ -419,7 +419,7 @@ with message:
and this, but later
-------------------------------------------------------------------------------
./failing/message/fail
FAIL aborts the test
-------------------------------------------------------------------------------
MessageTests.cpp:<line number>
...............................................................................
@ -429,7 +429,7 @@ explicitly with message:
This is a failure
-------------------------------------------------------------------------------
./failing/message/sections
Output from all sections is reported
one
-------------------------------------------------------------------------------
MessageTests.cpp:<line number>
@ -440,7 +440,7 @@ explicitly with message:
Message from section one
-------------------------------------------------------------------------------
./failing/message/sections
Output from all sections is reported
two
-------------------------------------------------------------------------------
MessageTests.cpp:<line number>
@ -453,7 +453,7 @@ explicitly with message:
Message from section one
Message from section two
-------------------------------------------------------------------------------
./mixed/message/scoped
SCOPED_INFO is reset for each loop
-------------------------------------------------------------------------------
MessageTests.cpp:<line number>
...............................................................................
@ -477,7 +477,19 @@ explicitly with message:
Previous info should not be seen
-------------------------------------------------------------------------------
./mixed/Misc/Sections/nested2
sends information to INFO
-------------------------------------------------------------------------------
MessageTests.cpp:<line number>
...............................................................................
MessageTests.cpp:<line number>: FAILED:
REQUIRE( false )
with messages:
hi
i := 7
-------------------------------------------------------------------------------
more nested SECTION tests
s1
s2
-------------------------------------------------------------------------------
@ -490,7 +502,7 @@ with expansion:
1 == 2
-------------------------------------------------------------------------------
./mixed/Misc/Sections/loops
looped SECTION tests
s1
-------------------------------------------------------------------------------
MiscTests.cpp:<line number>
@ -502,7 +514,7 @@ with expansion:
0 > 1
-------------------------------------------------------------------------------
./mixed/Misc/loops
looped tests
-------------------------------------------------------------------------------
MiscTests.cpp:<line number>
...............................................................................
@ -552,19 +564,7 @@ with message:
Some information
An error
-------------------------------------------------------------------------------
./failing/info
-------------------------------------------------------------------------------
MiscTests.cpp:<line number>
...............................................................................
MiscTests.cpp:<line number>: FAILED:
REQUIRE( false )
with messages:
hi
i := 7
-------------------------------------------------------------------------------
./failing/checkedif
checkedIf, failing
-------------------------------------------------------------------------------
MiscTests.cpp:<line number>
...............................................................................
@ -580,7 +580,7 @@ with expansion:
false
-------------------------------------------------------------------------------
./failing/checkedelse
checkedElse, failing
-------------------------------------------------------------------------------
MiscTests.cpp:<line number>
...............................................................................
@ -596,7 +596,7 @@ with expansion:
false
-------------------------------------------------------------------------------
./manual/onechar
send a single char to INFO
-------------------------------------------------------------------------------
MiscTests.cpp:<line number>
...............................................................................
@ -607,7 +607,7 @@ with message:
3
-------------------------------------------------------------------------------
./failing/matchers/Contains
Contains string matcher
-------------------------------------------------------------------------------
MiscTests.cpp:<line number>
...............................................................................
@ -618,7 +618,7 @@ with expansion:
"this string contains 'abc' as a substring" contains: "not there"
-------------------------------------------------------------------------------
./failing/matchers/StartsWith
StartsWith string matcher
-------------------------------------------------------------------------------
MiscTests.cpp:<line number>
...............................................................................
@ -629,7 +629,7 @@ with expansion:
"this string contains 'abc' as a substring" starts with: "string"
-------------------------------------------------------------------------------
./failing/matchers/EndsWith
EndsWith string matcher
-------------------------------------------------------------------------------
MiscTests.cpp:<line number>
...............................................................................
@ -640,7 +640,7 @@ with expansion:
"this string contains 'abc' as a substring" ends with: "this"
-------------------------------------------------------------------------------
./failing/matchers/Equals
Equals string matcher
-------------------------------------------------------------------------------
MiscTests.cpp:<line number>
...............................................................................
@ -661,7 +661,7 @@ warning:
This one ran
-------------------------------------------------------------------------------
./failing/CatchSectionInfiniteLoop
A couple of nested sections followed by a failure
-------------------------------------------------------------------------------
MiscTests.cpp:<line number>
...............................................................................
@ -671,7 +671,7 @@ explicitly with message:
to infinity and beyond
-------------------------------------------------------------------------------
./failing/CatchSectionInfiniteLoop
A couple of nested sections followed by a failure
-------------------------------------------------------------------------------
MiscTests.cpp:<line number>
...............................................................................
@ -681,7 +681,7 @@ explicitly with message:
to infinity and beyond
-------------------------------------------------------------------------------
./failing/CatchSectionInfiniteLoop
A couple of nested sections followed by a failure
-------------------------------------------------------------------------------
MiscTests.cpp:<line number>
...............................................................................
@ -690,18 +690,10 @@ MiscTests.cpp:<line number>: FAILED:
explicitly with message:
to infinity and beyond
Message from section one
Message from section two
Some information
An error
Message from section one
Message from section two
Some information
An error
hello
hello
-------------------------------------------------------------------------------
./inprogress/failing/Tricky/trailing expression
Where the is more to the expression after the RHS[failing]
-------------------------------------------------------------------------------
TrickyTests.cpp:<line number>
...............................................................................
@ -712,7 +704,7 @@ warning:
error
-------------------------------------------------------------------------------
./inprogress/failing/Tricky/compound lhs
Where the LHS is not a simple value[failing]
-------------------------------------------------------------------------------
TrickyTests.cpp:<line number>
...............................................................................
@ -723,7 +715,7 @@ warning:
error
-------------------------------------------------------------------------------
./failing/Tricky/non streamable type
A failing expression with a non streamable type is still captured[failing]
-------------------------------------------------------------------------------
TrickyTests.cpp:<line number>
...............................................................................
@ -739,7 +731,7 @@ with expansion:
{?} == {?}
-------------------------------------------------------------------------------
./failing/string literals
string literals of different sizes can be compared[failing]
-------------------------------------------------------------------------------
TrickyTests.cpp:<line number>
...............................................................................
@ -750,5 +742,5 @@ with expansion:
"first" == "second"
===============================================================================
122 test cases - 35 failed (753 assertions - 90 failed)
120 test cases - 35 failed (673 assertions - 90 failed)

841
projects/SelfTest/Baselines/console.sw.approved.txt
View File

File diff suppressed because it is too large Load Diff

24
projects/SelfTest/Baselines/console.swa4.approved.txt
View File

@ -4,7 +4,7 @@ CatchSelfTest is a <version> host application.
Run with -? for options
-------------------------------------------------------------------------------
./succeeding/Approx/simple
Some simple comparisons between doubles
-------------------------------------------------------------------------------
ApproxTests.cpp:<line number>
...............................................................................
@ -46,7 +46,7 @@ with expansion:
Approx( 1.23 ) != 1.24
-------------------------------------------------------------------------------
./succeeding/Approx/epsilon
Approximate comparisons with different epsilons
-------------------------------------------------------------------------------
ApproxTests.cpp:<line number>
...............................................................................
@ -64,7 +64,7 @@ with expansion:
1.23 == Approx( 1.231 )
-------------------------------------------------------------------------------
./succeeding/Approx/float
Approximate comparisons with floats
-------------------------------------------------------------------------------
ApproxTests.cpp:<line number>
...............................................................................
@ -82,7 +82,7 @@ with expansion:
0 == Approx( 0 )
-------------------------------------------------------------------------------
./succeeding/Approx/int
Approximate comparisons with ints
-------------------------------------------------------------------------------
ApproxTests.cpp:<line number>
...............................................................................
@ -96,7 +96,7 @@ PASSED:
REQUIRE( 0 == Approx( 0 ) )
-------------------------------------------------------------------------------
./succeeding/Approx/mixed
Approximate comparisons with mixed numeric types
-------------------------------------------------------------------------------
ApproxTests.cpp:<line number>
...............................................................................
@ -132,7 +132,7 @@ with expansion:
1.234 == Approx( 1.234 )
-------------------------------------------------------------------------------
./succeeding/Approx/custom
Use a custom approx
-------------------------------------------------------------------------------
ApproxTests.cpp:<line number>
...............................................................................
@ -204,7 +204,7 @@ with expansion:
3.1428571429 != Approx( 3.141 )
-------------------------------------------------------------------------------
./succeeding/TestClass/succeedingCase
A METHOD_AS_TEST_CASE based test run that succeeds
-------------------------------------------------------------------------------
ClassTests.cpp:<line number>
...............................................................................
@ -216,7 +216,7 @@ with expansion:
"hello" == "hello"
-------------------------------------------------------------------------------
./failing/TestClass/failingCase
A METHOD_AS_TEST_CASE based test run that fails
-------------------------------------------------------------------------------
ClassTests.cpp:<line number>
...............................................................................
@ -227,7 +227,7 @@ with expansion:
"hello" == "world"
-------------------------------------------------------------------------------
./succeeding/Fixture/succeedingCase
A TEST_CASE_METHOD based test run that succeeds
-------------------------------------------------------------------------------
ClassTests.cpp:<line number>
...............................................................................
@ -239,7 +239,7 @@ with expansion:
1 == 1
-------------------------------------------------------------------------------
./failing/Fixture/failingCase
A TEST_CASE_METHOD based test run that fails
-------------------------------------------------------------------------------
ClassTests.cpp:<line number>
...............................................................................
@ -250,7 +250,7 @@ with expansion:
1 == 2
-------------------------------------------------------------------------------
./succeeding/conditions/equality
Equality checks that should succeed
-------------------------------------------------------------------------------
ConditionTests.cpp:<line number>
...............................................................................
@ -298,7 +298,7 @@ with expansion:
1.3 == Approx( 1.3 )
-------------------------------------------------------------------------------
./failing/conditions/equality
Equality checks that should fail]
-------------------------------------------------------------------------------
ConditionTests.cpp:<line number>
...............................................................................

224
projects/SelfTest/Baselines/junit.sw.approved.txt
View File

@ -1,26 +1,26 @@
<testsuites>
<testsuite name="~_" errors="10" failures="99" tests="772" hostname="tbd" time="{duration}" timestamp="tbd">
<testcase classname="global" name="./succeeding/Approx/simple" time="{duration}"/>
<testcase classname="global" name="./succeeding/Approx/epsilon" time="{duration}"/>
<testcase classname="global" name="./succeeding/Approx/float" time="{duration}"/>
<testcase classname="global" name="./succeeding/Approx/int" time="{duration}"/>
<testcase classname="global" name="./succeeding/Approx/mixed" time="{duration}"/>
<testcase classname="global" name="./succeeding/Approx/custom" time="{duration}"/>
<testsuite name="~_" errors="10" failures="99" tests="692" hostname="tbd" time="{duration}" timestamp="tbd">
<testcase classname="global" name="Some simple comparisons between doubles" time="{duration}"/>
<testcase classname="global" name="Approximate comparisons with different epsilons" time="{duration}"/>
<testcase classname="global" name="Approximate comparisons with floats" time="{duration}"/>
<testcase classname="global" name="Approximate comparisons with ints" time="{duration}"/>
<testcase classname="global" name="Approximate comparisons with mixed numeric types" time="{duration}"/>
<testcase classname="global" name="Use a custom approx" time="{duration}"/>
<testcase classname="global" name="Approximate PI" time="{duration}"/>
<testcase classname="TestClass" name="./succeeding/TestClass/succeedingCase" time="{duration}"/>
<testcase classname="TestClass" name="./failing/TestClass/failingCase" time="{duration}">
<testcase classname="TestClass" name="A METHOD_AS_TEST_CASE based test run that succeeds" time="{duration}"/>
<testcase classname="TestClass" name="A METHOD_AS_TEST_CASE based test run that fails" time="{duration}">
<failure message="&quot;hello&quot; == &quot;world&quot;" type="REQUIRE">
ClassTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="Fixture" name="./succeeding/Fixture/succeedingCase" time="{duration}"/>
<testcase classname="Fixture" name="./failing/Fixture/failingCase" time="{duration}">
<testcase classname="Fixture" name="A TEST_CASE_METHOD based test run that succeeds" time="{duration}"/>
<testcase classname="Fixture" name="A TEST_CASE_METHOD based test run that fails" time="{duration}">
<failure message="1 == 2" type="REQUIRE">
ClassTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="global" name="./succeeding/conditions/equality" time="{duration}"/>
<testcase classname="global" name="./failing/conditions/equality" time="{duration}">
<testcase classname="global" name="Equality checks that should succeed" time="{duration}"/>
<testcase classname="global" name="Equality checks that should fail]" time="{duration}">
<failure message="7 == 6" type="CHECK">
ConditionTests.cpp:<line number>
</failure>
@ -61,8 +61,8 @@ ConditionTests.cpp:<line number>
ConditionTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="global" name="./succeeding/conditions/inequality" time="{duration}"/>
<testcase classname="global" name="./failing/conditions/inequality" time="{duration}">
<testcase classname="global" name="Inequality checks that should succeed" time="{duration}"/>
<testcase classname="global" name="Inequality checks that should fails" time="{duration}">
<failure message="7 != 7" type="CHECK">
ConditionTests.cpp:<line number>
</failure>
@ -79,8 +79,8 @@ ConditionTests.cpp:<line number>
ConditionTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="global" name="./succeeding/conditions/ordered" time="{duration}"/>
<testcase classname="global" name="./failing/conditions/ordered" time="{duration}">
<testcase classname="global" name="Ordering comparison checks that should succeed" time="{duration}"/>
<testcase classname="global" name="Ordering comparison checks that should fail" time="{duration}">
<failure message="7 > 7" type="CHECK">
ConditionTests.cpp:<line number>
</failure>
@ -139,14 +139,14 @@ ConditionTests.cpp:<line number>
ConditionTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="global" name="./succeeding/conditions/int literals" time="{duration}"/>
<testcase classname="global" name="./succeeding/conditions//long_to_unsigned_x" time="{duration}"/>
<testcase classname="global" name="./succeeding/conditions/const ints to int literal" time="{duration}"/>
<testcase classname="global" name="./succeeding/conditions/negative ints" time="{duration}"/>
<testcase classname="global" name="./succeeding/conditions/computed ints" time="{duration}"/>
<testcase classname="global" name="./succeeding/conditions/ptr" time="{duration}"/>
<testcase classname="global" name="./succeeding/conditions/not" time="{duration}"/>
<testcase classname="global" name="./failing/conditions/not" time="{duration}">
<testcase classname="global" name="Comparisons with int literals don't warn when mixing signed/ unsigned" time="{duration}"/>
<testcase classname="global" name="comparisons between int variables" time="{duration}"/>
<testcase classname="global" name="comparisons between const int variables" time="{duration}"/>
<testcase classname="global" name="Comparisons between unsigned ints and negative signed ints match c++ standard behaviour" time="{duration}"/>
<testcase classname="global" name="Comparisons between ints where one side is computed" time="{duration}"/>
<testcase classname="global" name="Pointers can be compared to null" time="{duration}"/>
<testcase classname="global" name="'Not' checks that should succeed" time="{duration}"/>
<testcase classname="global" name="'Not' checks that should fail" time="{duration}">
<failure message="false != false" type="CHECK">
ConditionTests.cpp:<line number>
</failure>
@ -172,8 +172,8 @@ ConditionTests.cpp:<line number>
ConditionTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="global" name="./succeeding/exceptions/explicit" time="{duration}"/>
<testcase classname="global" name="./failing/exceptions/explicit" time="{duration}">
<testcase classname="global" name="When checked exceptions are thrown they can be expected or unexpected" time="{duration}"/>
<testcase classname="global" name="Expected exceptions that don't throw or unexpected exceptions fail the test" time="{duration}">
<error message="thisThrows()" type="CHECK_THROWS_AS">
expected exception
ExceptionTests.cpp:<line number>
@ -186,67 +186,67 @@ expected exception
ExceptionTests.cpp:<line number>
</error>
</testcase>
<testcase classname="global" name="./failing/exceptions/implicit" time="{duration}">
<testcase classname="global" name="When unchecked exceptions are thrown directly they are always failures" time="{duration}">
<error type="TEST_CASE">
unexpected exception
ExceptionTests.cpp:<line number>
</error>
</testcase>
<testcase classname="global" name="./failing/exceptions/implicit/2" time="{duration}">
<testcase classname="global" name="An unchecked exception reports the line of the last assertion" time="{duration}">
<error message="{Unknown expression after the reported line}">
unexpected exception
ExceptionTests.cpp:<line number>
</error>
</testcase>
<testcase classname="./failing/exceptions/implicit/3" name="section name" time="{duration}">
<testcase classname="When unchecked exceptions are thrown from sections they are always failures" name="section name" time="{duration}">
<error type="TEST_CASE">
unexpected exception
ExceptionTests.cpp:<line number>
</error>
</testcase>
<testcase classname="global" name="./failing/exceptions/implicit/4" time="{duration}">
<testcase classname="global" name="When unchecked exceptions are thrown from functions they are always failures" time="{duration}">
<error message="thisThrows() == 0" type="CHECK">
expected exception
ExceptionTests.cpp:<line number>
</error>
</testcase>
<testcase classname="global" name="./failing/exceptions/custom" time="{duration}">
<testcase classname="global" name="Unexpected custom exceptions can be translated" time="{duration}">
<error type="TEST_CASE">
custom exception
ExceptionTests.cpp:<line number>
</error>
</testcase>
<testcase classname="global" name="./failing/exceptions/custom/nothrow" time="{duration}">
<testcase classname="global" name="Custom exceptions can be translated when testing for nothrow" time="{duration}">
<error message="throwCustom()" type="REQUIRE_NOTHROW">
custom exception - not std
ExceptionTests.cpp:<line number>
</error>
</testcase>
<testcase classname="global" name="./failing/exceptions/custom/throw" time="{duration}">
<testcase classname="global" name="Custom exceptions can be translated when testing for throwing as something else" time="{duration}">
<error message="throwCustom()" type="REQUIRE_THROWS_AS">
custom exception - not std
ExceptionTests.cpp:<line number>
</error>
</testcase>
<testcase classname="global" name="./failing/exceptions/custom/double" time="{duration}">
<testcase classname="global" name="Unexpected exceptions can be translated" time="{duration}">
<error type="TEST_CASE">
3.14
ExceptionTests.cpp:<line number>
</error>
</testcase>
<testcase classname="global" name="./succeeding/exceptions/notimplemented" time="{duration}"/>
<testcase classname="global" name="./succeeding/generators/1" time="{duration}"/>
<testcase classname="global" name="./succeeding/generators/2" time="{duration}"/>
<testcase classname="global" name="./succeeding/message" time="{duration}"/>
<testcase classname="global" name="./succeeding/succeed" time="{duration}"/>
<testcase classname="global" name="./failing/message/info/1" time="{duration}">
<testcase classname="global" name="NotImplemented exception" time="{duration}"/>
<testcase classname="global" name="Generators over two ranges" time="{duration}"/>
<testcase classname="global" name="Generator over a range of pairs" time="{duration}"/>
<testcase classname="global" name="INFO and WARN do not abort tests" time="{duration}"/>
<testcase classname="global" name="SUCCEED counts as a test pass" time="{duration}"/>
<testcase classname="global" name="INFO gets logged on failure" time="{duration}">
<failure message="2 == 1" type="REQUIRE">
this message should be logged
so should this
MessageTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="global" name="./mixed/message/info/2" time="{duration}">
<testcase classname="global" name="INFO gets logged on failure, even if captured before successful assertions" time="{duration}">
<failure message="2 == 1" type="CHECK">
this message should be logged
MessageTests.cpp:<line number>
@ -256,61 +256,68 @@ and this, but later
MessageTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="global" name="./failing/message/fail" time="{duration}">
<testcase classname="global" name="FAIL aborts the test" time="{duration}">
<failure type="FAIL">
This is a failure
MessageTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="./failing/message/sections" name="one" time="{duration}">
<testcase classname="Output from all sections is reported" name="one" time="{duration}">
<failure type="FAIL">
Message from section one
MessageTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="./failing/message/sections" name="two" time="{duration}">
<testcase classname="Output from all sections is reported" name="two" time="{duration}">
<failure type="FAIL">
Message from section two
MessageTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="./succeeding/message/sections/stdout" name="two" time="{duration}">
<testcase classname="Standard output from all sections is reported" name="two" time="{duration}">
<system-out>
Message from section one
Message from section two
</system-out>
</testcase>
<testcase classname="global" name="./mixed/message/scoped" time="{duration}">
<testcase classname="global" name="SCOPED_INFO is reset for each loop" time="{duration}">
<failure message="10 &lt; 10" type="REQUIRE">
current counter 10
i := 10
MessageTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="global" name="./succeeding/nofail" time="{duration}"/>
<testcase classname="global" name="The NO_FAIL macro reports a failure but does not fail the test" time="{duration}"/>
<testcase classname="global" name="just failure" time="{duration}">
<failure type="FAIL">
Previous info should not be seen
MessageTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="./succeeding/Misc/Sections" name="s1" time="{duration}"/>
<testcase classname="./succeeding/Misc/Sections" name="s2" time="{duration}"/>
<testcase classname="./succeeding/Misc/Sections/nested" name="s1" time="{duration}"/>
<testcase classname="./succeeding/Misc/Sections/nested" name="s1/s2" time="{duration}"/>
<testcase classname="./mixed/Misc/Sections/nested2" name="s1/s2" time="{duration}">
<testcase classname="global" name="sends information to INFO" time="{duration}">
<failure message="false" type="REQUIRE">
hi
i := 7
MessageTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="random SECTION tests" name="s1" time="{duration}"/>
<testcase classname="random SECTION tests" name="s2" time="{duration}"/>
<testcase classname="nested SECTION tests" name="s1" time="{duration}"/>
<testcase classname="nested SECTION tests" name="s1/s2" time="{duration}"/>
<testcase classname="more nested SECTION tests" name="s1/s2" time="{duration}">
<failure message="1 == 2" type="REQUIRE">
MiscTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="./mixed/Misc/Sections/nested2" name="s1/s3" time="{duration}"/>
<testcase classname="./mixed/Misc/Sections/nested2" name="s1/s4" time="{duration}"/>
<testcase classname="./mixed/Misc/Sections/loops" name="s1" time="{duration}">
<testcase classname="more nested SECTION tests" name="s1/s3" time="{duration}"/>
<testcase classname="more nested SECTION tests" name="s1/s4" time="{duration}"/>
<testcase classname="looped SECTION tests" name="s1" time="{duration}">
<failure message="0 > 1" type="CHECK">
MiscTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="global" name="./mixed/Misc/loops" time="{duration}">
<testcase classname="global" name="looped tests" time="{duration}">
<failure message="1 == 0" type="CHECK">
Testing if fib[0] (1) is even
MiscTests.cpp:<line number>
@ -336,7 +343,7 @@ Testing if fib[7] (21) is even
MiscTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="global" name="./succeeding/Misc/stdout,stderr" time="{duration}">
<testcase classname="global" name="Sends stuff to stdout and stderr" time="{duration}">
<system-out>
Some information
</system-out>
@ -344,16 +351,9 @@ Some information
An error
</system-err>
</testcase>
<testcase classname="global" name="./succeeding/Misc/null strings" time="{duration}"/>
<testcase classname="global" name="./failing/info" time="{duration}">
<failure message="false" type="REQUIRE">
hi
i := 7
MiscTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="global" name="./succeeding/checkedif" time="{duration}"/>
<testcase classname="global" name="./failing/checkedif" time="{duration}">
<testcase classname="global" name="null strings" time="{duration}"/>
<testcase classname="global" name="checkedIf" time="{duration}"/>
<testcase classname="global" name="checkedIf, failing" time="{duration}">
<failure message="false" type="CHECKED_IF">
MiscTests.cpp:<line number>
</failure>
@ -361,8 +361,8 @@ MiscTests.cpp:<line number>
MiscTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="global" name="./succeeding/checkedelse" time="{duration}"/>
<testcase classname="global" name="./failing/checkedelse" time="{duration}">
<testcase classname="global" name="checkedElse" time="{duration}"/>
<testcase classname="global" name="checkedElse, failing" time="{duration}">
<failure message="false" type="CHECKED_ELSE">
MiscTests.cpp:<line number>
</failure>
@ -370,38 +370,38 @@ MiscTests.cpp:<line number>
MiscTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="global" name="./manual/onechar" time="{duration}">
<testcase classname="global" name="send a single char to INFO" time="{duration}">
<failure message="false" type="REQUIRE">
3
MiscTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="global" name="./succeeding/atomic if" time="{duration}"/>
<testcase classname="global" name="./succeeding/matchers" time="{duration}"/>
<testcase classname="global" name="./failing/matchers/Contains" time="{duration}">
<testcase classname="global" name="atomic if" time="{duration}"/>
<testcase classname="global" name="String matchers" time="{duration}"/>
<testcase classname="global" name="Contains string matcher" time="{duration}">
<failure message="&quot;this string contains 'abc' as a substring&quot; contains: &quot;not there&quot;" type="CHECK_THAT">
MiscTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="global" name="./failing/matchers/StartsWith" time="{duration}">
<testcase classname="global" name="StartsWith string matcher" time="{duration}">
<failure message="&quot;this string contains 'abc' as a substring&quot; starts with: &quot;string&quot;" type="CHECK_THAT">
MiscTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="global" name="./failing/matchers/EndsWith" time="{duration}">
<testcase classname="global" name="EndsWith string matcher" time="{duration}">
<failure message="&quot;this string contains 'abc' as a substring&quot; ends with: &quot;this&quot;" type="CHECK_THAT">
MiscTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="global" name="./failing/matchers/Equals" time="{duration}">
<testcase classname="global" name="Equals string matcher" time="{duration}">
<failure message="&quot;this string contains 'abc' as a substring&quot; equals: &quot;something else&quot;" type="CHECK_THAT">
MiscTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="global" name="string" time="{duration}"/>
<testcase classname="global" name="./succeeding/matchers/AllOf" time="{duration}"/>
<testcase classname="global" name="./succeeding/matchers/AnyOf" time="{duration}"/>
<testcase classname="global" name="./succeeding/matchers/Equals" time="{duration}"/>
<testcase classname="global" name="Equals string matcher, with NULL" time="{duration}"/>
<testcase classname="global" name="AllOf matcher" time="{duration}"/>
<testcase classname="global" name="AnyOf matcher" time="{duration}"/>
<testcase classname="global" name="Equals" time="{duration}"/>
<testcase classname="global" name="Factorials are computed" time="{duration}"/>
<testcase classname="global" name="Nice descriptive name" time="{duration}"/>
<testcase classname="vectors can be sized and resized" name="root" time="{duration}"/>
@ -410,7 +410,7 @@ MiscTests.cpp:<line number>
<testcase classname="vectors can be sized and resized" name="resizing smaller changes size but not capacity/We can use the 'swap trick' to reset the capacity" time="{duration}"/>
<testcase classname="vectors can be sized and resized" name="reserving bigger changes capacity but not size" time="{duration}"/>
<testcase classname="vectors can be sized and resized" name="reserving smaller does not change size or capacity" time="{duration}"/>
<testcase classname="./failing/CatchSectionInfiniteLoop" name="root" time="{duration}">
<testcase classname="A couple of nested sections followed by a failure" name="root" time="{duration}">
<failure type="FAIL">
to infinity and beyond
MiscTests.cpp:<line number>
@ -424,25 +424,7 @@ to infinity and beyond
MiscTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="./failing/CatchSectionInfiniteLoop" name="Outer/Inner" time="{duration}"/>
<testcase classname="selftest/main" name="selftest/expected result/selftest/expected result/failing tests" time="{duration}"/>
<testcase classname="selftest/main" name="selftest/expected result/selftest/expected result/succeeding tests" time="{duration}"/>
<testcase classname="selftest/main" name="selftest/test counts/selftest/test counts/succeeding tests" time="{duration}"/>
<testcase classname="selftest/main" name="selftest/test counts/selftest/test counts/failing tests" time="{duration}">
<system-out>
Message from section one
Message from section two
Some information
Message from section one
Message from section two
Some information
</system-out>
<system-err>
An error
An error
</system-err>
</testcase>
<testcase classname="global" name="meta/Misc/Sections" time="{duration}"/>
<testcase classname="A couple of nested sections followed by a failure" name="Outer/Inner" time="{duration}"/>
<testcase classname="Process can be configured on command line" name="default - no arguments" time="{duration}"/>
<testcase classname="Process can be configured on command line" name="test lists/1 test" time="{duration}"/>
<testcase classname="Process can be configured on command line" name="test lists/Specify one test case exclusion using exclude:" time="{duration}"/>
@ -493,10 +475,10 @@ hello
</testcase>
<testcase classname="global" name="Text can be formatted using the Text class" time="{duration}"/>
<testcase classname="global" name="Long text is truncted" time="{duration}"/>
<testcase classname="global" name="./succeeding/Tricky/std::pair" time="{duration}"/>
<testcase classname="global" name="./inprogress/failing/Tricky/trailing expression" time="{duration}"/>
<testcase classname="global" name="./inprogress/failing/Tricky/compound lhs" time="{duration}"/>
<testcase classname="global" name="./failing/Tricky/non streamable type" time="{duration}">
<testcase classname="global" name="Parsing a std::pair" time="{duration}"/>
<testcase classname="global" name="Where the is more to the expression after the RHS[failing]" time="{duration}"/>
<testcase classname="global" name="Where the LHS is not a simple value[failing]" time="{duration}"/>
<testcase classname="global" name="A failing expression with a non streamable type is still captured[failing]" time="{duration}">
<failure message="0x<hex digits> == 0x<hex digits>" type="CHECK">
TrickyTests.cpp:<line number>
</failure>
@ -504,22 +486,22 @@ TrickyTests.cpp:<line number>
TrickyTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="global" name="./failing/string literals" time="{duration}">
<testcase classname="global" name="string literals of different sizes can be compared[failing]" time="{duration}">
<failure message="&quot;first&quot; == &quot;second&quot;" type="REQUIRE">
TrickyTests.cpp:<line number>
</failure>
</testcase>
<testcase classname="global" name="./succeeding/side-effects" time="{duration}"/>
<testcase classname="global" name="./succeeding/koenig" time="{duration}"/>
<testcase classname="global" name="./succeeding/non-const==" time="{duration}"/>
<testcase classname="global" name="./succeeding/enum/bits" time="{duration}"/>
<testcase classname="global" name="./succeeding/boolean member" time="{duration}"/>
<testcase classname="./succeeding/unimplemented static bool" name="compare to true" time="{duration}"/>
<testcase classname="./succeeding/unimplemented static bool" name="compare to false" time="{duration}"/>
<testcase classname="./succeeding/unimplemented static bool" name="negation" time="{duration}"/>
<testcase classname="./succeeding/unimplemented static bool" name="double negation" time="{duration}"/>
<testcase classname="./succeeding/unimplemented static bool" name="direct" time="{duration}"/>
<testcase classname="global" name="./succeeding/SafeBool" time="{duration}"/>
<testcase classname="global" name="An expression with side-effects should only be evaluated once" time="{duration}"/>
<testcase classname="global" name="Operators at different namespace levels not hijacked by Koenig lookup" time="{duration}"/>
<testcase classname="global" name="Demonstrate that a non-const == is not used" time="{duration}"/>
<testcase classname="global" name="Test enum bit values" time="{duration}"/>
<testcase classname="global" name="boolean member" time="{duration}"/>
<testcase classname="(unimplemented) static bools can be evaluated" name="compare to true" time="{duration}"/>
<testcase classname="(unimplemented) static bools can be evaluated" name="compare to false" time="{duration}"/>
<testcase classname="(unimplemented) static bools can be evaluated" name="negation" time="{duration}"/>
<testcase classname="(unimplemented) static bools can be evaluated" name="double negation" time="{duration}"/>
<testcase classname="(unimplemented) static bools can be evaluated" name="direct" time="{duration}"/>
<testcase classname="global" name="Objects that evaluated in boolean contexts can be checked" time="{duration}"/>
<testcase classname="Assertions then sections" name="root" time="{duration}"/>
<testcase classname="Assertions then sections" name="A section" time="{duration}"/>
<testcase classname="Assertions then sections" name="A section/Another section" time="{duration}"/>
@ -563,18 +545,10 @@ TrickyTests.cpp:<line number>
Message from section one
Message from section two
Some information
Message from section one
Message from section two
Some information
Message from section one
Message from section two
Some information
hello
hello
</system-out>
<system-err>
An error
An error
An error
</system-err>
</testsuite>

292
projects/SelfTest/Baselines/xml.sw.approved.txt
View File

@ -1,6 +1,6 @@
<Catch name="CatchSelfTest">
<Group name="~_">
<TestCase name="./succeeding/Approx/simple">
<TestCase name="Some simple comparisons between doubles">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ApproxTests.cpp" >
<Original>
d == Approx( 1.23 )
@ -51,7 +51,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/Approx/epsilon">
<TestCase name="Approximate comparisons with different epsilons">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ApproxTests.cpp" >
<Original>
d != Approx( 1.231 )
@ -70,7 +70,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/Approx/float">
<TestCase name="Approximate comparisons with floats">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ApproxTests.cpp" >
<Original>
1.23f == Approx( 1.23f )
@ -89,7 +89,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/Approx/int">
<TestCase name="Approximate comparisons with ints">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ApproxTests.cpp" >
<Original>
1 == Approx( 1 )
@ -108,7 +108,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/Approx/mixed">
<TestCase name="Approximate comparisons with mixed numeric types">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ApproxTests.cpp" >
<Original>
1.0f == Approx( 1 )
@ -151,7 +151,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/Approx/custom">
<TestCase name="Use a custom approx">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ApproxTests.cpp" >
<Original>
d == approx( 1.23 )
@ -237,7 +237,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/TestClass/succeedingCase">
<TestCase name="A METHOD_AS_TEST_CASE based test run that succeeds">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ClassTests.cpp" >
<Original>
s == &quot;hello&quot;
@ -248,7 +248,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/TestClass/failingCase">
<TestCase name="A METHOD_AS_TEST_CASE based test run that fails">
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ClassTests.cpp" >
<Original>
s == &quot;world&quot;
@ -259,7 +259,7 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/Fixture/succeedingCase">
<TestCase name="A TEST_CASE_METHOD based test run that succeeds">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ClassTests.cpp" >
<Original>
m_a == 1
@ -270,7 +270,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/Fixture/failingCase">
<TestCase name="A TEST_CASE_METHOD based test run that fails">
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ClassTests.cpp" >
<Original>
m_a == 2
@ -281,7 +281,7 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/conditions/equality">
<TestCase name="Equality checks that should succeed">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ConditionTests.cpp" >
<Original>
data.int_seven == 7
@ -340,7 +340,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/conditions/equality">
<TestCase name="Equality checks that should fail]">
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ConditionTests.cpp" >
<Original>
data.int_seven == 6
@ -447,7 +447,7 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/conditions/inequality">
<TestCase name="Inequality checks that should succeed">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ConditionTests.cpp" >
<Original>
data.int_seven != 6
@ -538,7 +538,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/conditions/inequality">
<TestCase name="Inequality checks that should fails">
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ConditionTests.cpp" >
<Original>
data.int_seven != 7
@ -581,7 +581,7 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/conditions/ordered">
<TestCase name="Ordering comparison checks that should succeed">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ConditionTests.cpp" >
<Original>
data.int_seven &lt; 8
@ -720,7 +720,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/conditions/ordered">
<TestCase name="Ordering comparison checks that should fail">
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ConditionTests.cpp" >
<Original>
data.int_seven > 7
@ -875,7 +875,7 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/conditions/int literals">
<TestCase name="Comparisons with int literals don't warn when mixing signed/ unsigned">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ConditionTests.cpp" >
<Original>
i == 1
@ -982,7 +982,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/conditions//long_to_unsigned_x">
<TestCase name="comparisons between int variables">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ConditionTests.cpp" >
<Original>
long_var == unsigned_char_var
@ -1017,7 +1017,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/conditions/const ints to int literal">
<TestCase name="comparisons between const int variables">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ConditionTests.cpp" >
<Original>
unsigned_char_var == 1
@ -1052,7 +1052,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/conditions/negative ints">
<TestCase name="Comparisons between unsigned ints and negative signed ints match c++ standard behaviour">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ConditionTests.cpp" >
<Original>
( -1 > 2u )
@ -1103,7 +1103,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/conditions/computed ints">
<TestCase name="Comparisons between ints where one side is computed">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ConditionTests.cpp" >
<Original>
54 == 6*9
@ -1114,7 +1114,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/conditions/ptr">
<TestCase name="Pointers can be compared to null">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ConditionTests.cpp" >
<Original>
p == __null
@ -1181,7 +1181,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/conditions/not">
<TestCase name="'Not' checks that should succeed">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ConditionTests.cpp" >
<Original>
false == false
@ -1248,7 +1248,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/conditions/not">
<TestCase name="'Not' checks that should fail">
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ConditionTests.cpp" >
<Original>
false != false
@ -1315,7 +1315,7 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/exceptions/explicit">
<TestCase name="When checked exceptions are thrown they can be expected or unexpected">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ExceptionTests.cpp" >
<Original>
thisThrows()
@ -1342,7 +1342,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/exceptions/explicit">
<TestCase name="Expected exceptions that don't throw or unexpected exceptions fail the test">
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ExceptionTests.cpp" >
<Original>
thisThrows()
@ -1375,13 +1375,13 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/exceptions/implicit">
<TestCase name="When unchecked exceptions are thrown directly they are always failures">
<Exception filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ExceptionTests.cpp" >
unexpected exception
</Exception>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/exceptions/implicit/2">
<TestCase name="An unchecked exception reports the line of the last assertion">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ExceptionTests.cpp" >
<Original>
1 == 1
@ -1403,7 +1403,7 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/exceptions/implicit/3">
<TestCase name="When unchecked exceptions are thrown from sections they are always failures">
<Section name="section name">
<Exception filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ExceptionTests.cpp" >
unexpected exception
@ -1412,7 +1412,7 @@
</Section>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/exceptions/implicit/4">
<TestCase name="When unchecked exceptions are thrown from functions they are always failures">
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ExceptionTests.cpp" >
<Original>
thisThrows() == 0
@ -1426,16 +1426,16 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/exceptions/implicit">
<TestCase name="When unchecked exceptions are thrown, but caught, they do not affect the test">
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/exceptions/custom">
<TestCase name="Unexpected custom exceptions can be translated">
<Exception filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ExceptionTests.cpp" >
custom exception
</Exception>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/exceptions/custom/nothrow">
<TestCase name="Custom exceptions can be translated when testing for nothrow">
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ExceptionTests.cpp" >
<Original>
throwCustom()
@ -1449,7 +1449,7 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/exceptions/custom/throw">
<TestCase name="Custom exceptions can be translated when testing for throwing as something else">
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ExceptionTests.cpp" >
<Original>
throwCustom()
@ -1463,13 +1463,13 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/exceptions/custom/double">
<TestCase name="Unexpected exceptions can be translated">
<Exception filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ExceptionTests.cpp" >
3.14
</Exception>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/exceptions/notimplemented">
<TestCase name="NotImplemented exception">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/ExceptionTests.cpp" >
<Original>
thisFunctionNotImplemented( 7 )
@ -1480,7 +1480,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/generators/1">
<TestCase name="Generators over two ranges">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/GeneratorTests.cpp" >
<Original>
multiply( i, 2 ) == i*2
@ -2635,7 +2635,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/generators/2">
<TestCase name="Generator over a range of pairs">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/GeneratorTests.cpp" >
<Original>
i->first == i->second-1
@ -2654,7 +2654,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/message">
<TestCase name="INFO and WARN do not abort tests">
<Info>
this is a message
</Info>
@ -2663,10 +2663,10 @@
</Warning>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/succeed">
<TestCase name="SUCCEED counts as a test pass">
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/message/info/1">
<TestCase name="INFO gets logged on failure">
<Info>
this message should be logged
</Info>
@ -2683,7 +2683,7 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./mixed/message/info/2">
<TestCase name="INFO gets logged on failure, even if captured before successful assertions">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MessageTests.cpp" >
<Original>
a == 2
@ -2724,13 +2724,13 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/message/fail">
<TestCase name="FAIL aborts the test">
<Failure>
This is a failure
</Failure>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/message/sections">
<TestCase name="Output from all sections is reported">
<Section name="one">
<Failure>
Message from section one
@ -2745,7 +2745,7 @@
</Section>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/message/sections/stdout">
<TestCase name="Standard output from all sections is reported">
<Section name="one">
<OverallResults successes="0" failures="1"/>
</Section>
@ -2754,7 +2754,7 @@
</Section>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./mixed/message/scoped">
<TestCase name="SCOPED_INFO is reset for each loop">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MessageTests.cpp" >
<Original>
i &lt; 10
@ -2851,7 +2851,7 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/nofail">
<TestCase name="The NO_FAIL macro reports a failure but does not fail the test">
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MessageTests.cpp" >
<Original>
1 == 2
@ -2871,7 +2871,24 @@
</Failure>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/Misc/Sections">
<TestCase name="sends information to INFO">
<Info>
hi
</Info>
<Info>
i := 7
</Info>
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MessageTests.cpp" >
<Original>
false
</Original>
<Expanded>
false
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="random SECTION tests">
<Section name="s1" description="doesn't equal">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MiscTests.cpp" >
<Original>
@ -2904,7 +2921,7 @@
</Section>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/Misc/Sections/nested">
<TestCase name="nested SECTION tests">
<Section name="s1" description="doesn't equal">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MiscTests.cpp" >
<Original>
@ -2956,7 +2973,7 @@
</Section>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./mixed/Misc/Sections/nested2">
<TestCase name="more nested SECTION tests">
<Section name="s1" description="doesn't equal">
<OverallResults successes="0" failures="0"/>
</Section>
@ -3004,7 +3021,7 @@
</Section>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./Sections/nested/a/b">
<TestCase name="even more nested SECTION tests">
<Section name="c">
<OverallResults successes="0" failures="0"/>
</Section>
@ -3025,7 +3042,7 @@
</Section>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./mixed/Misc/Sections/loops">
<TestCase name="looped SECTION tests">
<Section name="s1" description="b is currently: 0">
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MiscTests.cpp" >
<Original>
@ -3039,7 +3056,7 @@
</Section>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./mixed/Misc/loops">
<TestCase name="looped tests">
<Info>
Testing if fib[0] (1) is even
</Info>
@ -3124,10 +3141,10 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/Misc/stdout,stderr">
<TestCase name="Sends stuff to stdout and stderr">
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/Misc/null strings">
<TestCase name="null strings">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MiscTests.cpp" >
<Original>
makeString( false ) != static_cast&lt;char*>(__null)
@ -3146,24 +3163,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/info">
<Info>
hi
</Info>
<Info>
i := 7
</Info>
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MiscTests.cpp" >
<Original>
false
</Original>
<Expanded>
false
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/checkedif">
<TestCase name="checkedIf">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MiscTests.cpp" >
<Original>
flag
@ -3182,7 +3182,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/checkedif">
<TestCase name="checkedIf, failing">
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MiscTests.cpp" >
<Original>
flag
@ -3201,7 +3201,7 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/checkedelse">
<TestCase name="checkedElse">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MiscTests.cpp" >
<Original>
flag
@ -3220,7 +3220,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/checkedelse">
<TestCase name="checkedElse, failing">
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MiscTests.cpp" >
<Original>
flag
@ -3239,7 +3239,7 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./misc/xmlentitycheck">
<TestCase name="xmlentitycheck">
<Section name="embedded xml" description="&lt;test>it should be possible to embed xml characters, such as &lt;, &quot; or &amp;, or even whole &lt;xml>documents&lt;/xml> within an attribute&lt;/test>">
<OverallResults successes="0" failures="1"/>
</Section>
@ -3248,7 +3248,7 @@
</Section>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./manual/onechar">
<TestCase name="send a single char to INFO">
<Info>
3
</Info>
@ -3262,7 +3262,7 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/atomic if">
<TestCase name="atomic if">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MiscTests.cpp" >
<Original>
x == 0
@ -3273,7 +3273,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/matchers">
<TestCase name="String matchers">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MiscTests.cpp" >
<Original>
testStringForMatching() Contains( &quot;string&quot; )
@ -3308,7 +3308,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/matchers/Contains">
<TestCase name="Contains string matcher">
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MiscTests.cpp" >
<Original>
testStringForMatching() Contains( &quot;not there&quot; )
@ -3319,7 +3319,7 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/matchers/StartsWith">
<TestCase name="StartsWith string matcher">
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MiscTests.cpp" >
<Original>
testStringForMatching() StartsWith( &quot;string&quot; )
@ -3330,7 +3330,7 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/matchers/EndsWith">
<TestCase name="EndsWith string matcher">
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MiscTests.cpp" >
<Original>
testStringForMatching() EndsWith( &quot;this&quot; )
@ -3341,7 +3341,7 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/matchers/Equals">
<TestCase name="Equals string matcher">
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MiscTests.cpp" >
<Original>
testStringForMatching() Equals( &quot;something else&quot; )
@ -3352,7 +3352,7 @@
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="string">
<TestCase name="Equals string matcher, with NULL">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MiscTests.cpp" >
<Original>
&quot;&quot; Equals(__null)
@ -3363,7 +3363,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/matchers/AllOf">
<TestCase name="AllOf matcher">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MiscTests.cpp" >
<Original>
testStringForMatching() AllOf( Catch::Contains( &quot;string&quot; ), Catch::Contains( &quot;abc&quot; ) )
@ -3374,7 +3374,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/matchers/AnyOf">
<TestCase name="AnyOf matcher">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MiscTests.cpp" >
<Original>
testStringForMatching() AnyOf( Catch::Contains( &quot;string&quot; ), Catch::Contains( &quot;not there&quot; ) )
@ -3393,7 +3393,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/matchers/Equals">
<TestCase name="Equals">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/MiscTests.cpp" >
<Original>
testStringForMatching() Equals( &quot;this string contains 'abc' as a substring&quot; )
@ -3447,7 +3447,7 @@
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="empty">
<TestCase name="An empty test with no assertions">
<OverallResult success="true"/>
</TestCase>
<TestCase name="Nice descriptive name">
@ -3667,7 +3667,7 @@
</Section>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/CatchSectionInfiniteLoop">
<TestCase name="A couple of nested sections followed by a failure">
<Failure>
to infinity and beyond
</Failure>
@ -3688,90 +3688,6 @@
</Failure>
<OverallResult success="false"/>
</TestCase>
<TestCase name="selftest/main">
<Section name="selftest/expected result" description="Tests do what they claim">
<OverallResults successes="0" failures="0"/>
</Section>
<Section name="selftest/expected result" description="Tests do what they claim">
<Section name="selftest/expected result/failing tests" description="Tests in the 'failing' branch fail">
<OverallResults successes="28" failures="0"/>
</Section>
<OverallResults successes="28" failures="0"/>
</Section>
<Section name="selftest/expected result" description="Tests do what they claim">
<Section name="selftest/expected result/succeeding tests" description="Tests in the 'succeeding' branch succeed">
<OverallResults successes="46" failures="0"/>
</Section>
<OverallResults successes="46" failures="0"/>
</Section>
<Section name="selftest/test counts" description="Number of test cases that run is fixed">
<OverallResults successes="0" failures="0"/>
</Section>
<Section name="selftest/test counts" description="Number of test cases that run is fixed">
<Section name="selftest/test counts/succeeding tests" description="Number of 'succeeding' tests is fixed">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/TestMain.cpp" >
<Original>
totals.assertions.passed == 298
</Original>
<Expanded>
298 == 298
</Expanded>
</Expression>
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/TestMain.cpp" >
<Original>
totals.assertions.failed == 0
</Original>
<Expanded>
0 == 0
</Expanded>
</Expression>
<OverallResults successes="2" failures="0"/>
</Section>
<OverallResults successes="2" failures="0"/>
</Section>
<Section name="selftest/test counts" description="Number of test cases that run is fixed">
<Section name="selftest/test counts/failing tests" description="Number of 'failing' tests is fixed">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/TestMain.cpp" >
<Original>
totals.assertions.passed == 2
</Original>
<Expanded>
2 == 2
</Expanded>
</Expression>
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/TestMain.cpp" >
<Original>
totals.assertions.failed == 77
</Original>
<Expanded>
77 == 77
</Expanded>
</Expression>
<OverallResults successes="2" failures="0"/>
</Section>
<OverallResults successes="2" failures="0"/>
</Section>
<OverallResult success="true"/>
</TestCase>
<TestCase name="meta/Misc/Sections">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/TestMain.cpp" >
<Original>
totals.assertions.passed == 2
</Original>
<Expanded>
2 == 2
</Expanded>
</Expression>
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/TestMain.cpp" >
<Original>
totals.assertions.failed == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="Process can be configured on command line">
<Section name="default - no arguments">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/TestMain.cpp" >
@ -6374,7 +6290,7 @@ there&quot;
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/Tricky/std::pair">
<TestCase name="Parsing a std::pair">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/TrickyTests.cpp" >
<Original>
(std::pair&lt;int, int>( 1, 2 )) == aNicePair
@ -6385,19 +6301,19 @@ there&quot;
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./inprogress/failing/Tricky/trailing expression">
<TestCase name="Where the is more to the expression after the RHS[failing]">
<Warning>
Uncomment the code in this test to check that it gives a sensible compiler error
</Warning>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./inprogress/failing/Tricky/compound lhs">
<TestCase name="Where the LHS is not a simple value[failing]">
<Warning>
Uncomment the code in this test to check that it gives a sensible compiler error
</Warning>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/Tricky/non streamable type">
<TestCase name="A failing expression with a non streamable type is still captured[failing]">
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/TrickyTests.cpp" >
<Original>
&amp;o1 == &amp;o2
@ -6416,7 +6332,7 @@ there&quot;
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/string literals">
<TestCase name="string literals of different sizes can be compared[failing]">
<Expression success="false" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/TrickyTests.cpp" >
<Original>
std::string( &quot;first&quot; ) == &quot;second&quot;
@ -6427,7 +6343,7 @@ there&quot;
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/side-effects">
<TestCase name="An expression with side-effects should only be evaluated once">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/TrickyTests.cpp" >
<Original>
i++ == 7
@ -6446,7 +6362,7 @@ there&quot;
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/koenig">
<TestCase name="Operators at different namespace levels not hijacked by Koenig lookup">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/TrickyTests.cpp" >
<Original>
0x<hex digits> == o
@ -6457,7 +6373,7 @@ there&quot;
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/non-const==">
<TestCase name="Demonstrate that a non-const == is not used">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/TrickyTests.cpp" >
<Original>
t == 1u
@ -6468,7 +6384,7 @@ there&quot;
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/enum/bits">
<TestCase name="Test enum bit values">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/TrickyTests.cpp" >
<Original>
0x<hex digits> == bit30and31
@ -6479,7 +6395,7 @@ there&quot;
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/boolean member">
<TestCase name="boolean member">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/TrickyTests.cpp" >
<Original>
obj.prop != __null
@ -6490,7 +6406,7 @@ there&quot;
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/unimplemented static bool">
<TestCase name="(unimplemented) static bools can be evaluated">
<Section name="compare to true">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/TrickyTests.cpp" >
<Original>
@ -6572,7 +6488,7 @@ there&quot;
</Section>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/SafeBool">
<TestCase name="Objects that evaluated in boolean contexts can be checked">
<Expression success="true" filename="/Users/philnash/Dev/OSS/Catch/projects/SelfTest/TrickyTests.cpp" >
<Original>
True
@ -7482,7 +7398,7 @@ there&quot;
</Section>
<OverallResult success="true"/>
</TestCase>
<OverallResults successes="663" failures="109"/>
<OverallResults successes="583" failures="109"/>
</Group>
<OverallResults successes="663" failures="109"/>
<OverallResults successes="583" failures="109"/>
</Catch>

8
projects/SelfTest/ClassTests.cpp
View File

@ -31,8 +31,8 @@ namespace
}
METHOD_AS_TEST_CASE( TestClass::succeedingCase, "./succeeding/TestClass/succeedingCase", "A method based test run that succeeds [class]" )
METHOD_AS_TEST_CASE( TestClass::failingCase, "./failing/TestClass/failingCase", "A method based test run that fails [class]" )
METHOD_AS_TEST_CASE( TestClass::succeedingCase, "A METHOD_AS_TEST_CASE based test run that succeeds", "[class]" )
METHOD_AS_TEST_CASE( TestClass::failingCase, "A METHOD_AS_TEST_CASE based test run that fails", "[.][class][failing]" )
struct Fixture
@ -42,7 +42,7 @@ struct Fixture
int m_a;
};
TEST_CASE_METHOD( Fixture, "./succeeding/Fixture/succeedingCase", "A method based test run that succeeds [class]" )
TEST_CASE_METHOD( Fixture, "A TEST_CASE_METHOD based test run that succeeds", "[class]" )
{
REQUIRE( m_a == 1 );
}
@ -50,7 +50,7 @@ TEST_CASE_METHOD( Fixture, "./succeeding/Fixture/succeedingCase", "A method base
// We should be able to write our tests within a different namespace
namespace Inner
{
TEST_CASE_METHOD( Fixture, "./failing/Fixture/failingCase", "A method based test run that fails [class]" )
TEST_CASE_METHOD( Fixture, "A TEST_CASE_METHOD based test run that fails", "[.][class][failing]" )
{
REQUIRE( m_a == 2 );
}

42
projects/SelfTest/ConditionTests.cpp
View File

@ -43,8 +43,7 @@ struct TestDef {
// This allows us to see all results, even if an earlier check fails
// Equality tests
TEST_CASE( "./succeeding/conditions/equality",
"Equality checks that should succeed" )
TEST_CASE( "Equality checks that should succeed", "" )
{
TestDef td;
@ -63,8 +62,7 @@ TEST_CASE( "./succeeding/conditions/equality",
REQUIRE( x == Approx( 1.3 ) );
}
TEST_CASE( "./failing/conditions/equality",
"Equality checks that should fail" )
TEST_CASE( "Equality checks that should fail]", "[.][failing]" )
{
TestData data;
@ -85,8 +83,7 @@ TEST_CASE( "./failing/conditions/equality",
CHECK( x == Approx( 1.301 ) );
}
TEST_CASE( "./succeeding/conditions/inequality",
"Inequality checks that should succeed" )
TEST_CASE( "Inequality checks that should succeed", "" )
{
TestData data;
@ -103,8 +100,7 @@ TEST_CASE( "./succeeding/conditions/inequality",
REQUIRE( data.str_hello.size() != 6 );
}
TEST_CASE( "./failing/conditions/inequality",
"Inequality checks that should fails" )
TEST_CASE( "Inequality checks that should fails", "[.][failing]" )
{
TestData data;
@ -116,8 +112,7 @@ TEST_CASE( "./failing/conditions/inequality",
}
// Ordering comparison tests
TEST_CASE( "./succeeding/conditions/ordered",
"Ordering comparison checks that should succeed" )
TEST_CASE( "Ordering comparison checks that should succeed", "" )
{
TestData data;
@ -144,8 +139,7 @@ TEST_CASE( "./succeeding/conditions/ordered",
REQUIRE( data.str_hello > "a" );
}
TEST_CASE( "./failing/conditions/ordered",
"Ordering comparison checks that should fail" )
TEST_CASE( "Ordering comparison checks that should fail", "[.][failing]" )
{
TestData data;
@ -175,8 +169,7 @@ TEST_CASE( "./failing/conditions/ordered",
}
// Comparisons with int literals
TEST_CASE( "./succeeding/conditions/int literals",
"Comparisons with int literals don't warn when mixing signed/ unsigned" )
TEST_CASE( "Comparisons with int literals don't warn when mixing signed/ unsigned", "" )
{
int i = 1;
unsigned int ui = 2;
@ -214,8 +207,7 @@ TEST_CASE( "./succeeding/conditions/int literals",
#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
#endif
TEST_CASE( "./succeeding/conditions//long_to_unsigned_x",
"comparisons between int variables" )
TEST_CASE( "comparisons between int variables", "" )
{
long long_var = 1L;
unsigned char unsigned_char_var = 1;
@ -229,8 +221,7 @@ TEST_CASE( "./succeeding/conditions//long_to_unsigned_x",
REQUIRE( long_var == unsigned_long_var );
}
TEST_CASE( "./succeeding/conditions/const ints to int literal",
"comparisons between const int variables" )
TEST_CASE( "comparisons between const int variables", "" )
{
const unsigned char unsigned_char_var = 1;
const unsigned short unsigned_short_var = 1;
@ -243,8 +234,7 @@ TEST_CASE( "./succeeding/conditions/const ints to int literal",
REQUIRE( unsigned_long_var == 1 );
}
TEST_CASE( "./succeeding/conditions/negative ints",
"Comparisons between unsigned ints and negative signed ints match c++ standard behaviour" )
TEST_CASE( "Comparisons between unsigned ints and negative signed ints match c++ standard behaviour", "" )
{
CHECK( ( -1 > 2u ) );
CHECK( -1 > 2u );
@ -266,8 +256,7 @@ struct Ex
T operator * ( const T& ) const { return T(); }
};
TEST_CASE( "./succeeding/conditions/computed ints",
"Comparisons between ints where one side is computed" )
TEST_CASE( "Comparisons between ints where one side is computed", "" )
{
CHECK( 54 == 6*9 );
}
@ -279,8 +268,7 @@ TEST_CASE( "./succeeding/conditions/computed ints",
inline const char* returnsConstNull(){ return NULL; }
inline char* returnsNull(){ return NULL; }
TEST_CASE( "./succeeding/conditions/ptr",
"Pointers can be compared to null" )
TEST_CASE( "Pointers can be compared to null", "" )
{
TestData* p = NULL;
TestData* pNULL = NULL;
@ -312,8 +300,7 @@ TEST_CASE( "./succeeding/conditions/ptr",
// is detected and a warning issued.
// An alternative form of the macros (CHECK_FALSE and REQUIRE_FALSE) can be used instead to capture
// the operand value.
TEST_CASE( "./succeeding/conditions/not",
"'Not' checks that should succeed" )
TEST_CASE( "'Not' checks that should succeed", "" )
{
bool falseValue = false;
@ -329,8 +316,7 @@ TEST_CASE( "./succeeding/conditions/not",
REQUIRE_FALSE( 1 == 2 );
}
TEST_CASE( "./failing/conditions/not",
"'Not' checks that should fail" )
TEST_CASE( "'Not' checks that should fail", "[.][failing]" )
{
bool trueValue = true;

24
projects/SelfTest/ExceptionTests.cpp
View File

@ -28,33 +28,33 @@ namespace
}
}
TEST_CASE( "./succeeding/exceptions/explicit", "When checked exceptions are thrown they can be expected or unexpected" )
TEST_CASE( "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( "./failing/exceptions/explicit", "When checked exceptions are thrown they can be expected or unexpected" )
TEST_CASE( "Expected exceptions that don't throw or unexpected exceptions fail the test", "[.][failing]" )
{
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" )
TEST_CASE( "When unchecked exceptions are thrown directly they are always failures", "[.][failing]" )
{
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" )
TEST_CASE( "An unchecked exception reports the line of the last assertion", "[.][failing]" )
{
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" )
TEST_CASE( "When unchecked exceptions are thrown from sections they are always failures", "[.][failing]" )
{
SECTION( "section name", "" )
{
@ -63,12 +63,12 @@ TEST_CASE( "./failing/exceptions/implicit/3", "When unchecked exceptions are thr
}
}
TEST_CASE( "./failing/exceptions/implicit/4", "When unchecked exceptions are thrown they are always failures" )
TEST_CASE( "When unchecked exceptions are thrown from functions they are always failures", "[.][failing]" )
{
CHECK( thisThrows() == 0 );
}
TEST_CASE( "./succeeding/exceptions/implicit", "When unchecked exceptions are thrown, but caught, they do not affect the test" )
TEST_CASE( "When unchecked exceptions are thrown, but caught, they do not affect the test", "" )
{
try
{
@ -105,7 +105,7 @@ CATCH_TRANSLATE_EXCEPTION( double& ex )
return Catch::toString( ex );
}
TEST_CASE( "./failing/exceptions/custom", "Unexpected custom exceptions can be translated" )
TEST_CASE("Unexpected custom exceptions can be translated", "[.][failing]" )
{
if( Catch::isTrue( true ) )
throw CustomException( "custom exception" );
@ -116,18 +116,18 @@ inline void throwCustom() {
throw CustomException( "custom exception - not std" );
}
TEST_CASE( "./failing/exceptions/custom/nothrow", "Custom exceptions can be translated when testing for nothrow" )
TEST_CASE( "Custom exceptions can be translated when testing for nothrow", "[.][failing]" )
{
REQUIRE_NOTHROW( throwCustom() );
}
TEST_CASE( "./failing/exceptions/custom/throw", "Custom exceptions can be translated when testing for throwing as something else" )
TEST_CASE( "Custom exceptions can be translated when testing for throwing as something else", "[.][failing]" )
{
REQUIRE_THROWS_AS( throwCustom(), std::exception );
}
TEST_CASE( "./failing/exceptions/custom/double", "Unexpected custom exceptions can be translated" )
TEST_CASE( "Unexpected exceptions can be translated", "[.][failing]" )
{
if( Catch::isTrue( true ) )
throw double( 3.14 );
@ -137,7 +137,7 @@ inline int thisFunctionNotImplemented( int ) {
CATCH_NOT_IMPLEMENTED;
}
TEST_CASE( "./succeeding/exceptions/notimplemented", "" )
TEST_CASE( "NotImplemented exception", "" )
{
REQUIRE_THROWS( thisFunctionNotImplemented( 7 ) );
}

4
projects/SelfTest/GeneratorTests.cpp
View File

@ -16,7 +16,7 @@ inline int multiply( int a, int b )
return a*b;
}
CATCH_TEST_CASE( "./succeeding/generators/1", "Generators over two ranges" )
CATCH_TEST_CASE( "Generators over two ranges", "[generators]" )
{
using namespace Catch::Generators;
@ -29,7 +29,7 @@ CATCH_TEST_CASE( "./succeeding/generators/1", "Generators over two ranges" )
struct IntPair { int first, second; };
CATCH_TEST_CASE( "./succeeding/generators/2", "Generator over a range of pairs" )
CATCH_TEST_CASE( "Generator over a range of pairs", "[generators]" )
{
using namespace Catch::Generators;

31
projects/SelfTest/MessageTests.cpp
View File

@ -8,17 +8,17 @@
#include "catch.hpp"
TEST_CASE( "./succeeding/message", "INFO and WARN do not abort tests" )
TEST_CASE( "INFO and WARN do not abort tests", "[messages]" )
{
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" )
TEST_CASE( "SUCCEED counts as a test pass" )
{
SUCCEED( "this is a " << "success" );
}
TEST_CASE( "./failing/message/info/1", "INFO gets logged on failure" )
TEST_CASE( "INFO gets logged on failure", "[failing][messages][.]" )
{
INFO( "this message should be logged" );
INFO( "so should this" );
@ -26,7 +26,7 @@ TEST_CASE( "./failing/message/info/1", "INFO gets logged on failure" )
REQUIRE( a == 1 );
}
TEST_CASE( "./mixed/message/info/2", "INFO gets logged on failure" )
TEST_CASE( "INFO gets logged on failure, even if captured before successful assertions", "[failing][messages][.]" )
{
INFO( "this message may be logged later" );
int a = 2;
@ -45,13 +45,13 @@ TEST_CASE( "./mixed/message/info/2", "INFO gets logged on failure" )
CHECK( a == 2 );
}
TEST_CASE( "./failing/message/fail", "FAIL aborts the test" )
TEST_CASE( "FAIL aborts the test", "[failing][messages][.]" )
{
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" )
TEST_CASE( "Output from all sections is reported", "[failing][messages][.]" )
{
SECTION( "one", "" )
{
@ -64,7 +64,7 @@ TEST_CASE( "./failing/message/sections", "Output from all sections is reported"
}
}
TEST_CASE( "./succeeding/message/sections/stdout", "Output from all sections is reported" )
TEST_CASE( "Standard output from all sections is reported", "[messages]" )
{
SECTION( "one", "" )
{
@ -77,7 +77,7 @@ TEST_CASE( "./succeeding/message/sections/stdout", "Output from all sections is
}
}
TEST_CASE( "./mixed/message/scoped", "" )
TEST_CASE( "SCOPED_INFO is reset for each loop", "[messages][failing][.]" )
{
for( int i=0; i<100; i++ )
{
@ -87,16 +87,25 @@ TEST_CASE( "./mixed/message/scoped", "" )
}
}
TEST_CASE( "./succeeding/nofail", "The NO_FAIL macro reports a failure but does not fail the test" )
TEST_CASE( "The NO_FAIL macro reports a failure but does not fail the test", "[messages]" )
{
CHECK_NOFAIL( 1 == 2 );
}
TEST_CASE( "just info", "[info][isolated info][.]" )
TEST_CASE( "just info", "[info][isolated info][messages]" )
{
INFO( "this should never be seen" );
}
TEST_CASE( "just failure", "[fail][isolated info][.]" )
TEST_CASE( "just failure", "[fail][isolated info][.][messages]" )
{
FAIL( "Previous info should not be seen" );
}
TEST_CASE( "sends information to INFO", "[.][failing]" )
{
INFO( "hi" );
int i = 7;
CAPTURE( i );
REQUIRE( false );
}

59
projects/SelfTest/MiscTests.cpp
View File

@ -11,7 +11,7 @@
#include <iostream>
TEST_CASE( "./succeeding/Misc/Sections", "random SECTION tests" )
TEST_CASE( "random SECTION tests", "[.][sections][failing]" )
{
int a = 1;
int b = 2;
@ -28,7 +28,7 @@ TEST_CASE( "./succeeding/Misc/Sections", "random SECTION tests" )
}
}
TEST_CASE( "./succeeding/Misc/Sections/nested", "nested SECTION tests" )
TEST_CASE( "nested SECTION tests", "[.][sections][failing]" )
{
int a = 1;
int b = 2;
@ -45,7 +45,7 @@ TEST_CASE( "./succeeding/Misc/Sections/nested", "nested SECTION tests" )
}
}
TEST_CASE( "./mixed/Misc/Sections/nested2", "nested SECTION tests" )
TEST_CASE( "more nested SECTION tests", "[sections][failing][.]" )
{
int a = 1;
int b = 2;
@ -68,7 +68,7 @@ TEST_CASE( "./mixed/Misc/Sections/nested2", "nested SECTION tests" )
}
}
TEST_CASE( "./Sections/nested/a/b", "nested SECTION tests" )
TEST_CASE( "even more nested SECTION tests", "[sections]" )
{
SECTION( "c", "" )
{
@ -86,7 +86,7 @@ TEST_CASE( "./Sections/nested/a/b", "nested SECTION tests" )
}
}
TEST_CASE( "./mixed/Misc/Sections/loops", "looped SECTION tests" )
TEST_CASE( "looped SECTION tests", "[.][failing][sections]" )
{
int a = 1;
@ -101,7 +101,7 @@ TEST_CASE( "./mixed/Misc/Sections/loops", "looped SECTION tests" )
}
}
TEST_CASE( "./mixed/Misc/loops", "looped tests" )
TEST_CASE( "looped tests", "[.][failing]" )
{
static const int fib[] = { 1, 1, 2, 3, 5, 8, 13, 21 };
@ -112,7 +112,7 @@ TEST_CASE( "./mixed/Misc/loops", "looped tests" )
}
}
TEST_CASE( "./succeeding/Misc/stdout,stderr", "Sends stuff to stdout and stderr" )
TEST_CASE( "Sends stuff to stdout and stderr", "" )
{
std::cout << "Some information" << std::endl;
@ -124,19 +124,12 @@ inline const char* makeString( bool makeNull )
return makeNull ? NULL : "valid string";
}
TEST_CASE( "./succeeding/Misc/null strings", "" )
TEST_CASE( "null strings", "" )
{
REQUIRE( makeString( false ) != static_cast<char*>(NULL));
REQUIRE( makeString( true ) == static_cast<char*>(NULL));
}
TEST_CASE( "./failing/info", "sends information to INFO" )
{
INFO( "hi" );
int i = 7;
CAPTURE( i );
REQUIRE( false );
}
inline bool testCheckedIf( bool flag )
{
@ -146,12 +139,12 @@ inline bool testCheckedIf( bool flag )
return false;
}
TEST_CASE( "./succeeding/checkedif", "" )
TEST_CASE( "checkedIf", "" )
{
REQUIRE( testCheckedIf( true ) );
}
TEST_CASE( "./failing/checkedif", "" )
TEST_CASE( "checkedIf, failing", "[failing][.]" )
{
REQUIRE( testCheckedIf( false ) );
}
@ -164,17 +157,17 @@ inline bool testCheckedElse( bool flag )
return true;
}
TEST_CASE( "./succeeding/checkedelse", "" )
TEST_CASE( "checkedElse", "" )
{
REQUIRE( testCheckedElse( true ) );
}
TEST_CASE( "./failing/checkedelse", "" )
TEST_CASE( "checkedElse, failing", "[failing][.]" )
{
REQUIRE( testCheckedElse( false ) );
}
TEST_CASE( "./misc/xmlentitycheck", "" )
TEST_CASE( "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>" )
{
@ -186,13 +179,13 @@ TEST_CASE( "./misc/xmlentitycheck", "" )
}
}
TEST_CASE( "./manual/onechar", "send a single char to INFO" )
TEST_CASE( "send a single char to INFO", "[failing][.]" )
{
INFO(3);
REQUIRE(false);
}
TEST_CASE("./succeeding/atomic if", "")
TEST_CASE( "atomic if", "[failing][0]")
{
size_t x = 0;
@ -207,7 +200,7 @@ inline const char* testStringForMatching()
return "this string contains 'abc' as a substring";
}
TEST_CASE("./succeeding/matchers", "")
TEST_CASE("String matchers", "[matchers]" )
{
REQUIRE_THAT( testStringForMatching(), Contains( "string" ) );
CHECK_THAT( testStringForMatching(), Contains( "abc" ) );
@ -216,40 +209,40 @@ TEST_CASE("./succeeding/matchers", "")
CHECK_THAT( testStringForMatching(), EndsWith( "substring" ) );
}
TEST_CASE("./failing/matchers/Contains", "")
TEST_CASE("Contains string matcher", "[.][failing][matchers]")
{
CHECK_THAT( testStringForMatching(), Contains( "not there" ) );
}
TEST_CASE("./failing/matchers/StartsWith", "")
TEST_CASE("StartsWith string matcher", "[.][failing][matchers]")
{
CHECK_THAT( testStringForMatching(), StartsWith( "string" ) );
}
TEST_CASE("./failing/matchers/EndsWith", "")
TEST_CASE("EndsWith string matcher", "[.][failing][matchers]")
{
CHECK_THAT( testStringForMatching(), EndsWith( "this" ) );
}
TEST_CASE("./failing/matchers/Equals", "")
TEST_CASE("Equals string matcher", "[.][failing][matchers]")
{
CHECK_THAT( testStringForMatching(), Equals( "something else" ) );
}
TEST_CASE("string", "Equals with NULL")
TEST_CASE("Equals string matcher, with NULL", "[matchers]")
{
REQUIRE_THAT("", Equals(NULL));
}
TEST_CASE("./succeeding/matchers/AllOf", "")
TEST_CASE("AllOf matcher", "[matchers]")
{
CHECK_THAT( testStringForMatching(), AllOf( Catch::Contains( "string" ), Catch::Contains( "abc" ) ) );
}
TEST_CASE("./succeeding/matchers/AnyOf", "")
TEST_CASE("AnyOf matcher", "[matchers]")
{
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", "")
TEST_CASE("Equals", "[matchers]")
{
CHECK_THAT( testStringForMatching(), Equals( "this string contains 'abc' as a substring" ) );
}
@ -268,7 +261,7 @@ TEST_CASE( "Factorials are computed", "[factorial]" ) {
REQUIRE( Factorial(10) == 3628800 );
}
TEST_CASE( "empty", "An empty test with no assertions" )
TEST_CASE( "An empty test with no assertions", "[empty]" )
{
}
@ -333,7 +326,7 @@ TEST_CASE( "vectors can be sized and resized", "[vector]" ) {
}
// https://github.com/philsquared/Catch/issues/166
TEST_CASE("./failing/CatchSectionInfiniteLoop", "")
TEST_CASE("A couple of nested sections followed by a failure", "[failing][.]")
{
SECTION("Outer", "")
SECTION("Inner", "")

46
projects/SelfTest/TestMain.cpp
View File

@ -13,52 +13,6 @@
#include "internal/catch_text.h"
#include "internal/catch_console_colour.hpp"
TEST_CASE( "selftest/main", "Runs all Catch self tests and checks their results" ) {
using namespace Catch;
///////////////////////////////////////////////////////////////////////////
SECTION( "selftest/expected result",
"Tests do what they claim" ) {
SECTION( "selftest/expected result/failing tests",
"Tests in the 'failing' branch fail" ) {
MetaTestRunner::runMatching( "./failing/*", MetaTestRunner::Expected::ToFail, 0, 2 );
}
SECTION( "selftest/expected result/succeeding tests",
"Tests in the 'succeeding' branch succeed" ) {
MetaTestRunner::runMatching( "./succeeding/*", MetaTestRunner::Expected::ToSucceed, 1, 2 );
}
}
///////////////////////////////////////////////////////////////////////////
SECTION( "selftest/test counts",
"Number of test cases that run is fixed" ) {
EmbeddedRunner runner;
SECTION( "selftest/test counts/succeeding tests",
"Number of 'succeeding' tests is fixed" ) {
Totals totals = runner.runMatching( "./succeeding/*", 0, 2 );
CHECK( totals.assertions.passed == 298 );
CHECK( totals.assertions.failed == 0 );
}
SECTION( "selftest/test counts/failing tests",
"Number of 'failing' tests is fixed" ) {
Totals totals = runner.runMatching( "./failing/*", 1, 2 );
CHECK( totals.assertions.passed == 2 );
CHECK( totals.assertions.failed == 77 );
}
}
}
TEST_CASE( "meta/Misc/Sections", "looped tests" ) {
Catch::EmbeddedRunner runner;
Catch::Totals totals = runner.runMatching( "./mixed/Misc/Sections/nested2", 0, 1 );
CHECK( totals.assertions.passed == 2 );
CHECK( totals.assertions.failed == 1 );
}
#ifdef __clang__
#pragma clang diagnostic ignored "-Wweak-vtables"

64
projects/SelfTest/TrickyTests.cpp
View File

@ -27,8 +27,8 @@ namespace Catch
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"./succeeding/Tricky/std::pair",
"Parsing a std::pair"
"Parsing a std::pair",
"[Tricky][std::pair]"
)
{
std::pair<int, int> aNicePair( 1, 2 );
@ -39,8 +39,8 @@ TEST_CASE
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"./inprogress/failing/Tricky/trailing expression",
"Where the is more to the expression after the RHS"
"Where the is more to the expression after the RHS[failing]",
"[Tricky][failing][.]"
)
{
// int a = 1, b = 2;
@ -50,8 +50,8 @@ TEST_CASE
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"./inprogress/failing/Tricky/compound lhs",
"Where the LHS is not a simple value"
"Where the LHS is not a simple value[failing]",
"[Tricky][failing][.]"
)
{
/*
@ -76,8 +76,8 @@ struct Opaque
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"./failing/Tricky/non streamable type",
"A failing expression with a non streamable type is still captured"
"A failing expression with a non streamable type is still captured[failing]",
"[Tricky][failing][.]"
)
{
@ -92,8 +92,8 @@ TEST_CASE
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"./failing/string literals",
"string literals of different sizes can be compared"
"string literals of different sizes can be compared[failing]",
"[Tricky][failing][.]"
)
{
REQUIRE( std::string( "first" ) == "second" );
@ -103,8 +103,8 @@ TEST_CASE
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"./succeeding/side-effects",
"An expression with side-effects should only be evaluated once"
"An expression with side-effects should only be evaluated once",
"[Tricky]"
)
{
int i = 7;
@ -151,8 +151,8 @@ inline bool operator==(const B::Y& lhs, const A::X& rhs)
/* This, currently, does not compile with LLVM
TEST_CASE
(
"./succeeding/koenig",
"Operators at different namespace levels not hijacked by Koenig lookup"
"[Tricky]"
)
{
A::X x;
@ -171,8 +171,8 @@ namespace ObjectWithConversions
///////////////////////////////////////////////////////////////////////////////
TEST_CASE
(
"./succeeding/koenig",
"Operators at different namespace levels not hijacked by Koenig lookup"
"Operators at different namespace levels not hijacked by Koenig lookup",
"[Tricky]"
)
{
Object o;
@ -199,7 +199,7 @@ namespace ObjectWithNonConstEqualityOperator
unsigned int m_value;
};
TEST_CASE("./succeeding/non-const==", "Demonstrate that a non-const == is not used")
TEST_CASE("Demonstrate that a non-const == is not used", "[Tricky]" )
{
Test t( 1 );
REQUIRE( t == 1u );
@ -212,7 +212,7 @@ namespace EnumBitFieldTests
bit30 = 0x40000000, bit31 = 0x80000000,
bit30and31 = 0xc0000000};
TEST_CASE("./succeeding/enum/bits", "Test enum bit values")
TEST_CASE( "Test enum bit values", "[Tricky]" )
{
REQUIRE( 0xc0000000 == bit30and31 );
}
@ -226,7 +226,7 @@ struct Obj
int* prop;
};
TEST_CASE("./succeeding/boolean member", "")
TEST_CASE("boolean member", "[Tricky]")
{
Obj obj;
REQUIRE( obj.prop != NULL );
@ -238,14 +238,14 @@ TEST_CASE("./succeeding/boolean member", "")
// struct it is declared in - but when evaluating it in a deduced
// context it appears to require the extra definition.
// The issue was fixed by adding bool overloads to bypass the
// templates that were deduce it.
// templates that were there to deduce it.
template <bool B>
struct is_true
{
static const bool value = B;
};
TEST_CASE( "./succeeding/unimplemented static bool", "static bools can be evaluated" )
TEST_CASE( "(unimplemented) static bools can be evaluated", "[Tricky]" )
{
SECTION("compare to true","")
{
@ -277,11 +277,11 @@ TEST_CASE( "./succeeding/unimplemented static bool", "static bools can be evalua
// Uncomment these tests to produce an error at test registration time
/*
TEST_CASE( "./sameName", "Tests with the same name are not allowed" )
TEST_CASE( "Tests with the same name are not allowed", "[Tricky]" )
{
}
TEST_CASE( "./sameName", "Tests with the same name are not allowed" )
TEST_CASE( "Tests with the same name are not allowed", "[Tricky]" )
{
}
@ -298,7 +298,7 @@ struct Boolable
bool m_value;
};
TEST_CASE( "./succeeding/SafeBool", "Objects that evaluated in boolean contexts can be checked")
TEST_CASE( "Objects that evaluated in boolean contexts can be checked", "[Tricky][SafeBool]" )
{
Boolable True( true );
Boolable False( false );
@ -308,7 +308,7 @@ TEST_CASE( "./succeeding/SafeBool", "Objects that evaluated in boolean contexts
CHECK_FALSE( False );
}
TEST_CASE( "Assertions then sections", "" )
TEST_CASE( "Assertions then sections", "[Tricky]" )
{
// This was causing a failure due to the way the console reporter was handling
// the current section
@ -335,7 +335,7 @@ struct Awkward
operator int() const { return 7; }
};
TEST_CASE( "non streamable - with conv. op", "" )
TEST_CASE( "non streamable - with conv. op", "[Tricky]" )
{
Awkward awkward;
std::string s = Catch::toString( awkward );
@ -346,7 +346,7 @@ inline void foo() {}
typedef void (*fooptr_t)();
TEST_CASE( "Comparing function pointers", "[function pointer]" )
TEST_CASE( "Comparing function pointers", "[Tricky][function pointer]" )
{
// This was giving a warning in VS2010
// #179
@ -358,7 +358,7 @@ TEST_CASE( "Comparing function pointers", "[function pointer]" )
class ClassName {};
TEST_CASE( "pointer to class", "" )
TEST_CASE( "pointer to class", "[Tricky]" )
{
ClassName *p = 0;
REQUIRE( p == 0 );
@ -368,7 +368,7 @@ TEST_CASE( "pointer to class", "" )
#include <memory>
TEST_CASE( "null_ptr", "" )
TEST_CASE( "null_ptr", "[Tricky]" )
{
std::unique_ptr<int> ptr;
REQUIRE(ptr.get() == nullptr);
@ -376,7 +376,7 @@ TEST_CASE( "null_ptr", "" )
#endif
TEST_CASE( "X/level/0/a", "" ) { SUCCEED(""); }
TEST_CASE( "X/level/0/b", "[fizz]" ) { SUCCEED(""); }
TEST_CASE( "X/level/1/a", "" ) { SUCCEED(""); }
TEST_CASE( "X/level/1/b", "" ) { SUCCEED("");}
TEST_CASE( "X/level/0/a", "[Tricky]" ) { SUCCEED(""); }
TEST_CASE( "X/level/0/b", "[Tricky][fizz]" ){ SUCCEED(""); }
TEST_CASE( "X/level/1/a", "[Tricky]" ) { SUCCEED(""); }
TEST_CASE( "X/level/1/b", "[Tricky]" ) { SUCCEED(""); }

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

@ -145,9 +145,6 @@
<ClInclude Include="..\..\..\..\include\reporters\catch_reporter_junit.hpp" />
<ClInclude Include="..\..\..\..\include\reporters\catch_reporter_xml.hpp" />
</ItemGroup>
<ItemGroup>
<None Include="ReadMe.txt" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>