3rd-party/catch2
1
0
Fork 0
mirror of https://github.com/catchorg/Catch2.git synced 2024-11-09 15:49:53 +01:00
Code Issues Packages Projects Releases Wiki Activity
eac51f38bd
catch2/projects/SelfTest/Baselines/approvedResults.txt
Phil Nash eac51f38bd Fix for long headers
2012-12-13 12:57:49 +00:00

7668 lines
226 KiB
Plaintext
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

-- Started testing: 'CatchSelfTest' ----------------------------
-- Group: '~dummy' ---------------------------------------------
-- Test case: './succeeding/Approx/simple' ---------------------
ApproxTests.cpp:20:
d == Approx( 1.23 ) succeeded for: 1.23 == Approx( 1.23 )
line 21:
d != Approx( 1.22 ) succeeded for: 1.23 != Approx( 1.22 )
line 22:
d != Approx( 1.24 ) succeeded for: 1.23 != Approx( 1.24 )
line 24:
Approx( d ) == 1.23 succeeded for: Approx( 1.23 ) == 1.23
line 25:
Approx( d ) != 1.22 succeeded for: Approx( 1.23 ) != 1.22
line 26:
Approx( d ) != 1.24 succeeded for: Approx( 1.23 ) != 1.24
----------------------------------------------------------------
Summary for test case './succeeding/Approx/simple':
All tests passed (6 assertions in 1 test case)
-- Test case: './succeeding/Approx/epsilon' --------------------
ApproxTests.cpp:38:
d != Approx( 1.231 ) succeeded for: 1.23 != Approx( 1.231 )
line 39:
d == Approx( 1.231 ).epsilon( 0.1 ) succeeded for: 1.23 == Approx( 1.231 )
----------------------------------------------------------------
Summary for test case './succeeding/Approx/epsilon':
All tests passed (2 assertions in 1 test case)
-- Test case: './succeeding/Approx/float' ----------------------
ApproxTests.cpp:49:
1.23f == Approx( 1.23f ) succeeded for: 1.23 == Approx( 1.23 )
line 50:
0.0f == Approx( 0.0f ) succeeded for: 0 == Approx( 0 )
----------------------------------------------------------------
Summary for test case './succeeding/Approx/float':
All tests passed (2 assertions in 1 test case)
-- Test case: './succeeding/Approx/int' ------------------------
ApproxTests.cpp:60:
1 == Approx( 1 ) succeeded
line 61:
0 == Approx( 0 ) succeeded
----------------------------------------------------------------
Summary for test case './succeeding/Approx/int':
All tests passed (2 assertions in 1 test case)
-- Test case: './succeeding/Approx/mixed' ----------------------
ApproxTests.cpp:75:
1.0f == Approx( 1 ) succeeded for: 1 == Approx( 1 )
line 76:
0 == Approx( dZero) succeeded for: 0 == Approx( 0 )
line 77:
0 == Approx( dSmall ).epsilon( 0.001 ) succeeded for: 0 == Approx( 1e-05 )
line 78:
1.234f == Approx( dMedium ) succeeded for: 1.234 == Approx( 1.234 )
line 79:
dMedium == Approx( 1.234f ) succeeded for: 1.234 == Approx( 1.234 )
----------------------------------------------------------------
Summary for test case './succeeding/Approx/mixed':
All tests passed (5 assertions in 1 test case)
-- Test case: './succeeding/Approx/custom' ---------------------
ApproxTests.cpp:93:
d == approx( 1.23 ) succeeded for: 1.23 == Approx( 1.23 )
line 94:
d == approx( 1.22 ) succeeded for: 1.23 == Approx( 1.22 )
line 95:
d == approx( 1.24 ) succeeded for: 1.23 == Approx( 1.24 )
line 96:
d != approx( 1.25 ) succeeded for: 1.23 != Approx( 1.25 )
line 98:
approx( d ) == 1.23 succeeded for: Approx( 1.23 ) == 1.23
line 99:
approx( d ) == 1.22 succeeded for: Approx( 1.23 ) == 1.22
line 100:
approx( d ) == 1.24 succeeded for: Approx( 1.23 ) == 1.24
line 101:
approx( d ) != 1.25 succeeded for: Approx( 1.23 ) != 1.25
----------------------------------------------------------------
Summary for test case './succeeding/Approx/custom':
All tests passed (8 assertions in 1 test case)
-- Test case: './succeeding/TestClass/succeedingCase' ----------
ClassTests.cpp:24:
s == "hello" succeeded for: "hello" == "hello"
----------------------------------------------------------------
Summary for test case './succeeding/TestClass/succeedingCase':
All tests passed (1 assertion in 1 test case)
-- Test case: './failing/TestClass/failingCase' ----------------
ClassTests.cpp:28:
s == "world" failed for: "hello" == "world"
----------------------------------------------------------------
Summary for test case './failing/TestClass/failingCase':
1 test case - failed (1 assertion - failed)
-- Test case: './succeeding/Fixture/succeedingCase' ------------
ClassTests.cpp:47:
m_a == 1 succeeded for: 1 == 1
----------------------------------------------------------------
Summary for test case './succeeding/Fixture/succeedingCase':
All tests passed (1 assertion in 1 test case)
-- Test case: './failing/Fixture/failingCase' ------------------
ClassTests.cpp:55:
m_a == 2 failed for: 1 == 2
----------------------------------------------------------------
Summary for test case './failing/Fixture/failingCase':
1 test case - failed (1 assertion - failed)
-- Test case: './succeeding/conditions/equality' ---------------
ConditionTests.cpp:55:
data.int_seven == 7 succeeded for: 7 == 7
line 56:
data.float_nine_point_one == Approx( 9.1f ) succeeded for: 9.1 == Approx( 9.1 )
line 57:
data.double_pi == Approx( 3.1415926535 ) succeeded for: 3.14159 == Approx( 3.14159 )
line 58:
data.str_hello == "hello" succeeded for: "hello" == "hello"
line 59:
"hello" == data.str_hello succeeded for: "hello" == "hello"
line 60:
data.str_hello.size() == 5 succeeded for: 5 == 5
line 63:
x == Approx( 1.3 ) succeeded for: 1.3 == Approx( 1.3 )
----------------------------------------------------------------
Summary for test case './succeeding/conditions/equality':
All tests passed (7 assertions in 1 test case)
-- Test case: './failing/conditions/equality' ------------------
ConditionTests.cpp:71:
data.int_seven == 6 failed for: 7 == 6
line 72:
data.int_seven == 8 failed for: 7 == 8
line 73:
data.int_seven == 0 failed for: 7 == 0
line 74:
data.float_nine_point_one == Approx( 9.11f ) failed for: 9.1 == Approx( 9.11 )
line 75:
data.float_nine_point_one == Approx( 9.0f ) failed for: 9.1 == Approx( 9 )
line 76:
data.float_nine_point_one == Approx( 1 ) failed for: 9.1 == Approx( 1 )
line 77:
data.float_nine_point_one == Approx( 0 ) failed for: 9.1 == Approx( 0 )
line 78:
data.double_pi == Approx( 3.1415 ) failed for: 3.14159 == Approx( 3.1415 )
line 79:
data.str_hello == "goodbye" failed for: "hello" == "goodbye"
line 80:
data.str_hello == "hell" failed for: "hello" == "hell"
line 81:
data.str_hello == "hello1" failed for: "hello" == "hello1"
line 82:
data.str_hello.size() == 6 failed for: 5 == 6
line 85:
x == Approx( 1.301 ) failed for: 1.3 == Approx( 1.301 )
----------------------------------------------------------------
Summary for test case './failing/conditions/equality':
1 test case - failed (13 assertions - all failed)
-- Test case: './succeeding/conditions/inequality' -------------
ConditionTests.cpp:93:
data.int_seven != 6 succeeded for: 7 != 6
line 94:
data.int_seven != 8 succeeded for: 7 != 8
line 95:
data.float_nine_point_one != Approx( 9.11f ) succeeded for: 9.1 != Approx( 9.11 )
line 96:
data.float_nine_point_one != Approx( 9.0f ) succeeded for: 9.1 != Approx( 9 )
line 97:
data.float_nine_point_one != Approx( 1 ) succeeded for: 9.1 != Approx( 1 )
line 98:
data.float_nine_point_one != Approx( 0 ) succeeded for: 9.1 != Approx( 0 )
line 99:
data.double_pi != Approx( 3.1415 ) succeeded for: 3.14159 != Approx( 3.1415 )
line 100:
data.str_hello != "goodbye" succeeded for: "hello" != "goodbye"
line 101:
data.str_hello != "hell" succeeded for: "hello" != "hell"
line 102:
data.str_hello != "hello1" succeeded for: "hello" != "hello1"
line 103:
data.str_hello.size() != 6 succeeded for: 5 != 6
----------------------------------------------------------------
Summary for test case './succeeding/conditions/inequality':
All tests passed (11 assertions in 1 test case)
-- Test case: './failing/conditions/inequality' ----------------
ConditionTests.cpp:111:
data.int_seven != 7 failed for: 7 != 7
line 112:
data.float_nine_point_one != Approx( 9.1f ) failed for: 9.1 != Approx( 9.1 )
line 113:
data.double_pi != Approx( 3.1415926535 ) failed for: 3.14159 != Approx( 3.14159 )
line 114:
data.str_hello != "hello" failed for: "hello" != "hello"
line 115:
data.str_hello.size() != 5 failed for: 5 != 5
----------------------------------------------------------------
Summary for test case './failing/conditions/inequality':
1 test case - failed (5 assertions - all failed)
-- Test case: './succeeding/conditions/ordered' ----------------
ConditionTests.cpp:124:
data.int_seven < 8 succeeded for: 7 < 8
line 125:
data.int_seven > 6 succeeded for: 7 > 6
line 126:
data.int_seven > 0 succeeded for: 7 > 0
line 127:
data.int_seven > -1 succeeded for: 7 > -1
line 129:
data.int_seven >= 7 succeeded for: 7 >= 7
line 130:
data.int_seven >= 6 succeeded for: 7 >= 6
line 131:
data.int_seven <= 7 succeeded for: 7 <= 7
line 132:
data.int_seven <= 8 succeeded for: 7 <= 8
line 134:
data.float_nine_point_one > 9 succeeded for: 9.1 > 9
line 135:
data.float_nine_point_one < 10 succeeded for: 9.1 < 10
line 136:
data.float_nine_point_one < 9.2 succeeded for: 9.1 < 9.2
line 138:
data.str_hello <= "hello" succeeded for: "hello" <= "hello"
line 139:
data.str_hello >= "hello" succeeded for: "hello" >= "hello"
line 141:
data.str_hello < "hellp" succeeded for: "hello" < "hellp"
line 142:
data.str_hello < "zebra" succeeded for: "hello" < "zebra"
line 143:
data.str_hello > "hellm" succeeded for: "hello" > "hellm"
line 144:
data.str_hello > "a" succeeded for: "hello" > "a"
----------------------------------------------------------------
Summary for test case './succeeding/conditions/ordered':
All tests passed (17 assertions in 1 test case)
-- Test case: './failing/conditions/ordered' -------------------
ConditionTests.cpp:152:
data.int_seven > 7 failed for: 7 > 7
line 153:
data.int_seven < 7 failed for: 7 < 7
line 154:
data.int_seven > 8 failed for: 7 > 8
line 155:
data.int_seven < 6 failed for: 7 < 6
line 156:
data.int_seven < 0 failed for: 7 < 0
line 157:
data.int_seven < -1 failed for: 7 < -1
line 159:
data.int_seven >= 8 failed for: 7 >= 8
line 160:
data.int_seven <= 6 failed for: 7 <= 6
line 162:
data.float_nine_point_one < 9 failed for: 9.1 < 9
line 163:
data.float_nine_point_one > 10 failed for: 9.1 > 10
line 164:
data.float_nine_point_one > 9.2 failed for: 9.1 > 9.2
line 166:
data.str_hello > "hello" failed for: "hello" > "hello"
line 167:
data.str_hello < "hello" failed for: "hello" < "hello"
line 168:
data.str_hello > "hellp" failed for: "hello" > "hellp"
line 169:
data.str_hello > "z" failed for: "hello" > "z"
line 170:
data.str_hello < "hellm" failed for: "hello" < "hellm"
line 171:
data.str_hello < "a" failed for: "hello" < "a"
ConditionTests.cpp:173:
data.str_hello >= "z" failed for: "hello" >= "z"
line 174:
data.str_hello <= "a" failed for: "hello" <= "a"
----------------------------------------------------------------
Summary for test case './failing/conditions/ordered':
1 test case - failed (19 assertions - all failed)
-- Test case: './succeeding/conditions/int literals' -----------
ConditionTests.cpp:188:
i == 1 succeeded for: 1 == 1
line 189:
ui == 2 succeeded for: 2 == 2
line 190:
l == 3 succeeded for: 3 == 3
line 191:
ul == 4 succeeded for: 4 == 4
line 192:
c == 5 succeeded for: 5 == 5
line 193:
uc == 6 succeeded for:  == 6
line 195:
1 == i succeeded for: 1 == 1
line 196:
2 == ui succeeded for: 2 == 2
line 197:
3 == l succeeded for: 3 == 3
line 198:
4 == ul succeeded for: 4 == 4
line 199:
5 == c succeeded for: 5 == 5
line 200:
6 == uc succeeded for: 6 == 
line 202:
(std::numeric_limits<unsigned long>::max)() > ul succeeded for: 0x<hex digits> > 4
----------------------------------------------------------------
Summary for test case './succeeding/conditions/int literals':
All tests passed (13 assertions in 1 test case)
-- Test case: './succeeding/conditions//long_to_unsigned_x' ----
ConditionTests.cpp:223:
long_var == unsigned_char_var succeeded for: 1 == 
line 224:
long_var == unsigned_short_var succeeded for: 1 == 1
line 225:
long_var == unsigned_int_var succeeded for: 1 == 1
line 226:
long_var == unsigned_long_var succeeded for: 1 == 1
----------------------------------------------------------------
Summary for test case './succeeding/conditions//long_to_unsigned_x':
All tests passed (4 assertions in 1 test case)
-- Test case: './succeeding/conditions/const ints to int literal'
ConditionTests.cpp:237:
unsigned_char_var == 1 succeeded for:  == 1
line 238:
unsigned_short_var == 1 succeeded for: 1 == 1
line 239:
unsigned_int_var == 1 succeeded for: 1 == 1
line 240:
unsigned_long_var == 1 succeeded for: 1 == 1
----------------------------------------------------------------
Summary for test case './succeeding/conditions/const ints to int literal':
All tests passed (4 assertions in 1 test case)
-- Test case: './succeeding/conditions/negative ints' ----------
ConditionTests.cpp:246:
( -1 > 2u ) succeeded for: true
line 247:
-1 > 2u succeeded for: -1 > 2
line 249:
( 2u < -1 ) succeeded for: true
line 250:
2u < -1 succeeded for: 2 < -1
line 253:
( minInt > 2u ) succeeded for: true
line 254:
minInt > 2u succeeded for: -2147483648 > 2
----------------------------------------------------------------
Summary for test case './succeeding/conditions/negative ints':
All tests passed (6 assertions in 1 test case)
-- Test case: './succeeding/conditions/computed ints' ----------
ConditionTests.cpp:269:
54 == 6*9 succeeded for: 54 == 54
----------------------------------------------------------------
Summary for test case './succeeding/conditions/computed ints':
All tests passed (1 assertion in 1 test case)
-- Test case: './succeeding/conditions/ptr' --------------------
ConditionTests.cpp:285:
p == __null succeeded for: __null == 0
line 286:
p == pNULL succeeded for: __null == __null
line 291:
p != __null succeeded for: 0x<hex digits> != 0
line 294:
cp != __null succeeded for: 0x<hex digits> != 0
line 297:
cpc != __null succeeded for: 0x<hex digits> != 0
line 299:
returnsNull() == __null succeeded for: {null string} == 0
line 300:
returnsConstNull() == __null succeeded for: {null string} == 0
line 302:
__null != p succeeded for: 0 != 0x<hex digits>
----------------------------------------------------------------
Summary for test case './succeeding/conditions/ptr':
All tests passed (8 assertions in 1 test case)
-- Test case: './succeeding/conditions/not' --------------------
ConditionTests.cpp:317:
false == false succeeded
line 318:
true == true succeeded
line 319:
!false succeeded for: true
line 320:
!false succeeded
line 322:
!falseValue succeeded for: true
line 323:
!falseValue succeeded for: !false
line 325:
!(1 == 2) succeeded for: true
line 326:
!1 == 2 succeeded for: !(1 == 2)
----------------------------------------------------------------
Summary for test case './succeeding/conditions/not':
All tests passed (8 assertions in 1 test case)
-- Test case: './failing/conditions/not' -----------------------
ConditionTests.cpp:334:
false != false failed
line 335:
true != true failed
line 336:
!true failed for: false
line 337:
!true failed
line 339:
!trueValue failed for: false
line 340:
!trueValue failed for: !true
line 342:
!(1 == 1) failed for: false
line 343:
!1 == 1 failed for: !(1 == 1)
----------------------------------------------------------------
Summary for test case './failing/conditions/not':
1 test case - failed (8 assertions - all failed)
-- Test case: './succeeding/exceptions/explicit' ---------------
ExceptionTests.cpp:39:
thisThrows() succeeded
line 40:
thisDoesntThrow() succeeded
line 41:
thisThrows() succeeded
----------------------------------------------------------------
Summary for test case './succeeding/exceptions/explicit':
All tests passed (3 assertions in 1 test case)
-- Test case: './failing/exceptions/explicit' ------------------
ExceptionTests.cpp:47:
thisThrows() failed with unexpected exception with message: 'expected exception'
line 48:
thisDoesntThrow() failed because no exception was thrown where one was expected
line 49:
thisThrows() failed with unexpected exception with message: 'expected exception'
----------------------------------------------------------------
Summary for test case './failing/exceptions/explicit':
1 test case - failed (3 assertions - all failed)
-- Test case: './failing/exceptions/implicit' ------------------
ExceptionTests.cpp:52:
Unexpected exception with message: 'unexpected exception'
----------------------------------------------------------------
Summary for test case './failing/exceptions/implicit':
1 test case - failed (1 assertion - failed)
-- Test case: './failing/exceptions/implicit/2' ----------------
ExceptionTests.cpp:60:
1 == 1 succeeded
{Unknown expression after this line} failed with unexpected exception with message: 'unexpected exception'
----------------------------------------------------------------
Summary for test case './failing/exceptions/implicit/2':
1 test case - failed (2 assertions - 1 failed)
-- Test case: './succeeding/exceptions/implicit' ---------------
No assertions in test case, './succeeding/exceptions/implicit'
----------------------------------------------------------------
Summary for test case './succeeding/exceptions/implicit':
1 test case - failed (1 assertion - failed)
-- Test case: './failing/exceptions/custom' --------------------
ExceptionTests.cpp:102:
Unexpected exception with message: 'custom exception'
----------------------------------------------------------------
Summary for test case './failing/exceptions/custom':
1 test case - failed (1 assertion - failed)
-- Test case: './failing/exceptions/custom/nothrow' ------------
ExceptionTests.cpp:109:
throw CustomException( "unexpected custom exception" ) failed with unexpected exception with message: 'unexpected custom exception'
----------------------------------------------------------------
Summary for test case './failing/exceptions/custom/nothrow':
1 test case - failed (1 assertion - failed)
-- Test case: './failing/exceptions/custom/throw' --------------
ExceptionTests.cpp:114:
throw CustomException( "custom exception - not std" ) failed with unexpected exception with message: 'custom exception - not std'
----------------------------------------------------------------
Summary for test case './failing/exceptions/custom/throw':
1 test case - failed (1 assertion - failed)
-- Test case: './failing/exceptions/custom/double' -------------
ExceptionTests.cpp:118:
Unexpected exception with message: '3.14'
----------------------------------------------------------------
Summary for test case './failing/exceptions/custom/double':
1 test case - failed (1 assertion - failed)
-- Test case: './succeeding/exceptions/notimplemented' ---------
ExceptionTests.cpp:129:
thisFunctionNotImplemented( 7 ) succeeded
----------------------------------------------------------------
Summary for test case './succeeding/exceptions/notimplemented':
All tests passed (1 assertion in 1 test case)
-- Test case: './succeeding/generators/1' ----------------------
GeneratorTests.cpp:26:
multiply( i, 2 ) == i*2 succeeded for: 2 == 2
line 27:
multiply( j, 2 ) == j*2 succeeded for: 200 == 200
multiply( i, 2 ) == i*2 succeeded for: 4 == 4
line 27:
multiply( j, 2 ) == j*2 succeeded for: 200 == 200
multiply( i, 2 ) == i*2 succeeded for: 6 == 6
line 27:
multiply( j, 2 ) == j*2 succeeded for: 200 == 200
multiply( i, 2 ) == i*2 succeeded for: 8 == 8
line 27:
multiply( j, 2 ) == j*2 succeeded for: 200 == 200
multiply( i, 2 ) == i*2 succeeded for: 10 == 10
line 27:
multiply( j, 2 ) == j*2 succeeded for: 200 == 200
multiply( i, 2 ) == i*2 succeeded for: 30 == 30
line 27:
multiply( j, 2 ) == j*2 succeeded for: 200 == 200
multiply( i, 2 ) == i*2 succeeded for: 40 == 40
line 27:
multiply( j, 2 ) == j*2 succeeded for: 200 == 200
multiply( i, 2 ) == i*2 succeeded for: 42 == 42
line 27:
multiply( j, 2 ) == j*2 succeeded for: 200 == 200
multiply( i, 2 ) == i*2 succeeded for: 72 == 72
line 27:
multiply( j, 2 ) == j*2 succeeded for: 200 == 200
multiply( i, 2 ) == i*2 succeeded for: 2 == 2
line 27:
multiply( j, 2 ) == j*2 succeeded for: 202 == 202
multiply( i, 2 ) == i*2 succeeded for: 4 == 4
line 27:
multiply( j, 2 ) == j*2 succeeded for: 202 == 202
multiply( i, 2 ) == i*2 succeeded for: 6 == 6
line 27:
multiply( j, 2 ) == j*2 succeeded for: 202 == 202
multiply( i, 2 ) == i*2 succeeded for: 8 == 8
line 27:
multiply( j, 2 ) == j*2 succeeded for: 202 == 202
multiply( i, 2 ) == i*2 succeeded for: 10 == 10
line 27:
multiply( j, 2 ) == j*2 succeeded for: 202 == 202
multiply( i, 2 ) == i*2 succeeded for: 30 == 30
line 27:
multiply( j, 2 ) == j*2 succeeded for: 202 == 202
multiply( i, 2 ) == i*2 succeeded for: 40 == 40
line 27:
multiply( j, 2 ) == j*2 succeeded for: 202 == 202
multiply( i, 2 ) == i*2 succeeded for: 42 == 42
line 27:
multiply( j, 2 ) == j*2 succeeded for: 202 == 202
multiply( i, 2 ) == i*2 succeeded for: 72 == 72
line 27:
multiply( j, 2 ) == j*2 succeeded for: 202 == 202
multiply( i, 2 ) == i*2 succeeded for: 2 == 2
line 27:
multiply( j, 2 ) == j*2 succeeded for: 204 == 204
multiply( i, 2 ) == i*2 succeeded for: 4 == 4
line 27:
multiply( j, 2 ) == j*2 succeeded for: 204 == 204
multiply( i, 2 ) == i*2 succeeded for: 6 == 6
line 27:
multiply( j, 2 ) == j*2 succeeded for: 204 == 204
multiply( i, 2 ) == i*2 succeeded for: 8 == 8
line 27:
multiply( j, 2 ) == j*2 succeeded for: 204 == 204
multiply( i, 2 ) == i*2 succeeded for: 10 == 10
line 27:
multiply( j, 2 ) == j*2 succeeded for: 204 == 204
multiply( i, 2 ) == i*2 succeeded for: 30 == 30
line 27:
multiply( j, 2 ) == j*2 succeeded for: 204 == 204
multiply( i, 2 ) == i*2 succeeded for: 40 == 40
line 27:
multiply( j, 2 ) == j*2 succeeded for: 204 == 204
multiply( i, 2 ) == i*2 succeeded for: 42 == 42
line 27:
multiply( j, 2 ) == j*2 succeeded for: 204 == 204
multiply( i, 2 ) == i*2 succeeded for: 72 == 72
line 27:
multiply( j, 2 ) == j*2 succeeded for: 204 == 204
multiply( i, 2 ) == i*2 succeeded for: 2 == 2
line 27:
multiply( j, 2 ) == j*2 succeeded for: 206 == 206
multiply( i, 2 ) == i*2 succeeded for: 4 == 4
line 27:
multiply( j, 2 ) == j*2 succeeded for: 206 == 206
multiply( i, 2 ) == i*2 succeeded for: 6 == 6
line 27:
multiply( j, 2 ) == j*2 succeeded for: 206 == 206
multiply( i, 2 ) == i*2 succeeded for: 8 == 8
line 27:
multiply( j, 2 ) == j*2 succeeded for: 206 == 206
multiply( i, 2 ) == i*2 succeeded for: 10 == 10
line 27:
multiply( j, 2 ) == j*2 succeeded for: 206 == 206
multiply( i, 2 ) == i*2 succeeded for: 30 == 30
line 27:
multiply( j, 2 ) == j*2 succeeded for: 206 == 206
multiply( i, 2 ) == i*2 succeeded for: 40 == 40
line 27:
multiply( j, 2 ) == j*2 succeeded for: 206 == 206
multiply( i, 2 ) == i*2 succeeded for: 42 == 42
line 27:
multiply( j, 2 ) == j*2 succeeded for: 206 == 206
multiply( i, 2 ) == i*2 succeeded for: 72 == 72
line 27:
multiply( j, 2 ) == j*2 succeeded for: 206 == 206
multiply( i, 2 ) == i*2 succeeded for: 2 == 2
line 27:
multiply( j, 2 ) == j*2 succeeded for: 208 == 208
multiply( i, 2 ) == i*2 succeeded for: 4 == 4
line 27:
multiply( j, 2 ) == j*2 succeeded for: 208 == 208
multiply( i, 2 ) == i*2 succeeded for: 6 == 6
line 27:
multiply( j, 2 ) == j*2 succeeded for: 208 == 208
multiply( i, 2 ) == i*2 succeeded for: 8 == 8
line 27:
multiply( j, 2 ) == j*2 succeeded for: 208 == 208
multiply( i, 2 ) == i*2 succeeded for: 10 == 10
line 27:
multiply( j, 2 ) == j*2 succeeded for: 208 == 208
multiply( i, 2 ) == i*2 succeeded for: 30 == 30
line 27:
multiply( j, 2 ) == j*2 succeeded for: 208 == 208
multiply( i, 2 ) == i*2 succeeded for: 40 == 40
line 27:
multiply( j, 2 ) == j*2 succeeded for: 208 == 208
multiply( i, 2 ) == i*2 succeeded for: 42 == 42
line 27:
multiply( j, 2 ) == j*2 succeeded for: 208 == 208
multiply( i, 2 ) == i*2 succeeded for: 72 == 72
line 27:
multiply( j, 2 ) == j*2 succeeded for: 208 == 208
multiply( i, 2 ) == i*2 succeeded for: 2 == 2
line 27:
multiply( j, 2 ) == j*2 succeeded for: 210 == 210
multiply( i, 2 ) == i*2 succeeded for: 4 == 4
line 27:
multiply( j, 2 ) == j*2 succeeded for: 210 == 210
multiply( i, 2 ) == i*2 succeeded for: 6 == 6
line 27:
multiply( j, 2 ) == j*2 succeeded for: 210 == 210
multiply( i, 2 ) == i*2 succeeded for: 8 == 8
line 27:
multiply( j, 2 ) == j*2 succeeded for: 210 == 210
multiply( i, 2 ) == i*2 succeeded for: 10 == 10
line 27:
multiply( j, 2 ) == j*2 succeeded for: 210 == 210
multiply( i, 2 ) == i*2 succeeded for: 30 == 30
line 27:
multiply( j, 2 ) == j*2 succeeded for: 210 == 210
multiply( i, 2 ) == i*2 succeeded for: 40 == 40
line 27:
multiply( j, 2 ) == j*2 succeeded for: 210 == 210
multiply( i, 2 ) == i*2 succeeded for: 42 == 42
line 27:
multiply( j, 2 ) == j*2 succeeded for: 210 == 210
multiply( i, 2 ) == i*2 succeeded for: 72 == 72
line 27:
multiply( j, 2 ) == j*2 succeeded for: 210 == 210
multiply( i, 2 ) == i*2 succeeded for: 2 == 2
line 27:
multiply( j, 2 ) == j*2 succeeded for: 212 == 212
multiply( i, 2 ) == i*2 succeeded for: 4 == 4
line 27:
multiply( j, 2 ) == j*2 succeeded for: 212 == 212
multiply( i, 2 ) == i*2 succeeded for: 6 == 6
line 27:
multiply( j, 2 ) == j*2 succeeded for: 212 == 212
multiply( i, 2 ) == i*2 succeeded for: 8 == 8
line 27:
multiply( j, 2 ) == j*2 succeeded for: 212 == 212
multiply( i, 2 ) == i*2 succeeded for: 10 == 10
line 27:
multiply( j, 2 ) == j*2 succeeded for: 212 == 212
multiply( i, 2 ) == i*2 succeeded for: 30 == 30
line 27:
multiply( j, 2 ) == j*2 succeeded for: 212 == 212
multiply( i, 2 ) == i*2 succeeded for: 40 == 40
line 27:
multiply( j, 2 ) == j*2 succeeded for: 212 == 212
multiply( i, 2 ) == i*2 succeeded for: 42 == 42
line 27:
multiply( j, 2 ) == j*2 succeeded for: 212 == 212
multiply( i, 2 ) == i*2 succeeded for: 72 == 72
line 27:
multiply( j, 2 ) == j*2 succeeded for: 212 == 212
multiply( i, 2 ) == i*2 succeeded for: 2 == 2
line 27:
multiply( j, 2 ) == j*2 succeeded for: 214 == 214
multiply( i, 2 ) == i*2 succeeded for: 4 == 4
line 27:
multiply( j, 2 ) == j*2 succeeded for: 214 == 214
multiply( i, 2 ) == i*2 succeeded for: 6 == 6
line 27:
multiply( j, 2 ) == j*2 succeeded for: 214 == 214
multiply( i, 2 ) == i*2 succeeded for: 8 == 8
line 27:
multiply( j, 2 ) == j*2 succeeded for: 214 == 214
multiply( i, 2 ) == i*2 succeeded for: 10 == 10
line 27:
multiply( j, 2 ) == j*2 succeeded for: 214 == 214
multiply( i, 2 ) == i*2 succeeded for: 30 == 30
line 27:
multiply( j, 2 ) == j*2 succeeded for: 214 == 214
multiply( i, 2 ) == i*2 succeeded for: 40 == 40
line 27:
multiply( j, 2 ) == j*2 succeeded for: 214 == 214
multiply( i, 2 ) == i*2 succeeded for: 42 == 42
line 27:
multiply( j, 2 ) == j*2 succeeded for: 214 == 214
multiply( i, 2 ) == i*2 succeeded for: 72 == 72
line 27:
multiply( j, 2 ) == j*2 succeeded for: 214 == 214
----------------------------------------------------------------
Summary for test case './succeeding/generators/1':
All tests passed (144 assertions in 1 test case)
-- Test case: './succeeding/message' ---------------------------
MessageTests.cpp:14:
[warning: this is a warning]
No assertions in test case, './succeeding/message'
----------------------------------------------------------------
Summary for test case './succeeding/message':
1 test case - failed (1 assertion - failed)
-- Test case: './succeeding/succeed' ---------------------------
MessageTests.cpp:18:
succeeded
[with message: this is a success]
----------------------------------------------------------------
Summary for test case './succeeding/succeed':
All tests passed (1 assertion in 1 test case)
-- Test case: './failing/message/info/1' -----------------------
MessageTests.cpp:23:
[info: this message should be logged]
line 24:
[info: so should this]
line 26:
a == 1 failed for: 2 == 1
----------------------------------------------------------------
Summary for test case './failing/message/info/1':
1 test case - failed (1 assertion - failed)
-- Test case: './mixed/message/info/2' -------------------------
MessageTests.cpp:33:
a == 2 succeeded for: 2 == 2
line 31:
[info: this message should be logged]
line 35:
[info: this message should be logged, too]
line 37:
a == 1 failed for: 2 == 1
line 39:
[info: and this, but later]
line 41:
a == 0 failed for: 2 == 0
line 45:
a == 2 succeeded for: 2 == 2
----------------------------------------------------------------
Summary for test case './mixed/message/info/2':
1 test case - failed (4 assertions - 2 failed)
-- Test case: './failing/message/fail' -------------------------
MessageTests.cpp:51:
failed with message: 'This is a failure'
----------------------------------------------------------------
Summary for test case './failing/message/fail':
1 test case - failed (1 assertion - failed)
-- Test case: './failing/message/sections' ---------------------
-- Section: 'one' ----------------------------------------------
MessageTests.cpp:58:
failed with message: 'Message from section one'
----------------------------------------------------------------
Summary for section 'one':
1 assertion - failed
-- Section: 'two' ----------------------------------------------
MessageTests.cpp:63:
failed with message: 'Message from section two'
----------------------------------------------------------------
Summary for section 'two':
1 assertion - failed
----------------------------------------------------------------
Summary for test case './failing/message/sections':
1 test case - failed (2 assertions - both failed)
Message from section one
-- Test case: './succeeding/message/sections/stdout' -----------
-- Section: 'one' ----------------------------------------------
No assertions in section, 'one'
----------------------------------------------------------------
Summary for section 'one':
1 assertion - failed
Message from section two
-- Section: 'two' ----------------------------------------------
No assertions in section, 'two'
----------------------------------------------------------------
Summary for section 'two':
1 assertion - failed
----------------------------------------------------------------
Summary for test case './succeeding/message/sections/stdout':
1 test case - failed (2 assertions - both failed)
-- Test case: './mixed/message/scoped' -------------------------
MessageTests.cpp:86:
i < 10 succeeded for: 0 < 10
i < 10 succeeded for: 1 < 10
i < 10 succeeded for: 2 < 10
i < 10 succeeded for: 3 < 10
i < 10 succeeded for: 4 < 10
i < 10 succeeded for: 5 < 10
i < 10 succeeded for: 6 < 10
i < 10 succeeded for: 7 < 10
i < 10 succeeded for: 8 < 10
i < 10 succeeded for: 9 < 10
i < 10 succeeded[info: current counter 10]
i < 10 succeeded[info: i := 10]
i < 10 failed for: 10 < 10
----------------------------------------------------------------
Summary for test case './mixed/message/scoped':
1 test case - failed (11 assertions - 1 failed)
-- Test case: './succeeding/nofail' ----------------------------
MessageTests.cpp:92:
1 == 2 failed - but was ok
No assertions in test case, './succeeding/nofail'
----------------------------------------------------------------
Summary for test case './succeeding/nofail':
1 test case - failed (1 assertion - failed)
-- Test case: './succeeding/Misc/Sections' ---------------------
-- Section: 's1' -----------------------------------------------
MiscTests.cpp:25:
a != b succeeded for: 1 != 2
line 26:
b != a succeeded for: 2 != 1
----------------------------------------------------------------
Summary for section 's1':
All 2 assertions passed
-- Section: 's2' -----------------------------------------------
MiscTests.cpp:31:
a != b succeeded for: 1 != 2
----------------------------------------------------------------
Summary for section 's2':
1 assertion passed
----------------------------------------------------------------
Summary for test case './succeeding/Misc/Sections':
All tests passed (3 assertions in 1 test case)
-- Test case: './succeeding/Misc/Sections/nested' --------------
-- Section: 's1' -----------------------------------------------
MiscTests.cpp:42:
a != b succeeded for: 1 != 2
line 43:
b != a succeeded for: 2 != 1
-- Section: 's2' -----------------------------------------------
line 47:
a != b succeeded for: 1 != 2
----------------------------------------------------------------
Summary for section 's2':
1 assertion passed
----------------------------------------------------------------
Summary for section 's1':
All 3 assertions passed
----------------------------------------------------------------
Summary for test case './succeeding/Misc/Sections/nested':
All tests passed (3 assertions in 1 test case)
-- Test case: './mixed/Misc/Sections/nested2' ------------------
-- Section: 's1' -----------------------------------------------
-- Section: 's2' -----------------------------------------------
MiscTests.cpp:61:
a == b failed for: 1 == 2
----------------------------------------------------------------
Summary for section 's2':
1 assertion - failed
----------------------------------------------------------------
Summary for section 's1':
1 assertion - failed
-- Section: 's1' -----------------------------------------------
-- Section: 's3' -----------------------------------------------
MiscTests.cpp:66:
a != b succeeded for: 1 != 2
----------------------------------------------------------------
Summary for section 's3':
1 assertion passed
----------------------------------------------------------------
Summary for section 's1':
1 assertion passed
-- Section: 's1' -----------------------------------------------
-- Section: 's4' -----------------------------------------------
MiscTests.cpp:70:
a < b succeeded for: 1 < 2
----------------------------------------------------------------
Summary for section 's4':
1 assertion passed
----------------------------------------------------------------
Summary for section 's1':
1 assertion passed
----------------------------------------------------------------
Summary for test case './mixed/Misc/Sections/nested2':
1 test case - failed (3 assertions - 1 failed)
-- Test case: './Sections/nested/a/b' --------------------------
-- Section: 'c' ------------------------------------------------
-- Section: 'd (leaf)' -----------------------------------------
No assertions in section, 'd (leaf)'
----------------------------------------------------------------
Summary for section 'd (leaf)':
1 assertion - failed
----------------------------------------------------------------
Summary for section 'c':
1 assertion - failed
-- Section: 'c' ------------------------------------------------
-- Section: 'e (leaf)' -----------------------------------------
No assertions in section, 'e (leaf)'
----------------------------------------------------------------
Summary for section 'e (leaf)':
1 assertion - failed
----------------------------------------------------------------
Summary for section 'c':
1 assertion - failed
-- Section: 'f (leaf)' -----------------------------------------
No assertions in section, 'f (leaf)'
----------------------------------------------------------------
Summary for section 'f (leaf)':
1 assertion - failed
----------------------------------------------------------------
Summary for test case './Sections/nested/a/b':
1 test case - failed (3 assertions - all failed)
-- Test case: './mixed/Misc/Sections/loops' --------------------
-- Section: 's1' -----------------------------------------------
MiscTests.cpp:103:
b > a failed for: 0 > 1
----------------------------------------------------------------
Summary for section 's1':
1 assertion - failed
----------------------------------------------------------------
Summary for test case './mixed/Misc/Sections/loops':
1 test case - failed (1 assertion - failed)
-- Test case: './mixed/Misc/loops' -----------------------------
MiscTests.cpp:114:
[info: Testing if fib[0] (1) is even]
line 115:
( fib[i] % 2 ) == 0 failed for: 1 == 0
[info: Testing if fib[1] (1) is even]
line 115:
( fib[i] % 2 ) == 0 failed for: 1 == 0
line 115:
( fib[i] % 2 ) == 0 succeeded for: 0 == 0
[info: Testing if fib[2] (2) is even]
[info: Testing if fib[3] (3) is even]
line 115:
( fib[i] % 2 ) == 0 failed for: 1 == 0
[info: Testing if fib[4] (5) is even]
line 115:
( fib[i] % 2 ) == 0 failed for: 1 == 0
line 115:
( fib[i] % 2 ) == 0 succeeded for: 0 == 0
[info: Testing if fib[5] (8) is even]
[info: Testing if fib[6] (13) is even]
line 115:
( fib[i] % 2 ) == 0 failed for: 1 == 0
[info: Testing if fib[7] (21) is even]
line 115:
( fib[i] % 2 ) == 0 failed for: 1 == 0
----------------------------------------------------------------
Summary for test case './mixed/Misc/loops':
1 test case - failed (8 assertions - 6 failed)
Some information
An error
-- Test case: './succeeding/Misc/stdout,stderr' ----------------
No assertions in test case, './succeeding/Misc/stdout,stderr'
----------------------------------------------------------------
Summary for test case './succeeding/Misc/stdout,stderr':
1 test case - failed (1 assertion - failed)
-- Test case: './succeeding/Misc/null strings' -----------------
MiscTests.cpp:133:
makeString( false ) != static_cast<char*>(__null) succeeded for: "valid string" != {null string}
line 134:
makeString( true ) == static_cast<char*>(__null) succeeded for: {null string} == {null string}
----------------------------------------------------------------
Summary for test case './succeeding/Misc/null strings':
All tests passed (2 assertions in 1 test case)
-- Test case: './failing/info' ---------------------------------
MiscTests.cpp:139:
[info: hi]
line 141:
[info: i := 7]
line 142:
false failed
----------------------------------------------------------------
Summary for test case './failing/info':
1 test case - failed (1 assertion - failed)
-- Test case: './succeeding/checkedif' -------------------------
MiscTests.cpp:147:
flag succeeded for: true
line 155:
testCheckedIf( true ) succeeded for: true
----------------------------------------------------------------
Summary for test case './succeeding/checkedif':
All tests passed (2 assertions in 1 test case)
-- Test case: './failing/checkedif' ----------------------------
MiscTests.cpp:147:
flag failed for: false
line 160:
testCheckedIf( false ) failed for: false
----------------------------------------------------------------
Summary for test case './failing/checkedif':
1 test case - failed (2 assertions - both failed)
-- Test case: './succeeding/checkedelse' -----------------------
MiscTests.cpp:165:
flag succeeded for: true
line 173:
testCheckedElse( true ) succeeded for: true
----------------------------------------------------------------
Summary for test case './succeeding/checkedelse':
All tests passed (2 assertions in 1 test case)
-- Test case: './failing/checkedelse' --------------------------
MiscTests.cpp:165:
flag failed for: false
line 178:
testCheckedElse( false ) failed for: false
----------------------------------------------------------------
Summary for test case './failing/checkedelse':
1 test case - failed (2 assertions - both failed)
-- Test case: './misc/xmlentitycheck' --------------------------
-- Section: 'embedded xml' -------------------------------------
No assertions in section, 'embedded xml'
----------------------------------------------------------------
Summary for section 'embedded xml':
1 assertion - failed
-- Section: 'encoded chars' ------------------------------------
No assertions in section, 'encoded chars'
----------------------------------------------------------------
Summary for section 'encoded chars':
1 assertion - failed
----------------------------------------------------------------
Summary for test case './misc/xmlentitycheck':
1 test case - failed (2 assertions - both failed)
-- Test case: './manual/onechar' -------------------------------
MiscTests.cpp:195:
[info: 3]
line 196:
false failed
----------------------------------------------------------------
Summary for test case './manual/onechar':
1 test case - failed (1 assertion - failed)
-- Test case: './succeeding/atomic if' -------------------------
MiscTests.cpp:206:
x == 0 succeeded for: 0 == 0
----------------------------------------------------------------
Summary for test case './succeeding/atomic if':
All tests passed (1 assertion in 1 test case)
-- Test case: './succeeding/matchers' --------------------------
MiscTests.cpp:216:
testStringForMatching() Contains( "string" ) succeeded for:
"this string contains 'abc' as a substring" contains: "string"
line 217:
testStringForMatching() Contains( "abc" ) succeeded for:
"this string contains 'abc' as a substring" contains: "abc"
line 219:
testStringForMatching() StartsWith( "this" ) succeeded for:
"this string contains 'abc' as a substring" starts with: "this"
line 220:
testStringForMatching() EndsWith( "substring" ) succeeded for:
"this string contains 'abc' as a substring" ends with: "substring"
----------------------------------------------------------------
Summary for test case './succeeding/matchers':
All tests passed (4 assertions in 1 test case)
-- Test case: './failing/matchers/Contains' --------------------
MiscTests.cpp:225:
testStringForMatching() Contains( "not there" ) failed for:
"this string contains 'abc' as a substring" contains: "not there"
----------------------------------------------------------------
Summary for test case './failing/matchers/Contains':
1 test case - failed (1 assertion - failed)
-- Test case: './failing/matchers/StartsWith' ------------------
MiscTests.cpp:230:
testStringForMatching() StartsWith( "string" ) failed for:
"this string contains 'abc' as a substring" starts with: "string"
----------------------------------------------------------------
Summary for test case './failing/matchers/StartsWith':
1 test case - failed (1 assertion - failed)
-- Test case: './failing/matchers/EndsWith' --------------------
MiscTests.cpp:235:
testStringForMatching() EndsWith( "this" ) failed for:
"this string contains 'abc' as a substring" ends with: "this"
----------------------------------------------------------------
Summary for test case './failing/matchers/EndsWith':
1 test case - failed (1 assertion - failed)
-- Test case: './failing/matchers/Equals' ----------------------
MiscTests.cpp:240:
testStringForMatching() Equals( "something else" ) failed for:
"this string contains 'abc' as a substring" equals: "something else"
----------------------------------------------------------------
Summary for test case './failing/matchers/Equals':
1 test case - failed (1 assertion - failed)
-- Test case: '/succeeding/matchers/AllOf' ---------------------
MiscTests.cpp:245:
testStringForMatching() AllOf( Catch::Contains( "string" ), Catch::Contains( "abc" ) ) succeeded for:
"this string contains 'abc' as a substring" ( contains: "string" and contains: "abc" )
----------------------------------------------------------------
Summary for test case '/succeeding/matchers/AllOf':
All tests passed (1 assertion in 1 test case)
-- Test case: '/succeeding/matchers/AnyOf' ---------------------
MiscTests.cpp:249:
testStringForMatching() AnyOf( Catch::Contains( "string" ), Catch::Contains( "not there" ) ) succeeded for:
"this string contains 'abc' as a substring" ( contains: "string" or contains: "not there" )
line 250:
testStringForMatching() AnyOf( Catch::Contains( "not there" ), Catch::Contains( "string" ) ) succeeded for:
"this string contains 'abc' as a substring" ( contains: "not there" or contains: "string" )
----------------------------------------------------------------
Summary for test case '/succeeding/matchers/AnyOf':
All tests passed (2 assertions in 1 test case)
-- Test case: './succeeding/matchers/Equals' -------------------
MiscTests.cpp:255:
testStringForMatching() Equals( "this string contains 'abc' as a substring" ) succeeded for:
"this string contains 'abc' as a substring" equals: "this string contains 'abc' as a substring"
----------------------------------------------------------------
Summary for test case './succeeding/matchers/Equals':
All tests passed (1 assertion in 1 test case)
-- Test case: 'example/factorial' ------------------------------
MiscTests.cpp:266:
Factorial(0) == 1 succeeded for: 1 == 1
line 267:
Factorial(1) == 1 succeeded for: 1 == 1
line 268:
Factorial(2) == 2 succeeded for: 2 == 2
line 269:
Factorial(3) == 6 succeeded for: 6 == 6
line 270:
Factorial(10) == 3628800 succeeded for: 0x<hex digits> == 3628800
----------------------------------------------------------------
Summary for test case 'example/factorial':
All tests passed (5 assertions in 1 test case)
-- Test case: 'empty' ------------------------------------------
No assertions in test case, 'empty'
----------------------------------------------------------------
Summary for test case 'empty':
1 test case - failed (1 assertion - failed)
-- Test case: 'Nice descriptive name' --------------------------
MiscTests.cpp:279:
[warning: This one ran]
No assertions in test case, 'Nice descriptive name'
----------------------------------------------------------------
Summary for test case 'Nice descriptive name':
1 test case - failed (1 assertion - failed)
-- Test case: 'first tag' --------------------------------------
No assertions in test case, 'first tag'
----------------------------------------------------------------
Summary for test case 'first tag':
1 test case - failed (1 assertion - failed)
-- Test case: 'second tag' -------------------------------------
No assertions in test case, 'second tag'
----------------------------------------------------------------
Summary for test case 'second tag':
1 test case - failed (1 assertion - failed)
-- Test case: 'selftest/main' ----------------------------------
-- Section: 'selftest/expected result' -------------------------
-- Section: 'selftest/expected result/failing tests' -----------
/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/catch_self_test.hpp:106:
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
succeeded
[with message: Tests failed, as expected]
----------------------------------------------------------------
Summary for section 'selftest/expected result/failing tests':
All 25 assertions passed
----------------------------------------------------------------
Summary for section 'selftest/expected result':
All 25 assertions passed
-- Section: 'selftest/expected result' -------------------------
-- Section: 'selftest/expected result/succeeding tests' --------
/Users/Phil/Dev/OSS/Catch/projects/XCode4/CatchSelfTest/CatchSelfTest/../../../SelfTest/catch_self_test.hpp:95:
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
Message from section one
Message from section two
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
Some information
An error
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
succeeded
[with message: Tests passed, as expected]
----------------------------------------------------------------
Summary for section 'selftest/expected result/succeeding tests':
All 43 assertions passed
----------------------------------------------------------------
Summary for section 'selftest/expected result':
All 43 assertions passed
Message from section one
Message from section two
Some information
An error
-- Section: 'selftest/test counts' -----------------------------
-- Section: 'selftest/test counts/succeeding tests' ------------
TestMain.cpp:40:
totals.assertions.passed == 291 succeeded for: 291 == 291
line 41:
totals.assertions.failed == 0 succeeded for: 0 == 0
----------------------------------------------------------------
Summary for section 'selftest/test counts/succeeding tests':
All 2 assertions passed
----------------------------------------------------------------
Summary for section 'selftest/test counts':
All 2 assertions passed
-- Section: 'selftest/test counts' -----------------------------
-- Section: 'selftest/test counts/failing tests' ---------------
TestMain.cpp:47:
totals.assertions.passed == 1 succeeded for: 1 == 1
line 48:
totals.assertions.failed == 72 succeeded for: 72 == 72
----------------------------------------------------------------
Summary for section 'selftest/test counts/failing tests':
All 2 assertions passed
----------------------------------------------------------------
Summary for section 'selftest/test counts':
All 2 assertions passed
----------------------------------------------------------------
Summary for test case 'selftest/main':
All tests passed (72 assertions in 1 test case)
-- Test case: 'meta/Misc/Sections' -----------------------------
TestMain.cpp:57:
totals.assertions.passed == 2 succeeded for: 2 == 2
line 58:
totals.assertions.failed == 1 succeeded for: 1 == 1
----------------------------------------------------------------
Summary for test case 'meta/Misc/Sections':
All tests passed (2 assertions in 1 test case)
-- Test case: 'selftest/parser/2' ------------------------------
-- Section: 'default' ------------------------------------------
TestMain.cpp:97:
parseIntoConfig( argv, config ) succeeded
line 99:
config.shouldDebugBreak == false succeeded for: false == false
line 100:
config.cutoff == -1 succeeded for: -1 == -1
line 101:
config.allowThrows == true succeeded for: true == true
line 102:
config.reporter.empty() succeeded for: true
----------------------------------------------------------------
Summary for section 'default':
All 5 assertions passed
-- Section: 'test lists' ---------------------------------------
-- Section: '-t/1' ---------------------------------------------
TestMain.cpp:108:
parseIntoConfig( argv, config ) succeeded
line 110:
config.filters.size() == 1 succeeded for: 1 == 1
line 111:
config.filters[0].shouldInclude( fakeTestCase( "notIncluded" ) ) == false succeeded for: false == false
line 112:
config.filters[0].shouldInclude( fakeTestCase( "test1" ) ) succeeded for: true
----------------------------------------------------------------
Summary for section '-t/1':
All 4 assertions passed
----------------------------------------------------------------
Summary for section 'test lists':
All 4 assertions passed
-- Section: 'test lists' ---------------------------------------
-- Section: '-t/exclude:1' -------------------------------------
TestMain.cpp:116:
parseIntoConfig( argv, config ) succeeded
line 118:
config.filters.size() == 1 succeeded for: 1 == 1
line 119:
config.filters[0].shouldInclude( fakeTestCase( "test1" ) ) == false succeeded for: false == false
line 120:
config.filters[0].shouldInclude( fakeTestCase( "alwaysIncluded" ) ) succeeded for: true
----------------------------------------------------------------
Summary for section '-t/exclude:1':
All 4 assertions passed
----------------------------------------------------------------
Summary for section 'test lists':
All 4 assertions passed
-- Section: 'test lists' ---------------------------------------
-- Section: '--test/1' -----------------------------------------
TestMain.cpp:125:
parseIntoConfig( argv, config ) succeeded
line 127:
config.filters.size() == 1 succeeded for: 1 == 1
line 128:
config.filters[0].shouldInclude( fakeTestCase( "notIncluded" ) ) == false succeeded for: false == false
line 129:
config.filters[0].shouldInclude( fakeTestCase( "test1" ) ) succeeded for: true
----------------------------------------------------------------
Summary for section '--test/1':
All 4 assertions passed
----------------------------------------------------------------
Summary for section 'test lists':
All 4 assertions passed
-- Section: 'test lists' ---------------------------------------
-- Section: '--test/exclude:1' ---------------------------------
TestMain.cpp:134:
parseIntoConfig( argv, config ) succeeded
line 136:
config.filters.size() == 1 succeeded for: 1 == 1
line 137:
config.filters[0].shouldInclude( fakeTestCase( "test1" ) ) == false succeeded for: false == false
line 138:
config.filters[0].shouldInclude( fakeTestCase( "alwaysIncluded" ) ) succeeded for: true
----------------------------------------------------------------
Summary for section '--test/exclude:1':
All 4 assertions passed
----------------------------------------------------------------
Summary for section 'test lists':
All 4 assertions passed
-- Section: 'test lists' ---------------------------------------
-- Section: '--test/exclude:2' ---------------------------------
TestMain.cpp:143:
parseIntoConfig( argv, config ) succeeded
line 145:
config.filters.size() == 1 succeeded for: 1 == 1
line 146:
config.filters[0].shouldInclude( fakeTestCase( "test1" ) ) == false succeeded for: false == false
line 147:
config.filters[0].shouldInclude( fakeTestCase( "alwaysIncluded" ) ) succeeded for: true
----------------------------------------------------------------
Summary for section '--test/exclude:2':
All 4 assertions passed
----------------------------------------------------------------
Summary for section 'test lists':
All 4 assertions passed
-- Section: 'test lists' ---------------------------------------
-- Section: '-t/2' ---------------------------------------------
TestMain.cpp:152:
parseIntoConfig( argv, config ) succeeded
line 154:
config.filters.size() == 1 succeeded for: 1 == 1
line 155:
config.filters[0].shouldInclude( fakeTestCase( "notIncluded" ) ) == false succeeded for: false == false
line 156:
config.filters[0].shouldInclude( fakeTestCase( "test1" ) ) succeeded for: true
line 157:
config.filters[0].shouldInclude( fakeTestCase( "test2" ) ) succeeded for: true
----------------------------------------------------------------
Summary for section '-t/2':
All 5 assertions passed
----------------------------------------------------------------
Summary for section 'test lists':
All 5 assertions passed
-- Section: 'test lists' ---------------------------------------
-- Section: '-t/0' ---------------------------------------------
TestMain.cpp:162:
parseIntoConfigAndReturnError( argv, config ) Contains( "at least 1" ) succeeded for:
"Error while parsing arguments. Expected at least 1 argument." contains: "at least 1"
----------------------------------------------------------------
Summary for section '-t/0':
1 assertion passed
----------------------------------------------------------------
Summary for section 'test lists':
1 assertion passed
-- Section: 'reporter' -----------------------------------------
-- Section: '-r/basic' -----------------------------------------
TestMain.cpp:169:
parseIntoConfig( argv, config ) succeeded
line 171:
config.reporter == "console" succeeded for: "console" == "console"
----------------------------------------------------------------
Summary for section '-r/basic':
All 2 assertions passed
----------------------------------------------------------------
Summary for section 'reporter':
All 2 assertions passed
-- Section: 'reporter' -----------------------------------------
-- Section: '-r/xml' -------------------------------------------
TestMain.cpp:175:
parseIntoConfig( argv, config ) succeeded
line 177:
config.reporter == "xml" succeeded for: "xml" == "xml"
----------------------------------------------------------------
Summary for section '-r/xml':
All 2 assertions passed
----------------------------------------------------------------
Summary for section 'reporter':
All 2 assertions passed
-- Section: 'reporter' -----------------------------------------
-- Section: '--reporter/junit' ---------------------------------
TestMain.cpp:181:
parseIntoConfig( argv, config ) succeeded
line 183:
config.reporter == "junit" succeeded for: "junit" == "junit"
----------------------------------------------------------------
Summary for section '--reporter/junit':
All 2 assertions passed
----------------------------------------------------------------
Summary for section 'reporter':
All 2 assertions passed
-- Section: 'reporter' -----------------------------------------
-- Section: '-r/error' -----------------------------------------
TestMain.cpp:187:
parseIntoConfigAndReturnError( argv, config ) Contains( "1 argument" ) succeeded for:
"Error while parsing arguments. Expected 1 argument. Arguments were: one two" contains: "1 argument"
----------------------------------------------------------------
Summary for section '-r/error':
1 assertion passed
----------------------------------------------------------------
Summary for section 'reporter':
1 assertion passed
-- Section: 'debugger' -----------------------------------------
-- Section: '-b' -----------------------------------------------
TestMain.cpp:194:
parseIntoConfig( argv, config ) succeeded
line 196:
config.shouldDebugBreak == true succeeded for: true == true
----------------------------------------------------------------
Summary for section '-b':
All 2 assertions passed
----------------------------------------------------------------
Summary for section 'debugger':
All 2 assertions passed
-- Section: 'debugger' -----------------------------------------
-- Section: '--break' ------------------------------------------
TestMain.cpp:200:
parseIntoConfig( argv, config ) succeeded
line 202:
config.shouldDebugBreak succeeded for: true
----------------------------------------------------------------
Summary for section '--break':
All 2 assertions passed
----------------------------------------------------------------
Summary for section 'debugger':
All 2 assertions passed
-- Section: 'debugger' -----------------------------------------
-- Section: '-b' -----------------------------------------------
TestMain.cpp:206:
parseIntoConfigAndReturnError( argv, config ) Contains( "0 arguments" ) succeeded for:
"Error while parsing arguments. Expected 0 arguments. Arguments were: unexpected" contains: "0 arguments"
----------------------------------------------------------------
Summary for section '-b':
1 assertion passed
----------------------------------------------------------------
Summary for section 'debugger':
1 assertion passed
-- Section: 'abort' --------------------------------------------
-- Section: '-a' -----------------------------------------------
TestMain.cpp:213:
parseIntoConfig( argv, config ) succeeded
line 215:
config.cutoff == 1 succeeded for: 1 == 1
----------------------------------------------------------------
Summary for section '-a':
All 2 assertions passed
----------------------------------------------------------------
Summary for section 'abort':
All 2 assertions passed
-- Section: 'abort' --------------------------------------------
-- Section: '-a/2' ---------------------------------------------
TestMain.cpp:219:
parseIntoConfig( argv, config ) succeeded
line 221:
config.cutoff == 2 succeeded for: 2 == 2
----------------------------------------------------------------
Summary for section '-a/2':
All 2 assertions passed
----------------------------------------------------------------
Summary for section 'abort':
All 2 assertions passed
-- Section: 'abort' --------------------------------------------
-- Section: '-a/error/0' ---------------------------------------
TestMain.cpp:225:
parseIntoConfigAndReturnError( argv, config ) Contains( "greater than zero" ) succeeded for:
"Error while parsing arguments. threshold must be a number greater than zero. Arguments were: 0" contains: "greater than zero"
----------------------------------------------------------------
Summary for section '-a/error/0':
1 assertion passed
----------------------------------------------------------------
Summary for section 'abort':
1 assertion passed
-- Section: 'abort' --------------------------------------------
-- Section: '-a/error/non numeric' -----------------------------
TestMain.cpp:229:
parseIntoConfigAndReturnError( argv, config ) Contains( "greater than zero" ) succeeded for:
"Error while parsing arguments. threshold must be a number greater than zero. Arguments were: oops" contains: "greater than zero"
----------------------------------------------------------------
Summary for section '-a/error/non numeric':
1 assertion passed
----------------------------------------------------------------
Summary for section 'abort':
1 assertion passed
-- Section: 'abort' --------------------------------------------
-- Section: '-a/error/two args' --------------------------------
TestMain.cpp:233:
parseIntoConfigAndReturnError( argv, config ) Contains( "0 and 1 argument" ) succeeded for:
"Error while parsing arguments. Expected between 0 and 1 argument. Arguments were: 1 2" contains: "0 and 1 argument"
----------------------------------------------------------------
Summary for section '-a/error/two args':
1 assertion passed
----------------------------------------------------------------
Summary for section 'abort':
1 assertion passed
-- Section: 'nothrow' ------------------------------------------
-- Section: '-nt' ----------------------------------------------
TestMain.cpp:240:
parseIntoConfig( argv, config ) succeeded
line 242:
config.allowThrows == false succeeded for: false == false
----------------------------------------------------------------
Summary for section '-nt':
All 2 assertions passed
----------------------------------------------------------------
Summary for section 'nothrow':
All 2 assertions passed
-- Section: 'nothrow' ------------------------------------------
-- Section: '--nothrow' ----------------------------------------
TestMain.cpp:246:
parseIntoConfig( argv, config ) succeeded
line 248:
config.allowThrows == false succeeded for: false == false
----------------------------------------------------------------
Summary for section '--nothrow':
All 2 assertions passed
----------------------------------------------------------------
Summary for section 'nothrow':
All 2 assertions passed
-- Section: 'streams' ------------------------------------------
-- Section: '-o filename' --------------------------------------
TestMain.cpp:255:
parseIntoConfig( argv, config ) succeeded
line 257:
config.outputFilename == "filename.ext" succeeded for: "filename.ext" == "filename.ext"
line 258:
config.stream.empty() succeeded for: true
----------------------------------------------------------------
Summary for section '-o filename':
All 3 assertions passed
----------------------------------------------------------------
Summary for section 'streams':
All 3 assertions passed
-- Section: 'streams' ------------------------------------------
-- Section: '-o %stdout' ---------------------------------------
TestMain.cpp:262:
parseIntoConfig( argv, config ) succeeded
line 264:
config.stream == "stdout" succeeded for: "stdout" == "stdout"
line 265:
config.outputFilename.empty() succeeded for: true
----------------------------------------------------------------
Summary for section '-o %stdout':
All 3 assertions passed
----------------------------------------------------------------
Summary for section 'streams':
All 3 assertions passed
-- Section: 'streams' ------------------------------------------
-- Section: '--out' --------------------------------------------
TestMain.cpp:269:
parseIntoConfig( argv, config ) succeeded
line 271:
config.outputFilename == "filename.ext" succeeded for: "filename.ext" == "filename.ext"
----------------------------------------------------------------
Summary for section '--out':
All 2 assertions passed
----------------------------------------------------------------
Summary for section 'streams':
All 2 assertions passed
-- Section: 'combinations' -------------------------------------
-- Section: '-a -b' --------------------------------------------
TestMain.cpp:278:
parseIntoConfig( argv, config ) succeeded
line 280:
config.cutoff == 1 succeeded for: 1 == 1
line 281:
config.shouldDebugBreak succeeded for: true
line 282:
config.allowThrows == false succeeded for: false == false
----------------------------------------------------------------
Summary for section '-a -b':
All 4 assertions passed
----------------------------------------------------------------
Summary for section 'combinations':
All 4 assertions passed
----------------------------------------------------------------
Summary for test case 'selftest/parser/2':
All tests passed (66 assertions in 1 test case)
-- Test case: 'selftest/test filter' ---------------------------
TestMain.cpp:291:
matchAny.shouldInclude( fakeTestCase( "any" ) ) succeeded for: true
line 292:
matchNone.shouldInclude( fakeTestCase( "any" ) ) == false succeeded for: false == false
line 297:
matchHidden.shouldInclude( fakeTestCase( "any" ) ) == false succeeded for: false == false
line 298:
matchNonHidden.shouldInclude( fakeTestCase( "any" ) ) succeeded for: true
line 300:
matchHidden.shouldInclude( fakeTestCase( "./any" ) ) succeeded for: true
line 301:
matchNonHidden.shouldInclude( fakeTestCase( "./any" ) ) == false succeeded for: false == false
----------------------------------------------------------------
Summary for test case 'selftest/test filter':
All tests passed (6 assertions in 1 test case)
-- Test case: 'selftest/test filters' --------------------------
TestMain.cpp:312:
matchHidden.shouldInclude( fakeTestCase( "./something" ) ) succeeded for: true
line 314:
filters.shouldInclude( fakeTestCase( "any" ) ) == false succeeded for: false == false
line 315:
filters.shouldInclude( fakeTestCase( "./something" ) ) succeeded for: true
line 316:
filters.shouldInclude( fakeTestCase( "./anything" ) ) == false succeeded for: false == false
----------------------------------------------------------------
Summary for test case 'selftest/test filters':
All tests passed (4 assertions in 1 test case)
-- Test case: 'selftest/filter/prefix wildcard' ----------------
TestMain.cpp:322:
matchBadgers.shouldInclude( fakeTestCase( "big badger" ) ) succeeded for: true
line 323:
matchBadgers.shouldInclude( fakeTestCase( "little badgers" ) ) == false succeeded for: false == false
----------------------------------------------------------------
Summary for test case 'selftest/filter/prefix wildcard':
All tests passed (2 assertions in 1 test case)
-- Test case: 'selftest/filter/wildcard at both ends' ----------
TestMain.cpp:328:
matchBadgers.shouldInclude( fakeTestCase( "big badger" ) ) succeeded for: true
line 329:
matchBadgers.shouldInclude( fakeTestCase( "little badgers" ) ) succeeded for: true
line 330:
matchBadgers.shouldInclude( fakeTestCase( "badgers are big" ) ) succeeded for: true
line 331:
matchBadgers.shouldInclude( fakeTestCase( "hedgehogs" ) ) == false succeeded for: false == false
----------------------------------------------------------------
Summary for test case 'selftest/filter/wildcard at both ends':
All tests passed (4 assertions in 1 test case)
-- Test case: 'selftest/option parsers' ------------------------
TestMain.cpp:351:
opt.parseIntoConfig( parser, config ) succeeded
line 353:
config.filters.size() == 1 succeeded for: 1 == 1
line 354:
config.filters[0].shouldInclude( fakeTestCase( "notIncluded" ) ) == false succeeded for: false == false
line 355:
config.filters[0].shouldInclude( fakeTestCase( "test1" ) ) succeeded for: true
----------------------------------------------------------------
Summary for test case 'selftest/option parsers':
All tests passed (4 assertions in 1 test case)
-- Test case: 'selftest/tags' ----------------------------------
-- Section: 'one tag' ------------------------------------------
TestMain.cpp:369:
oneTag.getTestCaseInfo().description == "" succeeded for: "" == ""
line 370:
oneTag.hasTag( "one" ) succeeded for: true
line 371:
oneTag.getTags().size() == 1 succeeded for: 1 == 1
line 373:
oneTag.matchesTags( p1 ) == true succeeded for: true == true
line 374:
oneTag.matchesTags( p2 ) == true succeeded for: true == true
line 375:
oneTag.matchesTags( p3 ) == false succeeded for: false == false
line 376:
oneTag.matchesTags( p4 ) == false succeeded for: false == false
line 377:
oneTag.matchesTags( p5 ) == false succeeded for: false == false
----------------------------------------------------------------
Summary for section 'one tag':
All 8 assertions passed
-- Section: 'two tags' -----------------------------------------
TestMain.cpp:383:
twoTags.getTestCaseInfo().description == "" succeeded for: "" == ""
line 384:
twoTags.hasTag( "one" ) succeeded for: true
line 385:
twoTags.hasTag( "two" ) succeeded for: true
line 386:
twoTags.hasTag( "three" ) == false succeeded for: false == false
line 387:
twoTags.getTags().size() == 2 succeeded for: 2 == 2
line 389:
twoTags.matchesTags( p1 ) == true succeeded for: true == true
line 390:
twoTags.matchesTags( p2 ) == true succeeded for: true == true
line 391:
twoTags.matchesTags( p3 ) == true succeeded for: true == true
line 392:
twoTags.matchesTags( p4 ) == true succeeded for: true == true
line 393:
twoTags.matchesTags( p5 ) == true succeeded for: true == true
----------------------------------------------------------------
Summary for section 'two tags':
All 10 assertions passed
-- Section: 'one tag with characters either side' --------------
TestMain.cpp:399:
oneTagWithExtras.getTestCaseInfo().description == "1234" succeeded for: "1234" == "1234"
line 400:
oneTagWithExtras.hasTag( "one" ) succeeded for: true
line 401:
oneTagWithExtras.hasTag( "two" ) == false succeeded for: false == false
line 402:
oneTagWithExtras.getTags().size() == 1 succeeded for: 1 == 1
----------------------------------------------------------------
Summary for section 'one tag with characters either side':
All 4 assertions passed
-- Section: 'start of a tag, but not closed' -------------------
TestMain.cpp:409:
oneTagOpen.getTestCaseInfo().description == "[one" succeeded for: "[one" == "[one"
line 410:
oneTagOpen.hasTag( "one" ) == false succeeded for: false == false
line 411:
oneTagOpen.getTags().size() == 0 succeeded for: 0 == 0
----------------------------------------------------------------
Summary for section 'start of a tag, but not closed':
All 3 assertions passed
-- Section: 'hidden' -------------------------------------------
TestMain.cpp:417:
oneTag.getTestCaseInfo().description == "" succeeded for: "" == ""
line 418:
oneTag.hasTag( "hide" ) succeeded for: true
line 419:
oneTag.isHidden() succeeded for: true
line 421:
oneTag.matchesTags( "~[hide]" ) == false succeeded for: false == false
----------------------------------------------------------------
Summary for section 'hidden':
All 4 assertions passed
----------------------------------------------------------------
Summary for test case 'selftest/tags':
All tests passed (29 assertions in 1 test case)
-- Test case: './succeeding/Tricky/std::pair' ------------------
TrickyTests.cpp:37:
(std::pair<int, int>( 1, 2 )) == aNicePair succeeded for:
std::pair( 1, 2 )
==
std::pair( 1, 2 )
----------------------------------------------------------------
Summary for test case './succeeding/Tricky/std::pair':
All tests passed (1 assertion in 1 test case)
-- Test case: './inprogress/failing/Tricky/trailing expression'
TrickyTests.cpp:55:
[warning: Uncomment the code in this test to check that it gives a sensible compiler error]
No assertions in test case, './inprogress/failing/Tricky/trailing expression'
----------------------------------------------------------------
Summary for test case './inprogress/failing/Tricky/trailing expression':
1 test case - failed (1 assertion - failed)
-- Test case: './inprogress/failing/Tricky/compound lhs' -------
TrickyTests.cpp:71:
[warning: Uncomment the code in this test to check that it gives a sensible compiler error]
No assertions in test case, './inprogress/failing/Tricky/compound lhs'
----------------------------------------------------------------
Summary for test case './inprogress/failing/Tricky/compound lhs':
1 test case - failed (1 assertion - failed)
-- Test case: './failing/Tricky/non streamable type' -----------
TrickyTests.cpp:95:
&o1 == &o2 failed for: 0x<hex digits> == 0x<hex digits>
line 96:
o1 == o2 failed for: {?} == {?}
----------------------------------------------------------------
Summary for test case './failing/Tricky/non streamable type':
1 test case - failed (2 assertions - both failed)
-- Test case: './failing/string literals' ----------------------
TrickyTests.cpp:106:
std::string( "first" ) == "second" failed for: "first" == "second"
----------------------------------------------------------------
Summary for test case './failing/string literals':
1 test case - failed (1 assertion - failed)
-- Test case: './succeeding/side-effects' ----------------------
TrickyTests.cpp:119:
i++ == 7 succeeded for: 7 == 7
line 120:
i++ == 8 succeeded for: 8 == 8
----------------------------------------------------------------
Summary for test case './succeeding/side-effects':
All tests passed (2 assertions in 1 test case)
-- Test case: './succeeding/koenig' ----------------------------
TrickyTests.cpp:186:
0x<hex digits> == o succeeded for: 0x<hex digits> == {?}
----------------------------------------------------------------
Summary for test case './succeeding/koenig':
All tests passed (1 assertion in 1 test case)
-- Test case: './succeeding/non-const==' -----------------------
TrickyTests.cpp:212:
t == 1u succeeded for: {?} == 1
----------------------------------------------------------------
Summary for test case './succeeding/non-const==':
All tests passed (1 assertion in 1 test case)
-- Test case: './succeeding/enum/bits' -------------------------
TrickyTests.cpp:224:
0x<hex digits> == bit30and31 succeeded for: 0x<hex digits> == 3221225472
----------------------------------------------------------------
Summary for test case './succeeding/enum/bits':
All tests passed (1 assertion in 1 test case)
-- Test case: './succeeding/boolean member' --------------------
TrickyTests.cpp:239:
obj.prop != __null succeeded for: 0x<hex digits> != 0
----------------------------------------------------------------
Summary for test case './succeeding/boolean member':
All tests passed (1 assertion in 1 test case)
-- Test case: './succeeding/unimplemented static bool' ---------
-- Section: 'compare to true' ----------------------------------
TrickyTests.cpp:259:
is_true<true>::value == true succeeded for: true == true
line 260:
true == is_true<true>::value succeeded for: true == true
----------------------------------------------------------------
Summary for section 'compare to true':
All 2 assertions passed
-- Section: 'compare to false' ---------------------------------
TrickyTests.cpp:264:
is_true<false>::value == false succeeded for: false == false
line 265:
false == is_true<false>::value succeeded for: false == false
----------------------------------------------------------------
Summary for section 'compare to false':
All 2 assertions passed
-- Section: 'negation' -----------------------------------------
TrickyTests.cpp:270:
!is_true<false>::value succeeded for: true
----------------------------------------------------------------
Summary for section 'negation':
1 assertion passed
-- Section: 'double negation' ----------------------------------
TrickyTests.cpp:275:
!!is_true<true>::value succeeded for: true
----------------------------------------------------------------
Summary for section 'double negation':
1 assertion passed
-- Section: 'direct' -------------------------------------------
TrickyTests.cpp:280:
is_true<true>::value succeeded for: true
line 281:
!is_true<false>::value succeeded for: !false
----------------------------------------------------------------
Summary for section 'direct':
All 2 assertions passed
----------------------------------------------------------------
Summary for test case './succeeding/unimplemented static bool':
All tests passed (8 assertions in 1 test case)
-- Test case: './succeeding/SafeBool' --------------------------
TrickyTests.cpp:313:
True succeeded for: true
line 314:
!False succeeded for: true
line 315:
!False succeeded for: !false
----------------------------------------------------------------
Summary for test case './succeeding/SafeBool':
All tests passed (3 assertions in 1 test case)
-- Test case: 'scenario name' ----------------------------------
-- Section: 'This stuff exists' --------------------------------
-- Section: 'I do this' ----------------------------------------
-- Section: 'it should do this' --------------------------------
BDDTests.cpp:37:
itDoesThis() succeeded for: true
----------------------------------------------------------------
Summary for section 'it should do this':
1 assertion passed
----------------------------------------------------------------
Summary for section 'I do this':
1 assertion passed
----------------------------------------------------------------
Summary for section 'This stuff exists':
1 assertion passed
----------------------------------------------------------------
Summary for test case 'scenario name':
All tests passed (1 assertion in 1 test case)
----------------------------------------------------------------
Summary for group '~dummy':
95 test cases - 44 failed (607 assertions - 101 failed)
================================================================
Summary for all tests in 'CatchSelfTest':
95 test cases - 44 failed (607 assertions - 101 failed)
-- Started testing: 'CatchSelfTest' ----------------------------
-- Group: '~dummy' ---------------------------------------------
-- Test case: './succeeding/Approx/simple' ---------------------
ApproxTests.cpp:20:
d == Approx( 1.23 ) succeeded for: 1.23 == Approx( 1.23 )
line 21:
d != Approx( 1.22 ) succeeded for: 1.23 != Approx( 1.22 )
line 22:
d != Approx( 1.24 ) succeeded for: 1.23 != Approx( 1.24 )
line 24:
Approx( d ) == 1.23 succeeded for: Approx( 1.23 ) == 1.23
line 25:
Approx( d ) != 1.22 succeeded for: Approx( 1.23 ) != 1.22
line 26:
Approx( d ) != 1.24 succeeded for: Approx( 1.23 ) != 1.24
----------------------------------------------------------------
Summary for test case './succeeding/Approx/simple':
All tests passed (6 assertions in 1 test case)
-- Test case: './succeeding/Approx/epsilon' --------------------
ApproxTests.cpp:38:
d != Approx( 1.231 ) succeeded for: 1.23 != Approx( 1.231 )
line 39:
d == Approx( 1.231 ).epsilon( 0.1 ) succeeded for: 1.23 == Approx( 1.231 )
----------------------------------------------------------------
Summary for test case './succeeding/Approx/epsilon':
All tests passed (2 assertions in 1 test case)
-- Test case: './succeeding/Approx/float' ----------------------
ApproxTests.cpp:49:
1.23f == Approx( 1.23f ) succeeded for: 1.23 == Approx( 1.23 )
line 50:
0.0f == Approx( 0.0f ) succeeded for: 0 == Approx( 0 )
----------------------------------------------------------------
Summary for test case './succeeding/Approx/float':
All tests passed (2 assertions in 1 test case)
-- Test case: './succeeding/Approx/int' ------------------------
ApproxTests.cpp:60:
1 == Approx( 1 ) succeeded
line 61:
0 == Approx( 0 ) succeeded
----------------------------------------------------------------
Summary for test case './succeeding/Approx/int':
All tests passed (2 assertions in 1 test case)
-- Test case: './succeeding/Approx/mixed' ----------------------
ApproxTests.cpp:75:
1.0f == Approx( 1 ) succeeded for: 1 == Approx( 1 )
line 76:
0 == Approx( dZero) succeeded for: 0 == Approx( 0 )
line 77:
0 == Approx( dSmall ).epsilon( 0.001 ) succeeded for: 0 == Approx( 1e-05 )
line 78:
1.234f == Approx( dMedium ) succeeded for: 1.234 == Approx( 1.234 )
line 79:
dMedium == Approx( 1.234f ) succeeded for: 1.234 == Approx( 1.234 )
----------------------------------------------------------------
Summary for test case './succeeding/Approx/mixed':
All tests passed (5 assertions in 1 test case)
-- Test case: './succeeding/Approx/custom' ---------------------
ApproxTests.cpp:93:
d == approx( 1.23 ) succeeded for: 1.23 == Approx( 1.23 )
line 94:
d == approx( 1.22 ) succeeded for: 1.23 == Approx( 1.22 )
line 95:
d == approx( 1.24 ) succeeded for: 1.23 == Approx( 1.24 )
line 96:
d != approx( 1.25 ) succeeded for: 1.23 != Approx( 1.25 )
line 98:
approx( d ) == 1.23 succeeded for: Approx( 1.23 ) == 1.23
line 99:
approx( d ) == 1.22 succeeded for: Approx( 1.23 ) == 1.22
line 100:
approx( d ) == 1.24 succeeded for: Approx( 1.23 ) == 1.24
line 101:
approx( d ) != 1.25 succeeded for: Approx( 1.23 ) != 1.25
----------------------------------------------------------------
Summary for test case './succeeding/Approx/custom':
All tests passed (8 assertions in 1 test case)
-- Test case: './succeeding/TestClass/succeedingCase' ----------
ClassTests.cpp:24:
s == "hello" succeeded for: "hello" == "hello"
----------------------------------------------------------------
Summary for test case './succeeding/TestClass/succeedingCase':
All tests passed (1 assertion in 1 test case)
-- Test case: './failing/TestClass/failingCase' ----------------
ClassTests.cpp:28:
s == "world" failed for: "hello" == "world"
----------------------------------------------------------------
Summary for test case './failing/TestClass/failingCase':
1 test case - failed (1 assertion - failed)
-- Test case: './succeeding/Fixture/succeedingCase' ------------
ClassTests.cpp:47:
m_a == 1 succeeded for: 1 == 1
----------------------------------------------------------------
Summary for test case './succeeding/Fixture/succeedingCase':
All tests passed (1 assertion in 1 test case)
-- Test case: './failing/Fixture/failingCase' ------------------
ClassTests.cpp:55:
m_a == 2 failed for: 1 == 2
----------------------------------------------------------------
Summary for test case './failing/Fixture/failingCase':
1 test case - failed (1 assertion - failed)
-- Test case: './succeeding/conditions/equality' ---------------
ConditionTests.cpp:55:
data.int_seven == 7 succeeded for: 7 == 7
line 56:
data.float_nine_point_one == Approx( 9.1f ) succeeded for: 9.1 == Approx( 9.1 )
line 57:
data.double_pi == Approx( 3.1415926535 ) succeeded for: 3.14159 == Approx( 3.14159 )
line 58:
data.str_hello == "hello" succeeded for: "hello" == "hello"
line 59:
"hello" == data.str_hello succeeded for: "hello" == "hello"
line 60:
data.str_hello.size() == 5 succeeded for: 5 == 5
line 63:
x == Approx( 1.3 ) succeeded for: 1.3 == Approx( 1.3 )
----------------------------------------------------------------
Summary for test case './succeeding/conditions/equality':
All tests passed (7 assertions in 1 test case)
-- Test case: './failing/conditions/equality' ------------------
ConditionTests.cpp:71:
data.int_seven == 6 failed for: 7 == 6
line 72:
data.int_seven == 8 failed for: 7 == 8
----------------------------------------------------------------
Summary for test case './failing/conditions/equality':
1 test case - failed (2 assertions - both failed)
----------------------------------------------------------------
Summary for group '~dummy':
12 test cases - 3 failed (38 assertions - 4 failed)
================================================================
Summary for all tests in 'CatchSelfTest':
12 test cases - 3 failed (38 assertions - 4 failed)
<testsuites>
<testsuite name="~dummy" errors="8" failures="76" tests="607" hostname="tbd" time="tbd" timestamp="tbd">
<testcase classname="global" name="./succeeding/Approx/simple" time="tbd"/>
<testcase classname="global" name="./succeeding/Approx/epsilon" time="tbd"/>
<testcase classname="global" name="./succeeding/Approx/float" time="tbd"/>
<testcase classname="global" name="./succeeding/Approx/int" time="tbd"/>
<testcase classname="global" name="./succeeding/Approx/mixed" time="tbd"/>
<testcase classname="global" name="./succeeding/Approx/custom" time="tbd"/>
<testcase classname="TestClass" name="./succeeding/TestClass/succeedingCase" time="tbd"/>
<testcase classname="TestClass" name="./failing/TestClass/failingCase" time="tbd">
<failure message="&quot;hello&quot; == &quot;world&quot;" type="REQUIRE">
ClassTests.cpp:28:
</failure>
</testcase>
<testcase classname="Fixture" name="./succeeding/Fixture/succeedingCase" time="tbd"/>
<testcase classname="Fixture" name="./failing/Fixture/failingCase" time="tbd">
<failure message="1 == 2" type="REQUIRE">
ClassTests.cpp:55:
</failure>
</testcase>
<testcase classname="global" name="./succeeding/conditions/equality" time="tbd"/>
<testcase classname="global" name="./failing/conditions/equality" time="tbd">
<failure message="7 == 6" type="CHECK">
ConditionTests.cpp:71:
</failure>
<failure message="7 == 8" type="CHECK">
ConditionTests.cpp:72:
</failure>
<failure message="7 == 0" type="CHECK">
ConditionTests.cpp:73:
</failure>
<failure message="9.1 == Approx( 9.11 )" type="CHECK">
ConditionTests.cpp:74:
</failure>
<failure message="9.1 == Approx( 9 )" type="CHECK">
ConditionTests.cpp:75:
</failure>
<failure message="9.1 == Approx( 1 )" type="CHECK">
ConditionTests.cpp:76:
</failure>
<failure message="9.1 == Approx( 0 )" type="CHECK">
ConditionTests.cpp:77:
</failure>
<failure message="3.14159 == Approx( 3.1415 )" type="CHECK">
ConditionTests.cpp:78:
</failure>
<failure message="&quot;hello&quot; == &quot;goodbye&quot;" type="CHECK">
ConditionTests.cpp:79:
</failure>
<failure message="&quot;hello&quot; == &quot;hell&quot;" type="CHECK">
ConditionTests.cpp:80:
</failure>
<failure message="&quot;hello&quot; == &quot;hello1&quot;" type="CHECK">
ConditionTests.cpp:81:
</failure>
<failure message="5 == 6" type="CHECK">
ConditionTests.cpp:82:
</failure>
<failure message="1.3 == Approx( 1.301 )" type="CHECK">
ConditionTests.cpp:85:
</failure>
</testcase>
<testcase classname="global" name="./succeeding/conditions/inequality" time="tbd"/>
<testcase classname="global" name="./failing/conditions/inequality" time="tbd">
<failure message="7 != 7" type="CHECK">
ConditionTests.cpp:111:
</failure>
<failure message="9.1 != Approx( 9.1 )" type="CHECK">
ConditionTests.cpp:112:
</failure>
<failure message="3.14159 != Approx( 3.14159 )" type="CHECK">
ConditionTests.cpp:113:
</failure>
<failure message="&quot;hello&quot; != &quot;hello&quot;" type="CHECK">
ConditionTests.cpp:114:
</failure>
<failure message="5 != 5" type="CHECK">
ConditionTests.cpp:115:
</failure>
</testcase>
<testcase classname="global" name="./succeeding/conditions/ordered" time="tbd"/>
<testcase classname="global" name="./failing/conditions/ordered" time="tbd">
<failure message="7 > 7" type="CHECK">
ConditionTests.cpp:152:
</failure>
<failure message="7 &lt; 7" type="CHECK">
ConditionTests.cpp:153:
</failure>
<failure message="7 > 8" type="CHECK">
ConditionTests.cpp:154:
</failure>
<failure message="7 &lt; 6" type="CHECK">
ConditionTests.cpp:155:
</failure>
<failure message="7 &lt; 0" type="CHECK">
ConditionTests.cpp:156:
</failure>
<failure message="7 &lt; -1" type="CHECK">
ConditionTests.cpp:157:
</failure>
<failure message="7 >= 8" type="CHECK">
ConditionTests.cpp:159:
</failure>
<failure message="7 &lt;= 6" type="CHECK">
ConditionTests.cpp:160:
</failure>
<failure message="9.1 &lt; 9" type="CHECK">
ConditionTests.cpp:162:
</failure>
<failure message="9.1 > 10" type="CHECK">
ConditionTests.cpp:163:
</failure>
<failure message="9.1 > 9.2" type="CHECK">
ConditionTests.cpp:164:
</failure>
<failure message="&quot;hello&quot; > &quot;hello&quot;" type="CHECK">
ConditionTests.cpp:166:
</failure>
<failure message="&quot;hello&quot; &lt; &quot;hello&quot;" type="CHECK">
ConditionTests.cpp:167:
</failure>
<failure message="&quot;hello&quot; > &quot;hellp&quot;" type="CHECK">
ConditionTests.cpp:168:
</failure>
<failure message="&quot;hello&quot; > &quot;z&quot;" type="CHECK">
ConditionTests.cpp:169:
</failure>
<failure message="&quot;hello&quot; &lt; &quot;hellm&quot;" type="CHECK">
ConditionTests.cpp:170:
</failure>
<failure message="&quot;hello&quot; &lt; &quot;a&quot;" type="CHECK">
ConditionTests.cpp:171:
</failure>
<failure message="&quot;hello&quot; >= &quot;z&quot;" type="CHECK">
ConditionTests.cpp:173:
</failure>
<failure message="&quot;hello&quot; &lt;= &quot;a&quot;" type="CHECK">
ConditionTests.cpp:174:
</failure>
</testcase>
<testcase classname="global" name="./succeeding/conditions/int literals" time="tbd"/>
<testcase classname="global" name="./succeeding/conditions//long_to_unsigned_x" time="tbd"/>
<testcase classname="global" name="./succeeding/conditions/const ints to int literal" time="tbd"/>
<testcase classname="global" name="./succeeding/conditions/negative ints" time="tbd"/>
<testcase classname="global" name="./succeeding/conditions/computed ints" time="tbd"/>
<testcase classname="global" name="./succeeding/conditions/ptr" time="tbd"/>
<testcase classname="global" name="./succeeding/conditions/not" time="tbd"/>
<testcase classname="global" name="./failing/conditions/not" time="tbd">
<failure message="false != false" type="CHECK">
ConditionTests.cpp:334:
</failure>
<failure message="true != true" type="CHECK">
ConditionTests.cpp:335:
</failure>
<failure message="false" type="CHECK">
ConditionTests.cpp:336:
</failure>
<failure message="!true" type="CHECK_FALSE">
ConditionTests.cpp:337:
</failure>
<failure message="false" type="CHECK">
ConditionTests.cpp:339:
</failure>
<failure message="!true" type="CHECK_FALSE">
ConditionTests.cpp:340:
</failure>
<failure message="false" type="CHECK">
ConditionTests.cpp:342:
</failure>
<failure message="!(1 == 1)" type="CHECK_FALSE">
ConditionTests.cpp:343:
</failure>
</testcase>
<testcase classname="global" name="./succeeding/exceptions/explicit" time="tbd"/>
<testcase classname="global" name="./failing/exceptions/explicit" time="tbd">
<error message="thisThrows()" type="CHECK_THROWS_AS">
ExceptionTests.cpp:47:
</error>
< message="thisDoesntThrow()" type="CHECK_THROWS_AS">
ExceptionTests.cpp:48:
</>
<error message="thisThrows()" type="CHECK_NOTHROW">
ExceptionTests.cpp:49:
</error>
</testcase>
<testcase classname="global" name="./failing/exceptions/implicit" time="tbd">
<error type="TEST_CASE">
ExceptionTests.cpp:52:
</error>
</testcase>
<testcase classname="global" name="./failing/exceptions/implicit/2" time="tbd">
<error message="{Unknown expression after this line}">
ExceptionTests.cpp:60:
</error>
</testcase>
<testcase classname="global" name="./succeeding/exceptions/implicit" time="tbd"/>
<testcase classname="global" name="./failing/exceptions/custom" time="tbd">
<error type="TEST_CASE">
ExceptionTests.cpp:102:
</error>
</testcase>
<testcase classname="global" name="./failing/exceptions/custom/nothrow" time="tbd">
<error message="throw CustomException( &quot;unexpected custom exception&quot; )" type="REQUIRE_NOTHROW">
ExceptionTests.cpp:109:
</error>
</testcase>
<testcase classname="global" name="./failing/exceptions/custom/throw" time="tbd">
<error message="throw CustomException( &quot;custom exception - not std&quot; )" type="REQUIRE_THROWS_AS">
ExceptionTests.cpp:114:
</error>
</testcase>
<testcase classname="global" name="./failing/exceptions/custom/double" time="tbd">
<error type="TEST_CASE">
ExceptionTests.cpp:118:
</error>
</testcase>
<testcase classname="global" name="./succeeding/exceptions/notimplemented" time="tbd"/>
<testcase classname="global" name="./succeeding/generators/1" time="tbd"/>
<testcase classname="global" name="./succeeding/message" time="tbd">
<warning type="WARN">
MessageTests.cpp:14:
</warning>
</testcase>
<testcase classname="global" name="./succeeding/succeed" time="tbd"/>
<testcase classname="global" name="./failing/message/info/1" time="tbd">
<info type="INFO">
MessageTests.cpp:23:
</info>
<info type="INFO">
MessageTests.cpp:24:
</info>
<failure message="2 == 1" type="REQUIRE">
MessageTests.cpp:26:
</failure>
</testcase>
<testcase classname="global" name="./mixed/message/info/2" time="tbd">
<info type="INFO">
MessageTests.cpp:31:
</info>
<info type="INFO">
MessageTests.cpp:35:
</info>
<failure message="2 == 1" type="CHECK">
MessageTests.cpp:37:
</failure>
<info type="INFO">
MessageTests.cpp:39:
</info>
<failure message="2 == 0" type="CHECK">
MessageTests.cpp:41:
</failure>
</testcase>
<testcase classname="global" name="./failing/message/fail" time="tbd">
<failure type="FAIL">
MessageTests.cpp:51:
</failure>
</testcase>
<testcase classname="global" name="./failing/message/sections" time="tbd">
<failure type="FAIL">
MessageTests.cpp:58:
</failure>
<failure type="FAIL">
MessageTests.cpp:63:
</failure>
</testcase>
<testcase classname="global" name="./succeeding/message/sections/stdout" time="tbd">
<system-out>
Message from section one
Message from section two
</system-out>
</testcase>
<testcase classname="global" name="./mixed/message/scoped" time="tbd">
<info message="i &lt; 10" type="REQUIRE">
MessageTests.cpp:86:
</info>
<info message="i &lt; 10" type="REQUIRE">
MessageTests.cpp:86:
</info>
<failure message="10 &lt; 10" type="REQUIRE">
MessageTests.cpp:86:
</failure>
</testcase>
<testcase classname="global" name="./succeeding/nofail" time="tbd">
<failure message="1 == 2" type="CHECK_NOFAIL">
MessageTests.cpp:92:
</failure>
</testcase>
<testcase classname="global" name="./succeeding/Misc/Sections" time="tbd"/>
<testcase classname="global" name="./succeeding/Misc/Sections/nested" time="tbd"/>
<testcase classname="global" name="./mixed/Misc/Sections/nested2" time="tbd">
<failure message="1 == 2" type="REQUIRE">
MiscTests.cpp:61:
</failure>
</testcase>
<testcase classname="global" name="./Sections/nested/a/b" time="tbd"/>
<testcase classname="global" name="./mixed/Misc/Sections/loops" time="tbd">
<failure message="0 > 1" type="CHECK">
MiscTests.cpp:103:
</failure>
</testcase>
<testcase classname="global" name="./mixed/Misc/loops" time="tbd">
<info type="INFO">
MiscTests.cpp:114:
</info>
<failure message="1 == 0" type="CHECK">
MiscTests.cpp:115:
</failure>
<info type="INFO">
MiscTests.cpp:114:
</info>
<failure message="1 == 0" type="CHECK">
MiscTests.cpp:115:
</failure>
<info type="INFO">
MiscTests.cpp:114:
</info>
<info type="INFO">
MiscTests.cpp:114:
</info>
<failure message="1 == 0" type="CHECK">
MiscTests.cpp:115:
</failure>
<info type="INFO">
MiscTests.cpp:114:
</info>
<failure message="1 == 0" type="CHECK">
MiscTests.cpp:115:
</failure>
<info type="INFO">
MiscTests.cpp:114:
</info>
<info type="INFO">
MiscTests.cpp:114:
</info>
<failure message="1 == 0" type="CHECK">
MiscTests.cpp:115:
</failure>
<info type="INFO">
MiscTests.cpp:114:
</info>
<failure message="1 == 0" type="CHECK">
MiscTests.cpp:115:
</failure>
</testcase>
<testcase classname="global" name="./succeeding/Misc/stdout,stderr" time="tbd">
<system-out>
Some information
</system-out>
<system-err>
An error
</system-err>
</testcase>
<testcase classname="global" name="./succeeding/Misc/null strings" time="tbd"/>
<testcase classname="global" name="./failing/info" time="tbd">
<info type="INFO">
MiscTests.cpp:139:
</info>
<info type="CAPTURE">
MiscTests.cpp:141:
</info>
<failure message="false" type="REQUIRE">
MiscTests.cpp:142:
</failure>
</testcase>
<testcase classname="global" name="./succeeding/checkedif" time="tbd"/>
<testcase classname="global" name="./failing/checkedif" time="tbd">
<failure message="false" type="CHECKED_IF">
MiscTests.cpp:147:
</failure>
<failure message="false" type="REQUIRE">
MiscTests.cpp:160:
</failure>
</testcase>
<testcase classname="global" name="./succeeding/checkedelse" time="tbd"/>
<testcase classname="global" name="./failing/checkedelse" time="tbd">
<failure message="false" type="CHECKED_ELSE">
MiscTests.cpp:165:
</failure>
<failure message="false" type="REQUIRE">
MiscTests.cpp:178:
</failure>
</testcase>
<testcase classname="global" name="./misc/xmlentitycheck" time="tbd"/>
<testcase classname="global" name="./manual/onechar" time="tbd">
<info type="INFO">
MiscTests.cpp:195:
</info>
<failure message="false" type="REQUIRE">
MiscTests.cpp:196:
</failure>
</testcase>
<testcase classname="global" name="./succeeding/atomic if" time="tbd"/>
<testcase classname="global" name="./succeeding/matchers" time="tbd"/>
<testcase classname="global" name="./failing/matchers/Contains" time="tbd">
<failure message="&quot;this string contains 'abc' as a substring&quot; contains: &quot;not there&quot;" type="CHECK_THAT">
MiscTests.cpp:225:
</failure>
</testcase>
<testcase classname="global" name="./failing/matchers/StartsWith" time="tbd">
<failure message="&quot;this string contains 'abc' as a substring&quot; starts with: &quot;string&quot;" type="CHECK_THAT">
MiscTests.cpp:230:
</failure>
</testcase>
<testcase classname="global" name="./failing/matchers/EndsWith" time="tbd">
<failure message="&quot;this string contains 'abc' as a substring&quot; ends with: &quot;this&quot;" type="CHECK_THAT">
MiscTests.cpp:235:
</failure>
</testcase>
<testcase classname="global" name="./failing/matchers/Equals" time="tbd">
<failure message="&quot;this string contains 'abc' as a substring&quot; equals: &quot;something else&quot;" type="CHECK_THAT">
MiscTests.cpp:240:
</failure>
</testcase>
<testcase classname="global" name="/succeeding/matchers/AllOf" time="tbd"/>
<testcase classname="global" name="/succeeding/matchers/AnyOf" time="tbd"/>
<testcase classname="global" name="./succeeding/matchers/Equals" time="tbd"/>
<testcase classname="global" name="example/factorial" time="tbd"/>
<testcase classname="global" name="empty" time="tbd"/>
<testcase classname="global" name="Nice descriptive name" time="tbd">
<warning type="WARN">
MiscTests.cpp:279:
</warning>
</testcase>
<testcase classname="global" name="first tag" time="tbd"/>
<testcase classname="global" name="second tag" time="tbd"/>
<testcase classname="global" name="selftest/main" time="tbd">
<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="tbd"/>
<testcase classname="global" name="selftest/parser/2" time="tbd"/>
<testcase classname="global" name="selftest/test filter" time="tbd"/>
<testcase classname="global" name="selftest/test filters" time="tbd"/>
<testcase classname="global" name="selftest/filter/prefix wildcard" time="tbd"/>
<testcase classname="global" name="selftest/filter/wildcard at both ends" time="tbd"/>
<testcase classname="global" name="selftest/option parsers" time="tbd"/>
<testcase classname="global" name="selftest/tags" time="tbd"/>
<testcase classname="global" name="./succeeding/Tricky/std::pair" time="tbd"/>
<testcase classname="global" name="./inprogress/failing/Tricky/trailing expression" time="tbd">
<warning type="WARN">
TrickyTests.cpp:55:
</warning>
</testcase>
<testcase classname="global" name="./inprogress/failing/Tricky/compound lhs" time="tbd">
<warning type="WARN">
TrickyTests.cpp:71:
</warning>
</testcase>
<testcase classname="global" name="./failing/Tricky/non streamable type" time="tbd">
<failure message="0x<hex digits> == 0x<hex digits>" type="CHECK">
TrickyTests.cpp:95:
</failure>
<failure message="{?} == {?}" type="CHECK">
TrickyTests.cpp:96:
</failure>
</testcase>
<testcase classname="global" name="./failing/string literals" time="tbd">
<failure message="&quot;first&quot; == &quot;second&quot;" type="REQUIRE">
TrickyTests.cpp:106:
</failure>
</testcase>
<testcase classname="global" name="./succeeding/side-effects" time="tbd"/>
<testcase classname="global" name="./succeeding/koenig" time="tbd"/>
<testcase classname="global" name="./succeeding/non-const==" time="tbd"/>
<testcase classname="global" name="./succeeding/enum/bits" time="tbd"/>
<testcase classname="global" name="./succeeding/boolean member" time="tbd"/>
<testcase classname="global" name="./succeeding/unimplemented static bool" time="tbd"/>
<testcase classname="global" name="./succeeding/SafeBool" time="tbd"/>
<testcase classname="global" name="scenario name" time="tbd"/>
</testsuite>
<system-out>
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
</system-out>
<system-err>
An error
An error
An error
</system-err>
</testsuites>
<Catch name="CatchSelfTest">
<Group name="~dummy">
<TestCase name="./succeeding/Approx/simple">
ApproxTests.cpp" line="20">
<Original>
d == Approx( 1.23 )
</Original>
<Expanded>
1.23 == Approx( 1.23 )
</Expanded>
</Expression>
ApproxTests.cpp" line="21">
<Original>
d != Approx( 1.22 )
</Original>
<Expanded>
1.23 != Approx( 1.22 )
</Expanded>
</Expression>
ApproxTests.cpp" line="22">
<Original>
d != Approx( 1.24 )
</Original>
<Expanded>
1.23 != Approx( 1.24 )
</Expanded>
</Expression>
ApproxTests.cpp" line="24">
<Original>
Approx( d ) == 1.23
</Original>
<Expanded>
Approx( 1.23 ) == 1.23
</Expanded>
</Expression>
ApproxTests.cpp" line="25">
<Original>
Approx( d ) != 1.22
</Original>
<Expanded>
Approx( 1.23 ) != 1.22
</Expanded>
</Expression>
ApproxTests.cpp" line="26">
<Original>
Approx( d ) != 1.24
</Original>
<Expanded>
Approx( 1.23 ) != 1.24
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/Approx/epsilon">
ApproxTests.cpp" line="38">
<Original>
d != Approx( 1.231 )
</Original>
<Expanded>
1.23 != Approx( 1.231 )
</Expanded>
</Expression>
ApproxTests.cpp" line="39">
<Original>
d == Approx( 1.231 ).epsilon( 0.1 )
</Original>
<Expanded>
1.23 == Approx( 1.231 )
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/Approx/float">
ApproxTests.cpp" line="49">
<Original>
1.23f == Approx( 1.23f )
</Original>
<Expanded>
1.23 == Approx( 1.23 )
</Expanded>
</Expression>
ApproxTests.cpp" line="50">
<Original>
0.0f == Approx( 0.0f )
</Original>
<Expanded>
0 == Approx( 0 )
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/Approx/int">
ApproxTests.cpp" line="60">
<Original>
1 == Approx( 1 )
</Original>
<Expanded>
1 == Approx( 1 )
</Expanded>
</Expression>
ApproxTests.cpp" line="61">
<Original>
0 == Approx( 0 )
</Original>
<Expanded>
0 == Approx( 0 )
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/Approx/mixed">
ApproxTests.cpp" line="75">
<Original>
1.0f == Approx( 1 )
</Original>
<Expanded>
1 == Approx( 1 )
</Expanded>
</Expression>
ApproxTests.cpp" line="76">
<Original>
0 == Approx( dZero)
</Original>
<Expanded>
0 == Approx( 0 )
</Expanded>
</Expression>
ApproxTests.cpp" line="77">
<Original>
0 == Approx( dSmall ).epsilon( 0.001 )
</Original>
<Expanded>
0 == Approx( 1e-05 )
</Expanded>
</Expression>
ApproxTests.cpp" line="78">
<Original>
1.234f == Approx( dMedium )
</Original>
<Expanded>
1.234 == Approx( 1.234 )
</Expanded>
</Expression>
ApproxTests.cpp" line="79">
<Original>
dMedium == Approx( 1.234f )
</Original>
<Expanded>
1.234 == Approx( 1.234 )
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/Approx/custom">
ApproxTests.cpp" line="93">
<Original>
d == approx( 1.23 )
</Original>
<Expanded>
1.23 == Approx( 1.23 )
</Expanded>
</Expression>
ApproxTests.cpp" line="94">
<Original>
d == approx( 1.22 )
</Original>
<Expanded>
1.23 == Approx( 1.22 )
</Expanded>
</Expression>
ApproxTests.cpp" line="95">
<Original>
d == approx( 1.24 )
</Original>
<Expanded>
1.23 == Approx( 1.24 )
</Expanded>
</Expression>
ApproxTests.cpp" line="96">
<Original>
d != approx( 1.25 )
</Original>
<Expanded>
1.23 != Approx( 1.25 )
</Expanded>
</Expression>
ApproxTests.cpp" line="98">
<Original>
approx( d ) == 1.23
</Original>
<Expanded>
Approx( 1.23 ) == 1.23
</Expanded>
</Expression>
ApproxTests.cpp" line="99">
<Original>
approx( d ) == 1.22
</Original>
<Expanded>
Approx( 1.23 ) == 1.22
</Expanded>
</Expression>
ApproxTests.cpp" line="100">
<Original>
approx( d ) == 1.24
</Original>
<Expanded>
Approx( 1.23 ) == 1.24
</Expanded>
</Expression>
ApproxTests.cpp" line="101">
<Original>
approx( d ) != 1.25
</Original>
<Expanded>
Approx( 1.23 ) != 1.25
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/TestClass/succeedingCase">
ClassTests.cpp" line="24">
<Original>
s == &quot;hello&quot;
</Original>
<Expanded>
&quot;hello&quot; == &quot;hello&quot;
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/TestClass/failingCase">
ClassTests.cpp" line="28">
<Original>
s == &quot;world&quot;
</Original>
<Expanded>
&quot;hello&quot; == &quot;world&quot;
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/Fixture/succeedingCase">
ClassTests.cpp" line="47">
<Original>
m_a == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/Fixture/failingCase">
ClassTests.cpp" line="55">
<Original>
m_a == 2
</Original>
<Expanded>
1 == 2
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/conditions/equality">
ConditionTests.cpp" line="55">
<Original>
data.int_seven == 7
</Original>
<Expanded>
7 == 7
</Expanded>
</Expression>
ConditionTests.cpp" line="56">
<Original>
data.float_nine_point_one == Approx( 9.1f )
</Original>
<Expanded>
9.1 == Approx( 9.1 )
</Expanded>
</Expression>
ConditionTests.cpp" line="57">
<Original>
data.double_pi == Approx( 3.1415926535 )
</Original>
<Expanded>
3.14159 == Approx( 3.14159 )
</Expanded>
</Expression>
ConditionTests.cpp" line="58">
<Original>
data.str_hello == &quot;hello&quot;
</Original>
<Expanded>
&quot;hello&quot; == &quot;hello&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="59">
<Original>
&quot;hello&quot; == data.str_hello
</Original>
<Expanded>
&quot;hello&quot; == &quot;hello&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="60">
<Original>
data.str_hello.size() == 5
</Original>
<Expanded>
5 == 5
</Expanded>
</Expression>
ConditionTests.cpp" line="63">
<Original>
x == Approx( 1.3 )
</Original>
<Expanded>
1.3 == Approx( 1.3 )
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/conditions/equality">
ConditionTests.cpp" line="71">
<Original>
data.int_seven == 6
</Original>
<Expanded>
7 == 6
</Expanded>
</Expression>
ConditionTests.cpp" line="72">
<Original>
data.int_seven == 8
</Original>
<Expanded>
7 == 8
</Expanded>
</Expression>
ConditionTests.cpp" line="73">
<Original>
data.int_seven == 0
</Original>
<Expanded>
7 == 0
</Expanded>
</Expression>
ConditionTests.cpp" line="74">
<Original>
data.float_nine_point_one == Approx( 9.11f )
</Original>
<Expanded>
9.1 == Approx( 9.11 )
</Expanded>
</Expression>
ConditionTests.cpp" line="75">
<Original>
data.float_nine_point_one == Approx( 9.0f )
</Original>
<Expanded>
9.1 == Approx( 9 )
</Expanded>
</Expression>
ConditionTests.cpp" line="76">
<Original>
data.float_nine_point_one == Approx( 1 )
</Original>
<Expanded>
9.1 == Approx( 1 )
</Expanded>
</Expression>
ConditionTests.cpp" line="77">
<Original>
data.float_nine_point_one == Approx( 0 )
</Original>
<Expanded>
9.1 == Approx( 0 )
</Expanded>
</Expression>
ConditionTests.cpp" line="78">
<Original>
data.double_pi == Approx( 3.1415 )
</Original>
<Expanded>
3.14159 == Approx( 3.1415 )
</Expanded>
</Expression>
ConditionTests.cpp" line="79">
<Original>
data.str_hello == &quot;goodbye&quot;
</Original>
<Expanded>
&quot;hello&quot; == &quot;goodbye&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="80">
<Original>
data.str_hello == &quot;hell&quot;
</Original>
<Expanded>
&quot;hello&quot; == &quot;hell&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="81">
<Original>
data.str_hello == &quot;hello1&quot;
</Original>
<Expanded>
&quot;hello&quot; == &quot;hello1&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="82">
<Original>
data.str_hello.size() == 6
</Original>
<Expanded>
5 == 6
</Expanded>
</Expression>
ConditionTests.cpp" line="85">
<Original>
x == Approx( 1.301 )
</Original>
<Expanded>
1.3 == Approx( 1.301 )
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/conditions/inequality">
ConditionTests.cpp" line="93">
<Original>
data.int_seven != 6
</Original>
<Expanded>
7 != 6
</Expanded>
</Expression>
ConditionTests.cpp" line="94">
<Original>
data.int_seven != 8
</Original>
<Expanded>
7 != 8
</Expanded>
</Expression>
ConditionTests.cpp" line="95">
<Original>
data.float_nine_point_one != Approx( 9.11f )
</Original>
<Expanded>
9.1 != Approx( 9.11 )
</Expanded>
</Expression>
ConditionTests.cpp" line="96">
<Original>
data.float_nine_point_one != Approx( 9.0f )
</Original>
<Expanded>
9.1 != Approx( 9 )
</Expanded>
</Expression>
ConditionTests.cpp" line="97">
<Original>
data.float_nine_point_one != Approx( 1 )
</Original>
<Expanded>
9.1 != Approx( 1 )
</Expanded>
</Expression>
ConditionTests.cpp" line="98">
<Original>
data.float_nine_point_one != Approx( 0 )
</Original>
<Expanded>
9.1 != Approx( 0 )
</Expanded>
</Expression>
ConditionTests.cpp" line="99">
<Original>
data.double_pi != Approx( 3.1415 )
</Original>
<Expanded>
3.14159 != Approx( 3.1415 )
</Expanded>
</Expression>
ConditionTests.cpp" line="100">
<Original>
data.str_hello != &quot;goodbye&quot;
</Original>
<Expanded>
&quot;hello&quot; != &quot;goodbye&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="101">
<Original>
data.str_hello != &quot;hell&quot;
</Original>
<Expanded>
&quot;hello&quot; != &quot;hell&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="102">
<Original>
data.str_hello != &quot;hello1&quot;
</Original>
<Expanded>
&quot;hello&quot; != &quot;hello1&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="103">
<Original>
data.str_hello.size() != 6
</Original>
<Expanded>
5 != 6
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/conditions/inequality">
ConditionTests.cpp" line="111">
<Original>
data.int_seven != 7
</Original>
<Expanded>
7 != 7
</Expanded>
</Expression>
ConditionTests.cpp" line="112">
<Original>
data.float_nine_point_one != Approx( 9.1f )
</Original>
<Expanded>
9.1 != Approx( 9.1 )
</Expanded>
</Expression>
ConditionTests.cpp" line="113">
<Original>
data.double_pi != Approx( 3.1415926535 )
</Original>
<Expanded>
3.14159 != Approx( 3.14159 )
</Expanded>
</Expression>
ConditionTests.cpp" line="114">
<Original>
data.str_hello != &quot;hello&quot;
</Original>
<Expanded>
&quot;hello&quot; != &quot;hello&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="115">
<Original>
data.str_hello.size() != 5
</Original>
<Expanded>
5 != 5
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/conditions/ordered">
ConditionTests.cpp" line="124">
<Original>
data.int_seven &lt; 8
</Original>
<Expanded>
7 &lt; 8
</Expanded>
</Expression>
ConditionTests.cpp" line="125">
<Original>
data.int_seven > 6
</Original>
<Expanded>
7 > 6
</Expanded>
</Expression>
ConditionTests.cpp" line="126">
<Original>
data.int_seven > 0
</Original>
<Expanded>
7 > 0
</Expanded>
</Expression>
ConditionTests.cpp" line="127">
<Original>
data.int_seven > -1
</Original>
<Expanded>
7 > -1
</Expanded>
</Expression>
ConditionTests.cpp" line="129">
<Original>
data.int_seven >= 7
</Original>
<Expanded>
7 >= 7
</Expanded>
</Expression>
ConditionTests.cpp" line="130">
<Original>
data.int_seven >= 6
</Original>
<Expanded>
7 >= 6
</Expanded>
</Expression>
ConditionTests.cpp" line="131">
<Original>
data.int_seven &lt;= 7
</Original>
<Expanded>
7 &lt;= 7
</Expanded>
</Expression>
ConditionTests.cpp" line="132">
<Original>
data.int_seven &lt;= 8
</Original>
<Expanded>
7 &lt;= 8
</Expanded>
</Expression>
ConditionTests.cpp" line="134">
<Original>
data.float_nine_point_one > 9
</Original>
<Expanded>
9.1 > 9
</Expanded>
</Expression>
ConditionTests.cpp" line="135">
<Original>
data.float_nine_point_one &lt; 10
</Original>
<Expanded>
9.1 &lt; 10
</Expanded>
</Expression>
ConditionTests.cpp" line="136">
<Original>
data.float_nine_point_one &lt; 9.2
</Original>
<Expanded>
9.1 &lt; 9.2
</Expanded>
</Expression>
ConditionTests.cpp" line="138">
<Original>
data.str_hello &lt;= &quot;hello&quot;
</Original>
<Expanded>
&quot;hello&quot; &lt;= &quot;hello&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="139">
<Original>
data.str_hello >= &quot;hello&quot;
</Original>
<Expanded>
&quot;hello&quot; >= &quot;hello&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="141">
<Original>
data.str_hello &lt; &quot;hellp&quot;
</Original>
<Expanded>
&quot;hello&quot; &lt; &quot;hellp&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="142">
<Original>
data.str_hello &lt; &quot;zebra&quot;
</Original>
<Expanded>
&quot;hello&quot; &lt; &quot;zebra&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="143">
<Original>
data.str_hello > &quot;hellm&quot;
</Original>
<Expanded>
&quot;hello&quot; > &quot;hellm&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="144">
<Original>
data.str_hello > &quot;a&quot;
</Original>
<Expanded>
&quot;hello&quot; > &quot;a&quot;
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/conditions/ordered">
ConditionTests.cpp" line="152">
<Original>
data.int_seven > 7
</Original>
<Expanded>
7 > 7
</Expanded>
</Expression>
ConditionTests.cpp" line="153">
<Original>
data.int_seven &lt; 7
</Original>
<Expanded>
7 &lt; 7
</Expanded>
</Expression>
ConditionTests.cpp" line="154">
<Original>
data.int_seven > 8
</Original>
<Expanded>
7 > 8
</Expanded>
</Expression>
ConditionTests.cpp" line="155">
<Original>
data.int_seven &lt; 6
</Original>
<Expanded>
7 &lt; 6
</Expanded>
</Expression>
ConditionTests.cpp" line="156">
<Original>
data.int_seven &lt; 0
</Original>
<Expanded>
7 &lt; 0
</Expanded>
</Expression>
ConditionTests.cpp" line="157">
<Original>
data.int_seven &lt; -1
</Original>
<Expanded>
7 &lt; -1
</Expanded>
</Expression>
ConditionTests.cpp" line="159">
<Original>
data.int_seven >= 8
</Original>
<Expanded>
7 >= 8
</Expanded>
</Expression>
ConditionTests.cpp" line="160">
<Original>
data.int_seven &lt;= 6
</Original>
<Expanded>
7 &lt;= 6
</Expanded>
</Expression>
ConditionTests.cpp" line="162">
<Original>
data.float_nine_point_one &lt; 9
</Original>
<Expanded>
9.1 &lt; 9
</Expanded>
</Expression>
ConditionTests.cpp" line="163">
<Original>
data.float_nine_point_one > 10
</Original>
<Expanded>
9.1 > 10
</Expanded>
</Expression>
ConditionTests.cpp" line="164">
<Original>
data.float_nine_point_one > 9.2
</Original>
<Expanded>
9.1 > 9.2
</Expanded>
</Expression>
ConditionTests.cpp" line="166">
<Original>
data.str_hello > &quot;hello&quot;
</Original>
<Expanded>
&quot;hello&quot; > &quot;hello&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="167">
<Original>
data.str_hello &lt; &quot;hello&quot;
</Original>
<Expanded>
&quot;hello&quot; &lt; &quot;hello&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="168">
<Original>
data.str_hello > &quot;hellp&quot;
</Original>
<Expanded>
&quot;hello&quot; > &quot;hellp&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="169">
<Original>
data.str_hello > &quot;z&quot;
</Original>
<Expanded>
&quot;hello&quot; > &quot;z&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="170">
<Original>
data.str_hello &lt; &quot;hellm&quot;
</Original>
<Expanded>
&quot;hello&quot; &lt; &quot;hellm&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="171">
<Original>
data.str_hello &lt; &quot;a&quot;
</Original>
<Expanded>
&quot;hello&quot; &lt; &quot;a&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="173">
<Original>
data.str_hello >= &quot;z&quot;
</Original>
<Expanded>
&quot;hello&quot; >= &quot;z&quot;
</Expanded>
</Expression>
ConditionTests.cpp" line="174">
<Original>
data.str_hello &lt;= &quot;a&quot;
</Original>
<Expanded>
&quot;hello&quot; &lt;= &quot;a&quot;
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/conditions/int literals">
ConditionTests.cpp" line="188">
<Original>
i == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
ConditionTests.cpp" line="189">
<Original>
ui == 2
</Original>
<Expanded>
2 == 2
</Expanded>
</Expression>
ConditionTests.cpp" line="190">
<Original>
l == 3
</Original>
<Expanded>
3 == 3
</Expanded>
</Expression>
ConditionTests.cpp" line="191">
<Original>
ul == 4
</Original>
<Expanded>
4 == 4
</Expanded>
</Expression>
ConditionTests.cpp" line="192">
<Original>
c == 5
</Original>
<Expanded>
5 == 5
</Expanded>
</Expression>
ConditionTests.cpp" line="193">
<Original>
uc == 6
</Original>
<Expanded>
 == 6
</Expanded>
</Expression>
ConditionTests.cpp" line="195">
<Original>
1 == i
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
ConditionTests.cpp" line="196">
<Original>
2 == ui
</Original>
<Expanded>
2 == 2
</Expanded>
</Expression>
ConditionTests.cpp" line="197">
<Original>
3 == l
</Original>
<Expanded>
3 == 3
</Expanded>
</Expression>
ConditionTests.cpp" line="198">
<Original>
4 == ul
</Original>
<Expanded>
4 == 4
</Expanded>
</Expression>
ConditionTests.cpp" line="199">
<Original>
5 == c
</Original>
<Expanded>
5 == 5
</Expanded>
</Expression>
ConditionTests.cpp" line="200">
<Original>
6 == uc
</Original>
<Expanded>
6 == 
</Expanded>
</Expression>
ConditionTests.cpp" line="202">
<Original>
(std::numeric_limits&lt;unsigned long>::max)() > ul
</Original>
<Expanded>
0x<hex digits> > 4
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/conditions//long_to_unsigned_x">
ConditionTests.cpp" line="223">
<Original>
long_var == unsigned_char_var
</Original>
<Expanded>
1 == 
</Expanded>
</Expression>
ConditionTests.cpp" line="224">
<Original>
long_var == unsigned_short_var
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
ConditionTests.cpp" line="225">
<Original>
long_var == unsigned_int_var
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
ConditionTests.cpp" line="226">
<Original>
long_var == unsigned_long_var
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/conditions/const ints to int literal">
ConditionTests.cpp" line="237">
<Original>
unsigned_char_var == 1
</Original>
<Expanded>
 == 1
</Expanded>
</Expression>
ConditionTests.cpp" line="238">
<Original>
unsigned_short_var == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
ConditionTests.cpp" line="239">
<Original>
unsigned_int_var == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
ConditionTests.cpp" line="240">
<Original>
unsigned_long_var == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/conditions/negative ints">
ConditionTests.cpp" line="246">
<Original>
( -1 > 2u )
</Original>
<Expanded>
true
</Expanded>
</Expression>
ConditionTests.cpp" line="247">
<Original>
-1 > 2u
</Original>
<Expanded>
-1 > 2
</Expanded>
</Expression>
ConditionTests.cpp" line="249">
<Original>
( 2u &lt; -1 )
</Original>
<Expanded>
true
</Expanded>
</Expression>
ConditionTests.cpp" line="250">
<Original>
2u &lt; -1
</Original>
<Expanded>
2 &lt; -1
</Expanded>
</Expression>
ConditionTests.cpp" line="253">
<Original>
( minInt > 2u )
</Original>
<Expanded>
true
</Expanded>
</Expression>
ConditionTests.cpp" line="254">
<Original>
minInt > 2u
</Original>
<Expanded>
-2147483648 > 2
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/conditions/computed ints">
ConditionTests.cpp" line="269">
<Original>
54 == 6*9
</Original>
<Expanded>
54 == 54
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/conditions/ptr">
ConditionTests.cpp" line="285">
<Original>
p == __null
</Original>
<Expanded>
__null == 0
</Expanded>
</Expression>
ConditionTests.cpp" line="286">
<Original>
p == pNULL
</Original>
<Expanded>
__null == __null
</Expanded>
</Expression>
ConditionTests.cpp" line="291">
<Original>
p != __null
</Original>
<Expanded>
0x<hex digits> != 0
</Expanded>
</Expression>
ConditionTests.cpp" line="294">
<Original>
cp != __null
</Original>
<Expanded>
0x<hex digits> != 0
</Expanded>
</Expression>
ConditionTests.cpp" line="297">
<Original>
cpc != __null
</Original>
<Expanded>
0x<hex digits> != 0
</Expanded>
</Expression>
ConditionTests.cpp" line="299">
<Original>
returnsNull() == __null
</Original>
<Expanded>
{null string} == 0
</Expanded>
</Expression>
ConditionTests.cpp" line="300">
<Original>
returnsConstNull() == __null
</Original>
<Expanded>
{null string} == 0
</Expanded>
</Expression>
ConditionTests.cpp" line="302">
<Original>
__null != p
</Original>
<Expanded>
0 != 0x<hex digits>
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/conditions/not">
ConditionTests.cpp" line="317">
<Original>
false == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
ConditionTests.cpp" line="318">
<Original>
true == true
</Original>
<Expanded>
true == true
</Expanded>
</Expression>
ConditionTests.cpp" line="319">
<Original>
!false
</Original>
<Expanded>
true
</Expanded>
</Expression>
ConditionTests.cpp" line="320">
<Original>
!false
</Original>
<Expanded>
!false
</Expanded>
</Expression>
ConditionTests.cpp" line="322">
<Original>
!falseValue
</Original>
<Expanded>
true
</Expanded>
</Expression>
ConditionTests.cpp" line="323">
<Original>
!falseValue
</Original>
<Expanded>
!false
</Expanded>
</Expression>
ConditionTests.cpp" line="325">
<Original>
!(1 == 2)
</Original>
<Expanded>
true
</Expanded>
</Expression>
ConditionTests.cpp" line="326">
<Original>
!1 == 2
</Original>
<Expanded>
!(1 == 2)
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/conditions/not">
ConditionTests.cpp" line="334">
<Original>
false != false
</Original>
<Expanded>
false != false
</Expanded>
</Expression>
ConditionTests.cpp" line="335">
<Original>
true != true
</Original>
<Expanded>
true != true
</Expanded>
</Expression>
ConditionTests.cpp" line="336">
<Original>
!true
</Original>
<Expanded>
false
</Expanded>
</Expression>
ConditionTests.cpp" line="337">
<Original>
!true
</Original>
<Expanded>
!true
</Expanded>
</Expression>
ConditionTests.cpp" line="339">
<Original>
!trueValue
</Original>
<Expanded>
false
</Expanded>
</Expression>
ConditionTests.cpp" line="340">
<Original>
!trueValue
</Original>
<Expanded>
!true
</Expanded>
</Expression>
ConditionTests.cpp" line="342">
<Original>
!(1 == 1)
</Original>
<Expanded>
false
</Expanded>
</Expression>
ConditionTests.cpp" line="343">
<Original>
!1 == 1
</Original>
<Expanded>
!(1 == 1)
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/exceptions/explicit">
ExceptionTests.cpp" line="39">
<Original>
thisThrows()
</Original>
<Expanded>
thisThrows()
</Expanded>
</Expression>
ExceptionTests.cpp" line="40">
<Original>
thisDoesntThrow()
</Original>
<Expanded>
thisDoesntThrow()
</Expanded>
</Expression>
ExceptionTests.cpp" line="41">
<Original>
thisThrows()
</Original>
<Expanded>
thisThrows()
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/exceptions/explicit">
ExceptionTests.cpp" line="47">
<Original>
thisThrows()
</Original>
<Expanded>
thisThrows()
</Expanded>
ExceptionTests.cpp" line="47">
expected exception
</Exception>
</Expression>
ExceptionTests.cpp" line="48">
<Original>
thisDoesntThrow()
</Original>
<Expanded>
thisDoesntThrow()
</Expanded>
</Expression>
ExceptionTests.cpp" line="49">
<Original>
thisThrows()
</Original>
<Expanded>
thisThrows()
</Expanded>
ExceptionTests.cpp" line="49">
expected exception
</Exception>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/exceptions/implicit">
ExceptionTests.cpp" line="52">
unexpected exception
</Exception>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/exceptions/implicit/2">
ExceptionTests.cpp" line="60">
<Original>
1 == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
ExceptionTests.cpp" line="60">
<Original>
{Unknown expression after this line}
</Original>
<Expanded>
{Unknown expression after this line}
</Expanded>
ExceptionTests.cpp" line="60">
unexpected exception
</Exception>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/exceptions/implicit">
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/exceptions/custom">
ExceptionTests.cpp" line="102">
custom exception
</Exception>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/exceptions/custom/nothrow">
ExceptionTests.cpp" line="109">
<Original>
throw CustomException( &quot;unexpected custom exception&quot; )
</Original>
<Expanded>
throw CustomException( &quot;unexpected custom exception&quot; )
</Expanded>
ExceptionTests.cpp" line="109">
unexpected custom exception
</Exception>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/exceptions/custom/throw">
ExceptionTests.cpp" line="114">
<Original>
throw CustomException( &quot;custom exception - not std&quot; )
</Original>
<Expanded>
throw CustomException( &quot;custom exception - not std&quot; )
</Expanded>
ExceptionTests.cpp" line="114">
custom exception - not std
</Exception>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/exceptions/custom/double">
ExceptionTests.cpp" line="118">
3.14
</Exception>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/exceptions/notimplemented">
ExceptionTests.cpp" line="129">
<Original>
thisFunctionNotImplemented( 7 )
</Original>
<Expanded>
thisFunctionNotImplemented( 7 )
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/generators/1">
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
2 == 2
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
200 == 200
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
4 == 4
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
200 == 200
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
6 == 6
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
200 == 200
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
8 == 8
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
200 == 200
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
10 == 10
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
200 == 200
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
30 == 30
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
200 == 200
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
40 == 40
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
200 == 200
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
42 == 42
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
200 == 200
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
72 == 72
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
200 == 200
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
2 == 2
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
202 == 202
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
4 == 4
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
202 == 202
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
6 == 6
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
202 == 202
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
8 == 8
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
202 == 202
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
10 == 10
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
202 == 202
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
30 == 30
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
202 == 202
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
40 == 40
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
202 == 202
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
42 == 42
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
202 == 202
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
72 == 72
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
202 == 202
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
2 == 2
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
204 == 204
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
4 == 4
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
204 == 204
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
6 == 6
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
204 == 204
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
8 == 8
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
204 == 204
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
10 == 10
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
204 == 204
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
30 == 30
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
204 == 204
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
40 == 40
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
204 == 204
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
42 == 42
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
204 == 204
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
72 == 72
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
204 == 204
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
2 == 2
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
206 == 206
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
4 == 4
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
206 == 206
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
6 == 6
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
206 == 206
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
8 == 8
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
206 == 206
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
10 == 10
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
206 == 206
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
30 == 30
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
206 == 206
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
40 == 40
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
206 == 206
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
42 == 42
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
206 == 206
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
72 == 72
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
206 == 206
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
2 == 2
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
208 == 208
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
4 == 4
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
208 == 208
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
6 == 6
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
208 == 208
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
8 == 8
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
208 == 208
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
10 == 10
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
208 == 208
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
30 == 30
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
208 == 208
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
40 == 40
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
208 == 208
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
42 == 42
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
208 == 208
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
72 == 72
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
208 == 208
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
2 == 2
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
210 == 210
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
4 == 4
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
210 == 210
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
6 == 6
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
210 == 210
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
8 == 8
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
210 == 210
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
10 == 10
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
210 == 210
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
30 == 30
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
210 == 210
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
40 == 40
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
210 == 210
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
42 == 42
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
210 == 210
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
72 == 72
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
210 == 210
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
2 == 2
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
212 == 212
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
4 == 4
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
212 == 212
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
6 == 6
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
212 == 212
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
8 == 8
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
212 == 212
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
10 == 10
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
212 == 212
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
30 == 30
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
212 == 212
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
40 == 40
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
212 == 212
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
42 == 42
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
212 == 212
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
72 == 72
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
212 == 212
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
2 == 2
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
214 == 214
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
4 == 4
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
214 == 214
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
6 == 6
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
214 == 214
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
8 == 8
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
214 == 214
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
10 == 10
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
214 == 214
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
30 == 30
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
214 == 214
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
40 == 40
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
214 == 214
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
42 == 42
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
214 == 214
</Expanded>
</Expression>
GeneratorTests.cpp" line="26">
<Original>
multiply( i, 2 ) == i*2
</Original>
<Expanded>
72 == 72
</Expanded>
</Expression>
GeneratorTests.cpp" line="27">
<Original>
multiply( j, 2 ) == j*2
</Original>
<Expanded>
214 == 214
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/message">
<Warning>
this is a warning
</Warning>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/succeed">
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/message/info/1">
<Info>
this message should be logged
</Info>
<Info>
so should this
</Info>
MessageTests.cpp" line="26">
<Original>
a == 1
</Original>
<Expanded>
2 == 1
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./mixed/message/info/2">
MessageTests.cpp" line="33">
<Original>
a == 2
</Original>
<Expanded>
2 == 2
</Expanded>
</Expression>
<Info>
this message should be logged
</Info>
<Info>
this message should be logged, too
</Info>
MessageTests.cpp" line="37">
<Original>
a == 1
</Original>
<Expanded>
2 == 1
</Expanded>
</Expression>
<Info>
and this, but later
</Info>
MessageTests.cpp" line="41">
<Original>
a == 0
</Original>
<Expanded>
2 == 0
</Expanded>
</Expression>
MessageTests.cpp" line="45">
<Original>
a == 2
</Original>
<Expanded>
2 == 2
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/message/fail">
<Failure>
This is a failure
</Failure>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/message/sections">
<Section name="one">
<Failure>
Message from section one
</Failure>
<OverallResults successes="0" failures="1"/>
</Section>
<Section name="two">
<Failure>
Message from section two
</Failure>
<OverallResults successes="0" failures="1"/>
</Section>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/message/sections/stdout">
<Section name="one">
<OverallResults successes="0" failures="1"/>
</Section>
<Section name="two">
<OverallResults successes="0" failures="1"/>
</Section>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./mixed/message/scoped">
MessageTests.cpp" line="86">
<Original>
i &lt; 10
</Original>
<Expanded>
0 &lt; 10
</Expanded>
</Expression>
MessageTests.cpp" line="86">
<Original>
i &lt; 10
</Original>
<Expanded>
1 &lt; 10
</Expanded>
</Expression>
MessageTests.cpp" line="86">
<Original>
i &lt; 10
</Original>
<Expanded>
2 &lt; 10
</Expanded>
</Expression>
MessageTests.cpp" line="86">
<Original>
i &lt; 10
</Original>
<Expanded>
3 &lt; 10
</Expanded>
</Expression>
MessageTests.cpp" line="86">
<Original>
i &lt; 10
</Original>
<Expanded>
4 &lt; 10
</Expanded>
</Expression>
MessageTests.cpp" line="86">
<Original>
i &lt; 10
</Original>
<Expanded>
5 &lt; 10
</Expanded>
</Expression>
MessageTests.cpp" line="86">
<Original>
i &lt; 10
</Original>
<Expanded>
6 &lt; 10
</Expanded>
</Expression>
MessageTests.cpp" line="86">
<Original>
i &lt; 10
</Original>
<Expanded>
7 &lt; 10
</Expanded>
</Expression>
MessageTests.cpp" line="86">
<Original>
i &lt; 10
</Original>
<Expanded>
8 &lt; 10
</Expanded>
</Expression>
MessageTests.cpp" line="86">
<Original>
i &lt; 10
</Original>
<Expanded>
9 &lt; 10
</Expanded>
</Expression>
MessageTests.cpp" line="86">
<Original>
i &lt; 10
</Original>
<Expanded>
i &lt; 10
</Expanded>
<Info>
current counter 10
</Info>
</Expression>
MessageTests.cpp" line="86">
<Original>
i &lt; 10
</Original>
<Expanded>
i &lt; 10
</Expanded>
<Info>
i := 10
</Info>
</Expression>
MessageTests.cpp" line="86">
<Original>
i &lt; 10
</Original>
<Expanded>
10 &lt; 10
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/nofail">
MessageTests.cpp" line="92">
<Original>
1 == 2
</Original>
<Expanded>
1 == 2
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/Misc/Sections">
<Section name="s1" description="doesn't equal">
MiscTests.cpp" line="25">
<Original>
a != b
</Original>
<Expanded>
1 != 2
</Expanded>
</Expression>
MiscTests.cpp" line="26">
<Original>
b != a
</Original>
<Expanded>
2 != 1
</Expanded>
</Expression>
<OverallResults successes="2" failures="0"/>
</Section>
<Section name="s2" description="not equal">
MiscTests.cpp" line="31">
<Original>
a != b
</Original>
<Expanded>
1 != 2
</Expanded>
</Expression>
<OverallResults successes="1" failures="0"/>
</Section>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/Misc/Sections/nested">
<Section name="s1" description="doesn't equal">
MiscTests.cpp" line="42">
<Original>
a != b
</Original>
<Expanded>
1 != 2
</Expanded>
</Expression>
MiscTests.cpp" line="43">
<Original>
b != a
</Original>
<Expanded>
2 != 1
</Expanded>
</Expression>
<Section name="s2" description="not equal">
MiscTests.cpp" line="47">
<Original>
a != b
</Original>
<Expanded>
1 != 2
</Expanded>
</Expression>
<OverallResults successes="1" failures="0"/>
</Section>
<OverallResults successes="3" failures="0"/>
</Section>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./mixed/Misc/Sections/nested2">
<Section name="s1" description="doesn't equal">
<Section name="s2" description="equal">
MiscTests.cpp" line="61">
<Original>
a == b
</Original>
<Expanded>
1 == 2
</Expanded>
</Expression>
<OverallResults successes="0" failures="1"/>
</Section>
<OverallResults successes="0" failures="1"/>
</Section>
<Section name="s1" description="doesn't equal">
<Section name="s3" description="not equal">
MiscTests.cpp" line="66">
<Original>
a != b
</Original>
<Expanded>
1 != 2
</Expanded>
</Expression>
<OverallResults successes="1" failures="0"/>
</Section>
<OverallResults successes="1" failures="0"/>
</Section>
<Section name="s1" description="doesn't equal">
<Section name="s4" description="less than">
MiscTests.cpp" line="70">
<Original>
a &lt; b
</Original>
<Expanded>
1 &lt; 2
</Expanded>
</Expression>
<OverallResults successes="1" failures="0"/>
</Section>
<OverallResults successes="1" failures="0"/>
</Section>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./Sections/nested/a/b">
<Section name="c">
<Section name="d (leaf)">
<OverallResults successes="0" failures="1"/>
</Section>
<OverallResults successes="0" failures="1"/>
</Section>
<Section name="c">
<Section name="e (leaf)">
<OverallResults successes="0" failures="1"/>
</Section>
<OverallResults successes="0" failures="1"/>
</Section>
<Section name="c">
<OverallResults successes="0" failures="0"/>
</Section>
<Section name="f (leaf)">
<OverallResults successes="0" failures="1"/>
</Section>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./mixed/Misc/Sections/loops">
<Section name="s1" description="b is currently: 0">
MiscTests.cpp" line="103">
<Original>
b > a
</Original>
<Expanded>
0 > 1
</Expanded>
</Expression>
<OverallResults successes="0" failures="1"/>
</Section>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./mixed/Misc/loops">
<Info>
Testing if fib[0] (1) is even
</Info>
MiscTests.cpp" line="115">
<Original>
( fib[i] % 2 ) == 0
</Original>
<Expanded>
1 == 0
</Expanded>
</Expression>
<Info>
Testing if fib[1] (1) is even
</Info>
MiscTests.cpp" line="115">
<Original>
( fib[i] % 2 ) == 0
</Original>
<Expanded>
1 == 0
</Expanded>
</Expression>
MiscTests.cpp" line="115">
<Original>
( fib[i] % 2 ) == 0
</Original>
<Expanded>
0 == 0
</Expanded>
</Expression>
<Info>
Testing if fib[2] (2) is even
</Info>
<Info>
Testing if fib[3] (3) is even
</Info>
MiscTests.cpp" line="115">
<Original>
( fib[i] % 2 ) == 0
</Original>
<Expanded>
1 == 0
</Expanded>
</Expression>
<Info>
Testing if fib[4] (5) is even
</Info>
MiscTests.cpp" line="115">
<Original>
( fib[i] % 2 ) == 0
</Original>
<Expanded>
1 == 0
</Expanded>
</Expression>
MiscTests.cpp" line="115">
<Original>
( fib[i] % 2 ) == 0
</Original>
<Expanded>
0 == 0
</Expanded>
</Expression>
<Info>
Testing if fib[5] (8) is even
</Info>
<Info>
Testing if fib[6] (13) is even
</Info>
MiscTests.cpp" line="115">
<Original>
( fib[i] % 2 ) == 0
</Original>
<Expanded>
1 == 0
</Expanded>
</Expression>
<Info>
Testing if fib[7] (21) is even
</Info>
MiscTests.cpp" line="115">
<Original>
( fib[i] % 2 ) == 0
</Original>
<Expanded>
1 == 0
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/Misc/stdout,stderr">
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/Misc/null strings">
MiscTests.cpp" line="133">
<Original>
makeString( false ) != static_cast&lt;char*>(__null)
</Original>
<Expanded>
&quot;valid string&quot; != {null string}
</Expanded>
</Expression>
MiscTests.cpp" line="134">
<Original>
makeString( true ) == static_cast&lt;char*>(__null)
</Original>
<Expanded>
{null string} == {null string}
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/info">
<Info>
hi
</Info>
<Info>
i := 7
</Info>
MiscTests.cpp" line="142">
<Original>
false
</Original>
<Expanded>
false
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/checkedif">
MiscTests.cpp" line="147">
<Original>
flag
</Original>
<Expanded>
true
</Expanded>
</Expression>
MiscTests.cpp" line="155">
<Original>
testCheckedIf( true )
</Original>
<Expanded>
true
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/checkedif">
MiscTests.cpp" line="147">
<Original>
flag
</Original>
<Expanded>
false
</Expanded>
</Expression>
MiscTests.cpp" line="160">
<Original>
testCheckedIf( false )
</Original>
<Expanded>
false
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/checkedelse">
MiscTests.cpp" line="165">
<Original>
flag
</Original>
<Expanded>
true
</Expanded>
</Expression>
MiscTests.cpp" line="173">
<Original>
testCheckedElse( true )
</Original>
<Expanded>
true
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/checkedelse">
MiscTests.cpp" line="165">
<Original>
flag
</Original>
<Expanded>
false
</Expanded>
</Expression>
MiscTests.cpp" line="178">
<Original>
testCheckedElse( false )
</Original>
<Expanded>
false
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./misc/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>
<Section name="encoded chars" description="these should all be encoded: &amp;&amp;&amp;&quot;&quot;&quot;&lt;&lt;&lt;&amp;&quot;&lt;&lt;&amp;&quot;">
<OverallResults successes="0" failures="1"/>
</Section>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./manual/onechar">
<Info>
3
</Info>
MiscTests.cpp" line="196">
<Original>
false
</Original>
<Expanded>
false
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/atomic if">
MiscTests.cpp" line="206">
<Original>
x == 0
</Original>
<Expanded>
0 == 0
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/matchers">
MiscTests.cpp" line="216">
<Original>
testStringForMatching() Contains( &quot;string&quot; )
</Original>
<Expanded>
&quot;this string contains 'abc' as a substring&quot; contains: &quot;string&quot;
</Expanded>
</Expression>
MiscTests.cpp" line="217">
<Original>
testStringForMatching() Contains( &quot;abc&quot; )
</Original>
<Expanded>
&quot;this string contains 'abc' as a substring&quot; contains: &quot;abc&quot;
</Expanded>
</Expression>
MiscTests.cpp" line="219">
<Original>
testStringForMatching() StartsWith( &quot;this&quot; )
</Original>
<Expanded>
&quot;this string contains 'abc' as a substring&quot; starts with: &quot;this&quot;
</Expanded>
</Expression>
MiscTests.cpp" line="220">
<Original>
testStringForMatching() EndsWith( &quot;substring&quot; )
</Original>
<Expanded>
&quot;this string contains 'abc' as a substring&quot; ends with: &quot;substring&quot;
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./failing/matchers/Contains">
MiscTests.cpp" line="225">
<Original>
testStringForMatching() Contains( &quot;not there&quot; )
</Original>
<Expanded>
&quot;this string contains 'abc' as a substring&quot; contains: &quot;not there&quot;
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/matchers/StartsWith">
MiscTests.cpp" line="230">
<Original>
testStringForMatching() StartsWith( &quot;string&quot; )
</Original>
<Expanded>
&quot;this string contains 'abc' as a substring&quot; starts with: &quot;string&quot;
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/matchers/EndsWith">
MiscTests.cpp" line="235">
<Original>
testStringForMatching() EndsWith( &quot;this&quot; )
</Original>
<Expanded>
&quot;this string contains 'abc' as a substring&quot; ends with: &quot;this&quot;
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/matchers/Equals">
MiscTests.cpp" line="240">
<Original>
testStringForMatching() Equals( &quot;something else&quot; )
</Original>
<Expanded>
&quot;this string contains 'abc' as a substring&quot; equals: &quot;something else&quot;
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="/succeeding/matchers/AllOf">
MiscTests.cpp" line="245">
<Original>
testStringForMatching() AllOf( Catch::Contains( &quot;string&quot; ), Catch::Contains( &quot;abc&quot; ) )
</Original>
<Expanded>
&quot;this string contains 'abc' as a substring&quot; ( contains: &quot;string&quot; and contains: &quot;abc&quot; )
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="/succeeding/matchers/AnyOf">
MiscTests.cpp" line="249">
<Original>
testStringForMatching() AnyOf( Catch::Contains( &quot;string&quot; ), Catch::Contains( &quot;not there&quot; ) )
</Original>
<Expanded>
&quot;this string contains 'abc' as a substring&quot; ( contains: &quot;string&quot; or contains: &quot;not there&quot; )
</Expanded>
</Expression>
MiscTests.cpp" line="250">
<Original>
testStringForMatching() AnyOf( Catch::Contains( &quot;not there&quot; ), Catch::Contains( &quot;string&quot; ) )
</Original>
<Expanded>
&quot;this string contains 'abc' as a substring&quot; ( contains: &quot;not there&quot; or contains: &quot;string&quot; )
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/matchers/Equals">
MiscTests.cpp" line="255">
<Original>
testStringForMatching() Equals( &quot;this string contains 'abc' as a substring&quot; )
</Original>
<Expanded>
&quot;this string contains 'abc' as a substring&quot; equals: &quot;this string contains 'abc' as a substring&quot;
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="example/factorial">
MiscTests.cpp" line="266">
<Original>
Factorial(0) == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
MiscTests.cpp" line="267">
<Original>
Factorial(1) == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
MiscTests.cpp" line="268">
<Original>
Factorial(2) == 2
</Original>
<Expanded>
2 == 2
</Expanded>
</Expression>
MiscTests.cpp" line="269">
<Original>
Factorial(3) == 6
</Original>
<Expanded>
6 == 6
</Expanded>
</Expression>
MiscTests.cpp" line="270">
<Original>
Factorial(10) == 3628800
</Original>
<Expanded>
0x<hex digits> == 3628800
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="empty">
<OverallResult success="true"/>
</TestCase>
<TestCase name="Nice descriptive name">
<Warning>
This one ran
</Warning>
<OverallResult success="true"/>
</TestCase>
<TestCase name="first tag">
<OverallResult success="true"/>
</TestCase>
<TestCase name="second tag">
<OverallResult success="true"/>
</TestCase>
<TestCase name="selftest/main">
<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="25" failures="0"/>
</Section>
<OverallResults successes="25" 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="43" failures="0"/>
</Section>
<OverallResults successes="43" failures="0"/>
</Section>
<Section name="selftest/expected result" description="Tests do what they claim">
<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">
TestMain.cpp" line="40">
<Original>
totals.assertions.passed == 291
</Original>
<Expanded>
291 == 291
</Expanded>
</Expression>
TestMain.cpp" line="41">
<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">
TestMain.cpp" line="47">
<Original>
totals.assertions.passed == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
TestMain.cpp" line="48">
<Original>
totals.assertions.failed == 72
</Original>
<Expanded>
72 == 72
</Expanded>
</Expression>
<OverallResults successes="2" failures="0"/>
</Section>
<OverallResults successes="2" failures="0"/>
</Section>
<OverallResult success="true"/>
</TestCase>
<TestCase name="meta/Misc/Sections">
TestMain.cpp" line="57">
<Original>
totals.assertions.passed == 2
</Original>
<Expanded>
2 == 2
</Expanded>
</Expression>
TestMain.cpp" line="58">
<Original>
totals.assertions.failed == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="selftest/parser/2">
<Section name="default">
TestMain.cpp" line="97">
<Original>
parseIntoConfig( argv, config )
</Original>
<Expanded>
parseIntoConfig( argv, config )
</Expanded>
</Expression>
TestMain.cpp" line="99">
<Original>
config.shouldDebugBreak == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
TestMain.cpp" line="100">
<Original>
config.cutoff == -1
</Original>
<Expanded>
-1 == -1
</Expanded>
</Expression>
TestMain.cpp" line="101">
<Original>
config.allowThrows == true
</Original>
<Expanded>
true == true
</Expanded>
</Expression>
TestMain.cpp" line="102">
<Original>
config.reporter.empty()
</Original>
<Expanded>
true
</Expanded>
</Expression>
<OverallResults successes="5" failures="0"/>
</Section>
<Section name="test lists">
<Section name="-t/1" description="Specify one test case using -t">
TestMain.cpp" line="108">
<Original>
parseIntoConfig( argv, config )
</Original>
<Expanded>
parseIntoConfig( argv, config )
</Expanded>
</Expression>
TestMain.cpp" line="110">
<Original>
config.filters.size() == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
TestMain.cpp" line="111">
<Original>
config.filters[0].shouldInclude( fakeTestCase( &quot;notIncluded&quot; ) ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
TestMain.cpp" line="112">
<Original>
config.filters[0].shouldInclude( fakeTestCase( &quot;test1&quot; ) )
</Original>
<Expanded>
true
</Expanded>
</Expression>
<OverallResults successes="4" failures="0"/>
</Section>
<OverallResults successes="4" failures="0"/>
</Section>
<Section name="test lists">
<Section name="-t/exclude:1" description="Specify one test case exclusion using -t exclude:">
TestMain.cpp" line="116">
<Original>
parseIntoConfig( argv, config )
</Original>
<Expanded>
parseIntoConfig( argv, config )
</Expanded>
</Expression>
TestMain.cpp" line="118">
<Original>
config.filters.size() == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
TestMain.cpp" line="119">
<Original>
config.filters[0].shouldInclude( fakeTestCase( &quot;test1&quot; ) ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
TestMain.cpp" line="120">
<Original>
config.filters[0].shouldInclude( fakeTestCase( &quot;alwaysIncluded&quot; ) )
</Original>
<Expanded>
true
</Expanded>
</Expression>
<OverallResults successes="4" failures="0"/>
</Section>
<OverallResults successes="4" failures="0"/>
</Section>
<Section name="test lists">
<Section name="--test/1" description="Specify one test case using --test">
TestMain.cpp" line="125">
<Original>
parseIntoConfig( argv, config )
</Original>
<Expanded>
parseIntoConfig( argv, config )
</Expanded>
</Expression>
TestMain.cpp" line="127">
<Original>
config.filters.size() == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
TestMain.cpp" line="128">
<Original>
config.filters[0].shouldInclude( fakeTestCase( &quot;notIncluded&quot; ) ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
TestMain.cpp" line="129">
<Original>
config.filters[0].shouldInclude( fakeTestCase( &quot;test1&quot; ) )
</Original>
<Expanded>
true
</Expanded>
</Expression>
<OverallResults successes="4" failures="0"/>
</Section>
<OverallResults successes="4" failures="0"/>
</Section>
<Section name="test lists">
<Section name="--test/exclude:1" description="Specify one test case exclusion using --test exclude:">
TestMain.cpp" line="134">
<Original>
parseIntoConfig( argv, config )
</Original>
<Expanded>
parseIntoConfig( argv, config )
</Expanded>
</Expression>
TestMain.cpp" line="136">
<Original>
config.filters.size() == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
TestMain.cpp" line="137">
<Original>
config.filters[0].shouldInclude( fakeTestCase( &quot;test1&quot; ) ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
TestMain.cpp" line="138">
<Original>
config.filters[0].shouldInclude( fakeTestCase( &quot;alwaysIncluded&quot; ) )
</Original>
<Expanded>
true
</Expanded>
</Expression>
<OverallResults successes="4" failures="0"/>
</Section>
<OverallResults successes="4" failures="0"/>
</Section>
<Section name="test lists">
<Section name="--test/exclude:2" description="Specify one test case exclusion using --test ~">
TestMain.cpp" line="143">
<Original>
parseIntoConfig( argv, config )
</Original>
<Expanded>
parseIntoConfig( argv, config )
</Expanded>
</Expression>
TestMain.cpp" line="145">
<Original>
config.filters.size() == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
TestMain.cpp" line="146">
<Original>
config.filters[0].shouldInclude( fakeTestCase( &quot;test1&quot; ) ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
TestMain.cpp" line="147">
<Original>
config.filters[0].shouldInclude( fakeTestCase( &quot;alwaysIncluded&quot; ) )
</Original>
<Expanded>
true
</Expanded>
</Expression>
<OverallResults successes="4" failures="0"/>
</Section>
<OverallResults successes="4" failures="0"/>
</Section>
<Section name="test lists">
<Section name="-t/2" description="Specify two test cases using -t">
TestMain.cpp" line="152">
<Original>
parseIntoConfig( argv, config )
</Original>
<Expanded>
parseIntoConfig( argv, config )
</Expanded>
</Expression>
TestMain.cpp" line="154">
<Original>
config.filters.size() == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
TestMain.cpp" line="155">
<Original>
config.filters[0].shouldInclude( fakeTestCase( &quot;notIncluded&quot; ) ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
TestMain.cpp" line="156">
<Original>
config.filters[0].shouldInclude( fakeTestCase( &quot;test1&quot; ) )
</Original>
<Expanded>
true
</Expanded>
</Expression>
TestMain.cpp" line="157">
<Original>
config.filters[0].shouldInclude( fakeTestCase( &quot;test2&quot; ) )
</Original>
<Expanded>
true
</Expanded>
</Expression>
<OverallResults successes="5" failures="0"/>
</Section>
<OverallResults successes="5" failures="0"/>
</Section>
<Section name="test lists">
<Section name="-t/0" description="When no test names are supplied it is an error">
TestMain.cpp" line="162">
<Original>
parseIntoConfigAndReturnError( argv, config ) Contains( &quot;at least 1&quot; )
</Original>
<Expanded>
&quot;Error while parsing arguments. Expected at least 1 argument.&quot; contains: &quot;at least 1&quot;
</Expanded>
</Expression>
<OverallResults successes="1" failures="0"/>
</Section>
<OverallResults successes="1" failures="0"/>
</Section>
<Section name="test lists">
<OverallResults successes="0" failures="0"/>
</Section>
<Section name="reporter">
<Section name="-r/basic">
TestMain.cpp" line="169">
<Original>
parseIntoConfig( argv, config )
</Original>
<Expanded>
parseIntoConfig( argv, config )
</Expanded>
</Expression>
TestMain.cpp" line="171">
<Original>
config.reporter == &quot;console&quot;
</Original>
<Expanded>
&quot;console&quot; == &quot;console&quot;
</Expanded>
</Expression>
<OverallResults successes="2" failures="0"/>
</Section>
<OverallResults successes="2" failures="0"/>
</Section>
<Section name="reporter">
<Section name="-r/xml">
TestMain.cpp" line="175">
<Original>
parseIntoConfig( argv, config )
</Original>
<Expanded>
parseIntoConfig( argv, config )
</Expanded>
</Expression>
TestMain.cpp" line="177">
<Original>
config.reporter == &quot;xml&quot;
</Original>
<Expanded>
&quot;xml&quot; == &quot;xml&quot;
</Expanded>
</Expression>
<OverallResults successes="2" failures="0"/>
</Section>
<OverallResults successes="2" failures="0"/>
</Section>
<Section name="reporter">
<Section name="--reporter/junit">
TestMain.cpp" line="181">
<Original>
parseIntoConfig( argv, config )
</Original>
<Expanded>
parseIntoConfig( argv, config )
</Expanded>
</Expression>
TestMain.cpp" line="183">
<Original>
config.reporter == &quot;junit&quot;
</Original>
<Expanded>
&quot;junit&quot; == &quot;junit&quot;
</Expanded>
</Expression>
<OverallResults successes="2" failures="0"/>
</Section>
<OverallResults successes="2" failures="0"/>
</Section>
<Section name="reporter">
<Section name="-r/error" description="reporter config only accepts one argument">
TestMain.cpp" line="187">
<Original>
parseIntoConfigAndReturnError( argv, config ) Contains( &quot;1 argument&quot; )
</Original>
<Expanded>
&quot;Error while parsing arguments. Expected 1 argument. Arguments were: one two&quot; contains: &quot;1 argument&quot;
</Expanded>
</Expression>
<OverallResults successes="1" failures="0"/>
</Section>
<OverallResults successes="1" failures="0"/>
</Section>
<Section name="reporter">
<OverallResults successes="0" failures="0"/>
</Section>
<Section name="debugger">
<Section name="-b">
TestMain.cpp" line="194">
<Original>
parseIntoConfig( argv, config )
</Original>
<Expanded>
parseIntoConfig( argv, config )
</Expanded>
</Expression>
TestMain.cpp" line="196">
<Original>
config.shouldDebugBreak == true
</Original>
<Expanded>
true == true
</Expanded>
</Expression>
<OverallResults successes="2" failures="0"/>
</Section>
<OverallResults successes="2" failures="0"/>
</Section>
<Section name="debugger">
<Section name="--break">
TestMain.cpp" line="200">
<Original>
parseIntoConfig( argv, config )
</Original>
<Expanded>
parseIntoConfig( argv, config )
</Expanded>
</Expression>
TestMain.cpp" line="202">
<Original>
config.shouldDebugBreak
</Original>
<Expanded>
true
</Expanded>
</Expression>
<OverallResults successes="2" failures="0"/>
</Section>
<OverallResults successes="2" failures="0"/>
</Section>
<Section name="debugger">
<Section name="-b" description="break option has no arguments">
TestMain.cpp" line="206">
<Original>
parseIntoConfigAndReturnError( argv, config ) Contains( &quot;0 arguments&quot; )
</Original>
<Expanded>
&quot;Error while parsing arguments. Expected 0 arguments. Arguments were: unexpected&quot; contains: &quot;0 arguments&quot;
</Expanded>
</Expression>
<OverallResults successes="1" failures="0"/>
</Section>
<OverallResults successes="1" failures="0"/>
</Section>
<Section name="debugger">
<OverallResults successes="0" failures="0"/>
</Section>
<Section name="abort">
<Section name="-a">
TestMain.cpp" line="213">
<Original>
parseIntoConfig( argv, config )
</Original>
<Expanded>
parseIntoConfig( argv, config )
</Expanded>
</Expression>
TestMain.cpp" line="215">
<Original>
config.cutoff == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
<OverallResults successes="2" failures="0"/>
</Section>
<OverallResults successes="2" failures="0"/>
</Section>
<Section name="abort">
<Section name="-a/2">
TestMain.cpp" line="219">
<Original>
parseIntoConfig( argv, config )
</Original>
<Expanded>
parseIntoConfig( argv, config )
</Expanded>
</Expression>
TestMain.cpp" line="221">
<Original>
config.cutoff == 2
</Original>
<Expanded>
2 == 2
</Expanded>
</Expression>
<OverallResults successes="2" failures="0"/>
</Section>
<OverallResults successes="2" failures="0"/>
</Section>
<Section name="abort">
<Section name="-a/error/0">
TestMain.cpp" line="225">
<Original>
parseIntoConfigAndReturnError( argv, config ) Contains( &quot;greater than zero&quot; )
</Original>
<Expanded>
&quot;Error while parsing arguments. threshold must be a number greater than zero. Arguments were: 0&quot; contains: &quot;greater than zero&quot;
</Expanded>
</Expression>
<OverallResults successes="1" failures="0"/>
</Section>
<OverallResults successes="1" failures="0"/>
</Section>
<Section name="abort">
<Section name="-a/error/non numeric">
TestMain.cpp" line="229">
<Original>
parseIntoConfigAndReturnError( argv, config ) Contains( &quot;greater than zero&quot; )
</Original>
<Expanded>
&quot;Error while parsing arguments. threshold must be a number greater than zero. Arguments were: oops&quot; contains: &quot;greater than zero&quot;
</Expanded>
</Expression>
<OverallResults successes="1" failures="0"/>
</Section>
<OverallResults successes="1" failures="0"/>
</Section>
<Section name="abort">
<Section name="-a/error/two args" description="cutoff only takes one argument">
TestMain.cpp" line="233">
<Original>
parseIntoConfigAndReturnError( argv, config ) Contains( &quot;0 and 1 argument&quot; )
</Original>
<Expanded>
&quot;Error while parsing arguments. Expected between 0 and 1 argument. Arguments were: 1 2&quot; contains: &quot;0 and 1 argument&quot;
</Expanded>
</Expression>
<OverallResults successes="1" failures="0"/>
</Section>
<OverallResults successes="1" failures="0"/>
</Section>
<Section name="abort">
<OverallResults successes="0" failures="0"/>
</Section>
<Section name="nothrow">
<Section name="-nt">
TestMain.cpp" line="240">
<Original>
parseIntoConfig( argv, config )
</Original>
<Expanded>
parseIntoConfig( argv, config )
</Expanded>
</Expression>
TestMain.cpp" line="242">
<Original>
config.allowThrows == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
<OverallResults successes="2" failures="0"/>
</Section>
<OverallResults successes="2" failures="0"/>
</Section>
<Section name="nothrow">
<Section name="--nothrow">
TestMain.cpp" line="246">
<Original>
parseIntoConfig( argv, config )
</Original>
<Expanded>
parseIntoConfig( argv, config )
</Expanded>
</Expression>
TestMain.cpp" line="248">
<Original>
config.allowThrows == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
<OverallResults successes="2" failures="0"/>
</Section>
<OverallResults successes="2" failures="0"/>
</Section>
<Section name="nothrow">
<OverallResults successes="0" failures="0"/>
</Section>
<Section name="streams">
<Section name="-o filename">
TestMain.cpp" line="255">
<Original>
parseIntoConfig( argv, config )
</Original>
<Expanded>
parseIntoConfig( argv, config )
</Expanded>
</Expression>
TestMain.cpp" line="257">
<Original>
config.outputFilename == &quot;filename.ext&quot;
</Original>
<Expanded>
&quot;filename.ext&quot; == &quot;filename.ext&quot;
</Expanded>
</Expression>
TestMain.cpp" line="258">
<Original>
config.stream.empty()
</Original>
<Expanded>
true
</Expanded>
</Expression>
<OverallResults successes="3" failures="0"/>
</Section>
<OverallResults successes="3" failures="0"/>
</Section>
<Section name="streams">
<Section name="-o %stdout">
TestMain.cpp" line="262">
<Original>
parseIntoConfig( argv, config )
</Original>
<Expanded>
parseIntoConfig( argv, config )
</Expanded>
</Expression>
TestMain.cpp" line="264">
<Original>
config.stream == &quot;stdout&quot;
</Original>
<Expanded>
&quot;stdout&quot; == &quot;stdout&quot;
</Expanded>
</Expression>
TestMain.cpp" line="265">
<Original>
config.outputFilename.empty()
</Original>
<Expanded>
true
</Expanded>
</Expression>
<OverallResults successes="3" failures="0"/>
</Section>
<OverallResults successes="3" failures="0"/>
</Section>
<Section name="streams">
<Section name="--out">
TestMain.cpp" line="269">
<Original>
parseIntoConfig( argv, config )
</Original>
<Expanded>
parseIntoConfig( argv, config )
</Expanded>
</Expression>
TestMain.cpp" line="271">
<Original>
config.outputFilename == &quot;filename.ext&quot;
</Original>
<Expanded>
&quot;filename.ext&quot; == &quot;filename.ext&quot;
</Expanded>
</Expression>
<OverallResults successes="2" failures="0"/>
</Section>
<OverallResults successes="2" failures="0"/>
</Section>
<Section name="streams">
<OverallResults successes="0" failures="0"/>
</Section>
<Section name="combinations">
<Section name="-a -b">
TestMain.cpp" line="278">
<Original>
parseIntoConfig( argv, config )
</Original>
<Expanded>
parseIntoConfig( argv, config )
</Expanded>
</Expression>
TestMain.cpp" line="280">
<Original>
config.cutoff == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
TestMain.cpp" line="281">
<Original>
config.shouldDebugBreak
</Original>
<Expanded>
true
</Expanded>
</Expression>
TestMain.cpp" line="282">
<Original>
config.allowThrows == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
<OverallResults successes="4" failures="0"/>
</Section>
<OverallResults successes="4" failures="0"/>
</Section>
<OverallResult success="true"/>
</TestCase>
<TestCase name="selftest/test filter">
TestMain.cpp" line="291">
<Original>
matchAny.shouldInclude( fakeTestCase( &quot;any&quot; ) )
</Original>
<Expanded>
true
</Expanded>
</Expression>
TestMain.cpp" line="292">
<Original>
matchNone.shouldInclude( fakeTestCase( &quot;any&quot; ) ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
TestMain.cpp" line="297">
<Original>
matchHidden.shouldInclude( fakeTestCase( &quot;any&quot; ) ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
TestMain.cpp" line="298">
<Original>
matchNonHidden.shouldInclude( fakeTestCase( &quot;any&quot; ) )
</Original>
<Expanded>
true
</Expanded>
</Expression>
TestMain.cpp" line="300">
<Original>
matchHidden.shouldInclude( fakeTestCase( &quot;./any&quot; ) )
</Original>
<Expanded>
true
</Expanded>
</Expression>
TestMain.cpp" line="301">
<Original>
matchNonHidden.shouldInclude( fakeTestCase( &quot;./any&quot; ) ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="selftest/test filters">
TestMain.cpp" line="312">
<Original>
matchHidden.shouldInclude( fakeTestCase( &quot;./something&quot; ) )
</Original>
<Expanded>
true
</Expanded>
</Expression>
TestMain.cpp" line="314">
<Original>
filters.shouldInclude( fakeTestCase( &quot;any&quot; ) ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
TestMain.cpp" line="315">
<Original>
filters.shouldInclude( fakeTestCase( &quot;./something&quot; ) )
</Original>
<Expanded>
true
</Expanded>
</Expression>
TestMain.cpp" line="316">
<Original>
filters.shouldInclude( fakeTestCase( &quot;./anything&quot; ) ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="selftest/filter/prefix wildcard">
TestMain.cpp" line="322">
<Original>
matchBadgers.shouldInclude( fakeTestCase( &quot;big badger&quot; ) )
</Original>
<Expanded>
true
</Expanded>
</Expression>
TestMain.cpp" line="323">
<Original>
matchBadgers.shouldInclude( fakeTestCase( &quot;little badgers&quot; ) ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="selftest/filter/wildcard at both ends">
TestMain.cpp" line="328">
<Original>
matchBadgers.shouldInclude( fakeTestCase( &quot;big badger&quot; ) )
</Original>
<Expanded>
true
</Expanded>
</Expression>
TestMain.cpp" line="329">
<Original>
matchBadgers.shouldInclude( fakeTestCase( &quot;little badgers&quot; ) )
</Original>
<Expanded>
true
</Expanded>
</Expression>
TestMain.cpp" line="330">
<Original>
matchBadgers.shouldInclude( fakeTestCase( &quot;badgers are big&quot; ) )
</Original>
<Expanded>
true
</Expanded>
</Expression>
TestMain.cpp" line="331">
<Original>
matchBadgers.shouldInclude( fakeTestCase( &quot;hedgehogs&quot; ) ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="selftest/option parsers">
TestMain.cpp" line="351">
<Original>
opt.parseIntoConfig( parser, config )
</Original>
<Expanded>
opt.parseIntoConfig( parser, config )
</Expanded>
</Expression>
TestMain.cpp" line="353">
<Original>
config.filters.size() == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
TestMain.cpp" line="354">
<Original>
config.filters[0].shouldInclude( fakeTestCase( &quot;notIncluded&quot; ) ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
TestMain.cpp" line="355">
<Original>
config.filters[0].shouldInclude( fakeTestCase( &quot;test1&quot; ) )
</Original>
<Expanded>
true
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="selftest/tags">
<Section name="one tag">
TestMain.cpp" line="369">
<Original>
oneTag.getTestCaseInfo().description == &quot;&quot;
</Original>
<Expanded>
&quot;&quot; == &quot;&quot;
</Expanded>
</Expression>
TestMain.cpp" line="370">
<Original>
oneTag.hasTag( &quot;one&quot; )
</Original>
<Expanded>
true
</Expanded>
</Expression>
TestMain.cpp" line="371">
<Original>
oneTag.getTags().size() == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
TestMain.cpp" line="373">
<Original>
oneTag.matchesTags( p1 ) == true
</Original>
<Expanded>
true == true
</Expanded>
</Expression>
TestMain.cpp" line="374">
<Original>
oneTag.matchesTags( p2 ) == true
</Original>
<Expanded>
true == true
</Expanded>
</Expression>
TestMain.cpp" line="375">
<Original>
oneTag.matchesTags( p3 ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
TestMain.cpp" line="376">
<Original>
oneTag.matchesTags( p4 ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
TestMain.cpp" line="377">
<Original>
oneTag.matchesTags( p5 ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
<OverallResults successes="8" failures="0"/>
</Section>
<Section name="two tags">
TestMain.cpp" line="383">
<Original>
twoTags.getTestCaseInfo().description == &quot;&quot;
</Original>
<Expanded>
&quot;&quot; == &quot;&quot;
</Expanded>
</Expression>
TestMain.cpp" line="384">
<Original>
twoTags.hasTag( &quot;one&quot; )
</Original>
<Expanded>
true
</Expanded>
</Expression>
TestMain.cpp" line="385">
<Original>
twoTags.hasTag( &quot;two&quot; )
</Original>
<Expanded>
true
</Expanded>
</Expression>
TestMain.cpp" line="386">
<Original>
twoTags.hasTag( &quot;three&quot; ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
TestMain.cpp" line="387">
<Original>
twoTags.getTags().size() == 2
</Original>
<Expanded>
2 == 2
</Expanded>
</Expression>
TestMain.cpp" line="389">
<Original>
twoTags.matchesTags( p1 ) == true
</Original>
<Expanded>
true == true
</Expanded>
</Expression>
TestMain.cpp" line="390">
<Original>
twoTags.matchesTags( p2 ) == true
</Original>
<Expanded>
true == true
</Expanded>
</Expression>
TestMain.cpp" line="391">
<Original>
twoTags.matchesTags( p3 ) == true
</Original>
<Expanded>
true == true
</Expanded>
</Expression>
TestMain.cpp" line="392">
<Original>
twoTags.matchesTags( p4 ) == true
</Original>
<Expanded>
true == true
</Expanded>
</Expression>
TestMain.cpp" line="393">
<Original>
twoTags.matchesTags( p5 ) == true
</Original>
<Expanded>
true == true
</Expanded>
</Expression>
<OverallResults successes="10" failures="0"/>
</Section>
<Section name="one tag with characters either side">
TestMain.cpp" line="399">
<Original>
oneTagWithExtras.getTestCaseInfo().description == &quot;1234&quot;
</Original>
<Expanded>
&quot;1234&quot; == &quot;1234&quot;
</Expanded>
</Expression>
TestMain.cpp" line="400">
<Original>
oneTagWithExtras.hasTag( &quot;one&quot; )
</Original>
<Expanded>
true
</Expanded>
</Expression>
TestMain.cpp" line="401">
<Original>
oneTagWithExtras.hasTag( &quot;two&quot; ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
TestMain.cpp" line="402">
<Original>
oneTagWithExtras.getTags().size() == 1
</Original>
<Expanded>
1 == 1
</Expanded>
</Expression>
<OverallResults successes="4" failures="0"/>
</Section>
<Section name="start of a tag, but not closed">
TestMain.cpp" line="409">
<Original>
oneTagOpen.getTestCaseInfo().description == &quot;[one&quot;
</Original>
<Expanded>
&quot;[one&quot; == &quot;[one&quot;
</Expanded>
</Expression>
TestMain.cpp" line="410">
<Original>
oneTagOpen.hasTag( &quot;one&quot; ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
TestMain.cpp" line="411">
<Original>
oneTagOpen.getTags().size() == 0
</Original>
<Expanded>
0 == 0
</Expanded>
</Expression>
<OverallResults successes="3" failures="0"/>
</Section>
<Section name="hidden">
TestMain.cpp" line="417">
<Original>
oneTag.getTestCaseInfo().description == &quot;&quot;
</Original>
<Expanded>
&quot;&quot; == &quot;&quot;
</Expanded>
</Expression>
TestMain.cpp" line="418">
<Original>
oneTag.hasTag( &quot;hide&quot; )
</Original>
<Expanded>
true
</Expanded>
</Expression>
TestMain.cpp" line="419">
<Original>
oneTag.isHidden()
</Original>
<Expanded>
true
</Expanded>
</Expression>
TestMain.cpp" line="421">
<Original>
oneTag.matchesTags( &quot;~[hide]&quot; ) == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
<OverallResults successes="4" failures="0"/>
</Section>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/Tricky/std::pair">
TrickyTests.cpp" line="37">
<Original>
(std::pair&lt;int, int>( 1, 2 )) == aNicePair
</Original>
<Expanded>
std::pair( 1, 2 )
==
std::pair( 1, 2 )
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./inprogress/failing/Tricky/trailing expression">
<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">
<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">
TrickyTests.cpp" line="95">
<Original>
&amp;o1 == &amp;o2
</Original>
<Expanded>
0x<hex digits> == 0x<hex digits>
</Expanded>
</Expression>
TrickyTests.cpp" line="96">
<Original>
o1 == o2
</Original>
<Expanded>
{?} == {?}
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./failing/string literals">
TrickyTests.cpp" line="106">
<Original>
std::string( &quot;first&quot; ) == &quot;second&quot;
</Original>
<Expanded>
&quot;first&quot; == &quot;second&quot;
</Expanded>
</Expression>
<OverallResult success="false"/>
</TestCase>
<TestCase name="./succeeding/side-effects">
TrickyTests.cpp" line="119">
<Original>
i++ == 7
</Original>
<Expanded>
7 == 7
</Expanded>
</Expression>
TrickyTests.cpp" line="120">
<Original>
i++ == 8
</Original>
<Expanded>
8 == 8
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/koenig">
TrickyTests.cpp" line="186">
<Original>
0x<hex digits> == o
</Original>
<Expanded>
0x<hex digits> == {?}
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/non-const==">
TrickyTests.cpp" line="212">
<Original>
t == 1u
</Original>
<Expanded>
{?} == 1
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/enum/bits">
TrickyTests.cpp" line="224">
<Original>
0x<hex digits> == bit30and31
</Original>
<Expanded>
0x<hex digits> == 3221225472
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/boolean member">
TrickyTests.cpp" line="239">
<Original>
obj.prop != __null
</Original>
<Expanded>
0x<hex digits> != 0
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/unimplemented static bool">
<Section name="compare to true">
TrickyTests.cpp" line="259">
<Original>
is_true&lt;true>::value == true
</Original>
<Expanded>
true == true
</Expanded>
</Expression>
TrickyTests.cpp" line="260">
<Original>
true == is_true&lt;true>::value
</Original>
<Expanded>
true == true
</Expanded>
</Expression>
<OverallResults successes="2" failures="0"/>
</Section>
<Section name="compare to false">
TrickyTests.cpp" line="264">
<Original>
is_true&lt;false>::value == false
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
TrickyTests.cpp" line="265">
<Original>
false == is_true&lt;false>::value
</Original>
<Expanded>
false == false
</Expanded>
</Expression>
<OverallResults successes="2" failures="0"/>
</Section>
<Section name="negation">
TrickyTests.cpp" line="270">
<Original>
!is_true&lt;false>::value
</Original>
<Expanded>
true
</Expanded>
</Expression>
<OverallResults successes="1" failures="0"/>
</Section>
<Section name="double negation">
TrickyTests.cpp" line="275">
<Original>
!!is_true&lt;true>::value
</Original>
<Expanded>
true
</Expanded>
</Expression>
<OverallResults successes="1" failures="0"/>
</Section>
<Section name="direct">
TrickyTests.cpp" line="280">
<Original>
is_true&lt;true>::value
</Original>
<Expanded>
true
</Expanded>
</Expression>
TrickyTests.cpp" line="281">
<Original>
!is_true&lt;false>::value
</Original>
<Expanded>
!false
</Expanded>
</Expression>
<OverallResults successes="2" failures="0"/>
</Section>
<OverallResult success="true"/>
</TestCase>
<TestCase name="./succeeding/SafeBool">
TrickyTests.cpp" line="313">
<Original>
True
</Original>
<Expanded>
true
</Expanded>
</Expression>
TrickyTests.cpp" line="314">
<Original>
!False
</Original>
<Expanded>
true
</Expanded>
</Expression>
TrickyTests.cpp" line="315">
<Original>
!False
</Original>
<Expanded>
!false
</Expanded>
</Expression>
<OverallResult success="true"/>
</TestCase>
<TestCase name="scenario name">
<Section name="This stuff exists">
<Section name="I do this">
<Section name="it should do this">
BDDTests.cpp" line="37">
<Original>
itDoesThis()
</Original>
<Expanded>
true
</Expanded>
</Expression>
<OverallResults successes="1" failures="0"/>
</Section>
<OverallResults successes="1" failures="0"/>
</Section>
<OverallResults successes="1" failures="0"/>
</Section>
<OverallResult success="true"/>
</TestCase>
<OverallResults successes="506" failures="101"/>
</Group>
<OverallResults successes="506" failures="101"/>
</Catch>
Reference in New Issue View Git Blame Copy Permalink