~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
CatchSelfTest is a Catch v0.9 b38 (integration) host application.
Run with -? for options

-------------------------------------------------------------------------------
./succeeding/Approx/simple
-------------------------------------------------------------------------------
ApproxTests.cpp:16
...............................................................................

ApproxTests.cpp:20:
PASSED:
  REQUIRE( d == Approx( 1.23 ) )
with expansion:
  1.23 == Approx( 1.23 )

ApproxTests.cpp:21:
PASSED:
  REQUIRE( d != Approx( 1.22 ) )
with expansion:
  1.23 != Approx( 1.22 )

ApproxTests.cpp:22:
PASSED:
  REQUIRE( d != Approx( 1.24 ) )
with expansion:
  1.23 != Approx( 1.24 )

ApproxTests.cpp:24:
PASSED:
  REQUIRE( Approx( d ) == 1.23 )
with expansion:
  Approx( 1.23 ) == 1.23

ApproxTests.cpp:25:
PASSED:
  REQUIRE( Approx( d ) != 1.22 )
with expansion:
  Approx( 1.23 ) != 1.22

ApproxTests.cpp:26:
PASSED:
  REQUIRE( Approx( d ) != 1.24 )
with expansion:
  Approx( 1.23 ) != 1.24

-------------------------------------------------------------------------------
./succeeding/Approx/epsilon
-------------------------------------------------------------------------------
ApproxTests.cpp:34
...............................................................................

ApproxTests.cpp:38:
PASSED:
  REQUIRE( d != Approx( 1.231 ) )
with expansion:
  1.23 != Approx( 1.231 )

ApproxTests.cpp:39:
PASSED:
  REQUIRE( d == Approx( 1.231 ).epsilon( 0.1 ) )
with expansion:
  1.23 == Approx( 1.231 )

-------------------------------------------------------------------------------
./succeeding/Approx/float
-------------------------------------------------------------------------------
ApproxTests.cpp:47
...............................................................................

ApproxTests.cpp:49:
PASSED:
  REQUIRE( 1.23f == Approx( 1.23f ) )
with expansion:
  1.23 == Approx( 1.23 )

ApproxTests.cpp:50:
PASSED:
  REQUIRE( 0.0f == Approx( 0.0f ) )
with expansion:
  0 == Approx( 0 )

-------------------------------------------------------------------------------
./succeeding/Approx/int
-------------------------------------------------------------------------------
ApproxTests.cpp:58
...............................................................................

ApproxTests.cpp:60:
PASSED:
  REQUIRE( 1 == Approx( 1 ) )

ApproxTests.cpp:61:
PASSED:
  REQUIRE( 0 == Approx( 0 ) )

-------------------------------------------------------------------------------
./succeeding/Approx/mixed
-------------------------------------------------------------------------------
ApproxTests.cpp:69
...............................................................................

ApproxTests.cpp:75:
PASSED:
  REQUIRE( 1.0f == Approx( 1 ) )
with expansion:
  1 == Approx( 1 )

ApproxTests.cpp:76:
PASSED:
  REQUIRE( 0 == Approx( dZero) )
with expansion:
  0 == Approx( 0 )

ApproxTests.cpp:77:
PASSED:
  REQUIRE( 0 == Approx( dSmall ).epsilon( 0.001 ) )
with expansion:
  0 == Approx( 1e-05 )

ApproxTests.cpp:78:
PASSED:
  REQUIRE( 1.234f == Approx( dMedium ) )
with expansion:
  1.234 == Approx( 1.234 )

ApproxTests.cpp:79:
PASSED:
  REQUIRE( dMedium == Approx( 1.234f ) )
with expansion:
  1.234 == Approx( 1.234 )

-------------------------------------------------------------------------------
./succeeding/Approx/custom
-------------------------------------------------------------------------------
ApproxTests.cpp:87
...............................................................................

ApproxTests.cpp:93:
PASSED:
  REQUIRE( d == approx( 1.23 ) )
with expansion:
  1.23 == Approx( 1.23 )

ApproxTests.cpp:94:
PASSED:
  REQUIRE( d == approx( 1.22 ) )
with expansion:
  1.23 == Approx( 1.22 )

ApproxTests.cpp:95:
PASSED:
  REQUIRE( d == approx( 1.24 ) )
with expansion:
  1.23 == Approx( 1.24 )

ApproxTests.cpp:96:
PASSED:
  REQUIRE( d != approx( 1.25 ) )
with expansion:
  1.23 != Approx( 1.25 )

ApproxTests.cpp:98:
PASSED:
  REQUIRE( approx( d ) == 1.23 )
with expansion:
  Approx( 1.23 ) == 1.23

ApproxTests.cpp:99:
PASSED:
  REQUIRE( approx( d ) == 1.22 )
with expansion:
  Approx( 1.23 ) == 1.22

ApproxTests.cpp:100:
PASSED:
  REQUIRE( approx( d ) == 1.24 )
with expansion:
  Approx( 1.23 ) == 1.24

ApproxTests.cpp:101:
PASSED:
  REQUIRE( approx( d ) != 1.25 )
with expansion:
  Approx( 1.23 ) != 1.25

-------------------------------------------------------------------------------
Approximate PI
-------------------------------------------------------------------------------
ApproxTests.cpp:108
...............................................................................

ApproxTests.cpp:110:
PASSED:
  REQUIRE( divide( 22, 7 ) == Approx( 3.141 ).epsilon( 0.001 ) )
with expansion:
  3.142857142857143 == Approx( 3.141 )

ApproxTests.cpp:111:
PASSED:
  REQUIRE( divide( 22, 7 ) != Approx( 3.141 ).epsilon( 0.0001 ) )
with expansion:
  3.142857142857143 != Approx( 3.141 )

-------------------------------------------------------------------------------
./succeeding/TestClass/succeedingCase
-------------------------------------------------------------------------------
ClassTests.cpp:34
...............................................................................

ClassTests.cpp:24:
PASSED:
  REQUIRE( s == "hello" )
with expansion:
  "hello" == "hello"

-------------------------------------------------------------------------------
./failing/TestClass/failingCase
-------------------------------------------------------------------------------
ClassTests.cpp:35
...............................................................................

ClassTests.cpp:28: FAILED:
  REQUIRE( s == "world" )
with expansion:
  "hello" == "world"

-------------------------------------------------------------------------------
./succeeding/Fixture/succeedingCase
-------------------------------------------------------------------------------
ClassTests.cpp:45
...............................................................................

ClassTests.cpp:47:
PASSED:
  REQUIRE( m_a == 1 )
with expansion:
  1 == 1

-------------------------------------------------------------------------------
./failing/Fixture/failingCase
-------------------------------------------------------------------------------
ClassTests.cpp:53
...............................................................................

ClassTests.cpp:55: FAILED:
  REQUIRE( m_a == 2 )
with expansion:
  1 == 2

-------------------------------------------------------------------------------
./succeeding/conditions/equality
-------------------------------------------------------------------------------
ConditionTests.cpp:47
...............................................................................

ConditionTests.cpp:55:
PASSED:
  REQUIRE( data.int_seven == 7 )
with expansion:
  7 == 7

ConditionTests.cpp:56:
PASSED:
  REQUIRE( data.float_nine_point_one == Approx( 9.1f ) )
with expansion:
  9.1 == Approx( 9.1 )

ConditionTests.cpp:57:
PASSED:
  REQUIRE( data.double_pi == Approx( 3.1415926535 ) )
with expansion:
  3.1415926535 == Approx( 3.14159 )

ConditionTests.cpp:58:
PASSED:
  REQUIRE( data.str_hello == "hello" )
with expansion:
  "hello" == "hello"

ConditionTests.cpp:59:
PASSED:
  REQUIRE( "hello" == data.str_hello )
with expansion:
  "hello" == "hello"

ConditionTests.cpp:60:
PASSED:
  REQUIRE( data.str_hello.size() == 5 )
with expansion:
  5 == 5

ConditionTests.cpp:63:
PASSED:
  REQUIRE( x == Approx( 1.3 ) )
with expansion:
  1.3 == Approx( 1.3 )

-------------------------------------------------------------------------------
./failing/conditions/equality
-------------------------------------------------------------------------------
ConditionTests.cpp:67
...............................................................................

ConditionTests.cpp:71: FAILED:
  CHECK( data.int_seven == 6 )
with expansion:
  7 == 6

ConditionTests.cpp:72: FAILED:
  CHECK( data.int_seven == 8 )
with expansion:
  7 == 8

ConditionTests.cpp:73: FAILED:
  CHECK( data.int_seven == 0 )
with expansion:
  7 == 0

ConditionTests.cpp:74: FAILED:
  CHECK( data.float_nine_point_one == Approx( 9.11f ) )
with expansion:
  9.1 == Approx( 9.11 )

ConditionTests.cpp:75: FAILED:
  CHECK( data.float_nine_point_one == Approx( 9.0f ) )
with expansion:
  9.1 == Approx( 9 )

ConditionTests.cpp:76: FAILED:
  CHECK( data.float_nine_point_one == Approx( 1 ) )
with expansion:
  9.1 == Approx( 1 )

ConditionTests.cpp:77: FAILED:
  CHECK( data.float_nine_point_one == Approx( 0 ) )
with expansion:
  9.1 == Approx( 0 )

ConditionTests.cpp:78: FAILED:
  CHECK( data.double_pi == Approx( 3.1415 ) )
with expansion:
  3.1415926535 == Approx( 3.1415 )

ConditionTests.cpp:79: FAILED:
  CHECK( data.str_hello == "goodbye" )
with expansion:
  "hello" == "goodbye"

ConditionTests.cpp:80: FAILED:
  CHECK( data.str_hello == "hell" )
with expansion:
  "hello" == "hell"

ConditionTests.cpp:81: FAILED:
  CHECK( data.str_hello == "hello1" )
with expansion:
  "hello" == "hello1"

ConditionTests.cpp:82: FAILED:
  CHECK( data.str_hello.size() == 6 )
with expansion:
  5 == 6

ConditionTests.cpp:85: FAILED:
  CHECK( x == Approx( 1.301 ) )
with expansion:
  1.3 == Approx( 1.301 )

-------------------------------------------------------------------------------
./succeeding/conditions/inequality
-------------------------------------------------------------------------------
ConditionTests.cpp:89
...............................................................................

ConditionTests.cpp:93:
PASSED:
  REQUIRE( data.int_seven != 6 )
with expansion:
  7 != 6

ConditionTests.cpp:94:
PASSED:
  REQUIRE( data.int_seven != 8 )
with expansion:
  7 != 8

ConditionTests.cpp:95:
PASSED:
  REQUIRE( data.float_nine_point_one != Approx( 9.11f ) )
with expansion:
  9.1 != Approx( 9.11 )

ConditionTests.cpp:96:
PASSED:
  REQUIRE( data.float_nine_point_one != Approx( 9.0f ) )
with expansion:
  9.1 != Approx( 9 )

ConditionTests.cpp:97:
PASSED:
  REQUIRE( data.float_nine_point_one != Approx( 1 ) )
with expansion:
  9.1 != Approx( 1 )

ConditionTests.cpp:98:
PASSED:
  REQUIRE( data.float_nine_point_one != Approx( 0 ) )
with expansion:
  9.1 != Approx( 0 )

ConditionTests.cpp:99:
PASSED:
  REQUIRE( data.double_pi != Approx( 3.1415 ) )
with expansion:
  3.1415926535 != Approx( 3.1415 )

ConditionTests.cpp:100:
PASSED:
  REQUIRE( data.str_hello != "goodbye" )
with expansion:
  "hello" != "goodbye"

ConditionTests.cpp:101:
PASSED:
  REQUIRE( data.str_hello != "hell" )
with expansion:
  "hello" != "hell"

ConditionTests.cpp:102:
PASSED:
  REQUIRE( data.str_hello != "hello1" )
with expansion:
  "hello" != "hello1"

ConditionTests.cpp:103:
PASSED:
  REQUIRE( data.str_hello.size() != 6 )
with expansion:
  5 != 6

-------------------------------------------------------------------------------
./failing/conditions/inequality
-------------------------------------------------------------------------------
ConditionTests.cpp:107
...............................................................................

ConditionTests.cpp:111: FAILED:
  CHECK( data.int_seven != 7 )
with expansion:
  7 != 7

ConditionTests.cpp:112: FAILED:
  CHECK( data.float_nine_point_one != Approx( 9.1f ) )
with expansion:
  9.1 != Approx( 9.1 )

ConditionTests.cpp:113: FAILED:
  CHECK( data.double_pi != Approx( 3.1415926535 ) )
with expansion:
  3.1415926535 != Approx( 3.14159 )

ConditionTests.cpp:114: FAILED:
  CHECK( data.str_hello != "hello" )
with expansion:
  "hello" != "hello"

ConditionTests.cpp:115: FAILED:
  CHECK( data.str_hello.size() != 5 )
with expansion:
  5 != 5

-------------------------------------------------------------------------------
./succeeding/conditions/ordered
-------------------------------------------------------------------------------
ConditionTests.cpp:120
...............................................................................

ConditionTests.cpp:124:
PASSED:
  REQUIRE( data.int_seven < 8 )
with expansion:
  7 < 8

ConditionTests.cpp:125:
PASSED:
  REQUIRE( data.int_seven > 6 )
with expansion:
  7 > 6

ConditionTests.cpp:126:
PASSED:
  REQUIRE( data.int_seven > 0 )
with expansion:
  7 > 0

ConditionTests.cpp:127:
PASSED:
  REQUIRE( data.int_seven > -1 )
with expansion:
  7 > -1

ConditionTests.cpp:129:
PASSED:
  REQUIRE( data.int_seven >= 7 )
with expansion:
  7 >= 7

ConditionTests.cpp:130:
PASSED:
  REQUIRE( data.int_seven >= 6 )
with expansion:
  7 >= 6

ConditionTests.cpp:131:
PASSED:
  REQUIRE( data.int_seven <= 7 )
with expansion:
  7 <= 7

ConditionTests.cpp:132:
PASSED:
  REQUIRE( data.int_seven <= 8 )
with expansion:
  7 <= 8

ConditionTests.cpp:134:
PASSED:
  REQUIRE( data.float_nine_point_one > 9 )
with expansion:
  9.1 > 9

ConditionTests.cpp:135:
PASSED:
  REQUIRE( data.float_nine_point_one < 10 )
with expansion:
  9.1 < 10

ConditionTests.cpp:136:
PASSED:
  REQUIRE( data.float_nine_point_one < 9.2 )
with expansion:
  9.1 < 9.199999999999999

ConditionTests.cpp:138:
PASSED:
  REQUIRE( data.str_hello <= "hello" )
with expansion:
  "hello" <= "hello"

ConditionTests.cpp:139:
PASSED:
  REQUIRE( data.str_hello >= "hello" )
with expansion:
  "hello" >= "hello"

ConditionTests.cpp:141:
PASSED:
  REQUIRE( data.str_hello < "hellp" )
with expansion:
  "hello" < "hellp"

ConditionTests.cpp:142:
PASSED:
  REQUIRE( data.str_hello < "zebra" )
with expansion:
  "hello" < "zebra"

ConditionTests.cpp:143:
PASSED:
  REQUIRE( data.str_hello > "hellm" )
with expansion:
  "hello" > "hellm"

ConditionTests.cpp:144:
PASSED:
  REQUIRE( data.str_hello > "a" )
with expansion:
  "hello" > "a"

-------------------------------------------------------------------------------
./failing/conditions/ordered
-------------------------------------------------------------------------------
ConditionTests.cpp:148
...............................................................................

ConditionTests.cpp:152: FAILED:
  CHECK( data.int_seven > 7 )
with expansion:
  7 > 7

ConditionTests.cpp:153: FAILED:
  CHECK( data.int_seven < 7 )
with expansion:
  7 < 7

ConditionTests.cpp:154: FAILED:
  CHECK( data.int_seven > 8 )
with expansion:
  7 > 8

ConditionTests.cpp:155: FAILED:
  CHECK( data.int_seven < 6 )
with expansion:
  7 < 6

ConditionTests.cpp:156: FAILED:
  CHECK( data.int_seven < 0 )
with expansion:
  7 < 0

ConditionTests.cpp:157: FAILED:
  CHECK( data.int_seven < -1 )
with expansion:
  7 < -1

ConditionTests.cpp:159: FAILED:
  CHECK( data.int_seven >= 8 )
with expansion:
  7 >= 8

ConditionTests.cpp:160: FAILED:
  CHECK( data.int_seven <= 6 )
with expansion:
  7 <= 6

ConditionTests.cpp:162: FAILED:
  CHECK( data.float_nine_point_one < 9 )
with expansion:
  9.1 < 9

ConditionTests.cpp:163: FAILED:
  CHECK( data.float_nine_point_one > 10 )
with expansion:
  9.1 > 10

ConditionTests.cpp:164: FAILED:
  CHECK( data.float_nine_point_one > 9.2 )
with expansion:
  9.1 > 9.199999999999999

ConditionTests.cpp:166: FAILED:
  CHECK( data.str_hello > "hello" )
with expansion:
  "hello" > "hello"

ConditionTests.cpp:167: FAILED:
  CHECK( data.str_hello < "hello" )
with expansion:
  "hello" < "hello"

ConditionTests.cpp:168: FAILED:
  CHECK( data.str_hello > "hellp" )
with expansion:
  "hello" > "hellp"

ConditionTests.cpp:169: FAILED:
  CHECK( data.str_hello > "z" )
with expansion:
  "hello" > "z"

ConditionTests.cpp:170: FAILED:
  CHECK( data.str_hello < "hellm" )
with expansion:
  "hello" < "hellm"

ConditionTests.cpp:171: FAILED:
  CHECK( data.str_hello < "a" )
with expansion:
  "hello" < "a"

ConditionTests.cpp:173: FAILED:
  CHECK( data.str_hello >= "z" )
with expansion:
  "hello" >= "z"

ConditionTests.cpp:174: FAILED:
  CHECK( data.str_hello <= "a" )
with expansion:
  "hello" <= "a"

-------------------------------------------------------------------------------
./succeeding/conditions/int literals
-------------------------------------------------------------------------------
ConditionTests.cpp:179
...............................................................................

ConditionTests.cpp:188:
PASSED:
  REQUIRE( i == 1 )
with expansion:
  1 == 1

ConditionTests.cpp:189:
PASSED:
  REQUIRE( ui == 2 )
with expansion:
  2 == 2

ConditionTests.cpp:190:
PASSED:
  REQUIRE( l == 3 )
with expansion:
  3 == 3

ConditionTests.cpp:191:
PASSED:
  REQUIRE( ul == 4 )
with expansion:
  4 == 4

ConditionTests.cpp:192:
PASSED:
  REQUIRE( c == 5 )
with expansion:
  5 == 5

ConditionTests.cpp:193:
PASSED:
  REQUIRE( uc == 6 )
with expansion:
  6 == 6

ConditionTests.cpp:195:
PASSED:
  REQUIRE( 1 == i )
with expansion:
  1 == 1

ConditionTests.cpp:196:
PASSED:
  REQUIRE( 2 == ui )
with expansion:
  2 == 2

ConditionTests.cpp:197:
PASSED:
  REQUIRE( 3 == l )
with expansion:
  3 == 3

ConditionTests.cpp:198:
PASSED:
  REQUIRE( 4 == ul )
with expansion:
  4 == 4

ConditionTests.cpp:199:
PASSED:
  REQUIRE( 5 == c )
with expansion:
  5 == 5

ConditionTests.cpp:200:
PASSED:
  REQUIRE( 6 == uc )
with expansion:
  6 == 6

ConditionTests.cpp:202:
PASSED:
  REQUIRE( (std::numeric_limits<unsigned long>::max)() > ul )
with expansion:
  0x<hex digits> > 4

-------------------------------------------------------------------------------
./succeeding/conditions//long_to_unsigned_x
-------------------------------------------------------------------------------
ConditionTests.cpp:218
...............................................................................

ConditionTests.cpp:226:
PASSED:
  REQUIRE( long_var == unsigned_char_var )
with expansion:
  1 == 1

ConditionTests.cpp:227:
PASSED:
  REQUIRE( long_var == unsigned_short_var )
with expansion:
  1 == 1

ConditionTests.cpp:228:
PASSED:
  REQUIRE( long_var == unsigned_int_var )
with expansion:
  1 == 1

ConditionTests.cpp:229:
PASSED:
  REQUIRE( long_var == unsigned_long_var )
with expansion:
  1 == 1

-------------------------------------------------------------------------------
./succeeding/conditions/const ints to int literal
-------------------------------------------------------------------------------
ConditionTests.cpp:233
...............................................................................

ConditionTests.cpp:240:
PASSED:
  REQUIRE( unsigned_char_var == 1 )
with expansion:
  1 == 1

ConditionTests.cpp:241:
PASSED:
  REQUIRE( unsigned_short_var == 1 )
with expansion:
  1 == 1

ConditionTests.cpp:242:
PASSED:
  REQUIRE( unsigned_int_var == 1 )
with expansion:
  1 == 1

ConditionTests.cpp:243:
PASSED:
  REQUIRE( unsigned_long_var == 1 )
with expansion:
  1 == 1

-------------------------------------------------------------------------------
./succeeding/conditions/negative ints
-------------------------------------------------------------------------------
ConditionTests.cpp:247
...............................................................................

ConditionTests.cpp:249:
PASSED:
  CHECK( ( -1 > 2u ) )
with expansion:
  true

ConditionTests.cpp:250:
PASSED:
  CHECK( -1 > 2u )
with expansion:
  -1 > 2

ConditionTests.cpp:252:
PASSED:
  CHECK( ( 2u < -1 ) )
with expansion:
  true

ConditionTests.cpp:253:
PASSED:
  CHECK( 2u < -1 )
with expansion:
  2 < -1

ConditionTests.cpp:256:
PASSED:
  CHECK( ( minInt > 2u ) )
with expansion:
  true

ConditionTests.cpp:257:
PASSED:
  CHECK( minInt > 2u )
with expansion:
  -2147483648 > 2

-------------------------------------------------------------------------------
./succeeding/conditions/computed ints
-------------------------------------------------------------------------------
ConditionTests.cpp:270
...............................................................................

ConditionTests.cpp:272:
PASSED:
  CHECK( 54 == 6*9 )
with expansion:
  54 == 54

-------------------------------------------------------------------------------
./succeeding/conditions/ptr
-------------------------------------------------------------------------------
ConditionTests.cpp:283
...............................................................................

ConditionTests.cpp:288:
PASSED:
  REQUIRE( p == __null )
with expansion:
  __null == 0

ConditionTests.cpp:289:
PASSED:
  REQUIRE( p == pNULL )
with expansion:
  __null == __null

ConditionTests.cpp:294:
PASSED:
  REQUIRE( p != __null )
with expansion:
  0x<hex digits> != 0

ConditionTests.cpp:297:
PASSED:
  REQUIRE( cp != __null )
with expansion:
  0x<hex digits> != 0

ConditionTests.cpp:300:
PASSED:
  REQUIRE( cpc != __null )
with expansion:
  0x<hex digits> != 0

ConditionTests.cpp:302:
PASSED:
  REQUIRE( returnsNull() == __null )
with expansion:
  {null string} == 0

ConditionTests.cpp:303:
PASSED:
  REQUIRE( returnsConstNull() == __null )
with expansion:
  {null string} == 0

ConditionTests.cpp:305:
PASSED:
  REQUIRE( __null != p )
with expansion:
  0 != 0x<hex digits>

-------------------------------------------------------------------------------
./succeeding/conditions/not
-------------------------------------------------------------------------------
ConditionTests.cpp:316
...............................................................................

ConditionTests.cpp:320:
PASSED:
  REQUIRE( false == false )

ConditionTests.cpp:321:
PASSED:
  REQUIRE( true == true )

ConditionTests.cpp:322:
PASSED:
  REQUIRE( !false )
with expansion:
  true

ConditionTests.cpp:323:
PASSED:
  REQUIRE_FALSE( false )

ConditionTests.cpp:325:
PASSED:
  REQUIRE( !falseValue )
with expansion:
  true

ConditionTests.cpp:326:
PASSED:
  REQUIRE_FALSE( falseValue )
with expansion:
  !false

ConditionTests.cpp:328:
PASSED:
  REQUIRE( !(1 == 2) )
with expansion:
  true

ConditionTests.cpp:329:
PASSED:
  REQUIRE_FALSE( 1 == 2 )
with expansion:
  !(1 == 2)

-------------------------------------------------------------------------------
./failing/conditions/not
-------------------------------------------------------------------------------
ConditionTests.cpp:333
...............................................................................

ConditionTests.cpp:337: FAILED:
  CHECK( false != false )

ConditionTests.cpp:338: FAILED:
  CHECK( true != true )

ConditionTests.cpp:339: FAILED:
  CHECK( !true )
with expansion:
  false

ConditionTests.cpp:340: FAILED:
  CHECK_FALSE( true )

ConditionTests.cpp:342: FAILED:
  CHECK( !trueValue )
with expansion:
  false

ConditionTests.cpp:343: FAILED:
  CHECK_FALSE( trueValue )
with expansion:
  !true

ConditionTests.cpp:345: FAILED:
  CHECK( !(1 == 1) )
with expansion:
  false

ConditionTests.cpp:346: FAILED:
  CHECK_FALSE( 1 == 1 )
with expansion:
  !(1 == 1)

-------------------------------------------------------------------------------
./succeeding/exceptions/explicit
-------------------------------------------------------------------------------
ExceptionTests.cpp:31
...............................................................................

ExceptionTests.cpp:33:
PASSED:
  REQUIRE_THROWS_AS( thisThrows() )

ExceptionTests.cpp:34:
PASSED:
  REQUIRE_NOTHROW( thisDoesntThrow() )

ExceptionTests.cpp:35:
PASSED:
  REQUIRE_THROWS( thisThrows() )

-------------------------------------------------------------------------------
./failing/exceptions/explicit
-------------------------------------------------------------------------------
ExceptionTests.cpp:38
...............................................................................

ExceptionTests.cpp:40: FAILED:
  CHECK_THROWS_AS( thisThrows() )
due to unexpected exception with message:
  expected exception

ExceptionTests.cpp:41: FAILED:
  CHECK_THROWS_AS( thisDoesntThrow() )
because no exception was thrown where one was expected:

ExceptionTests.cpp:42: FAILED:
  CHECK_NOTHROW( thisThrows() )
due to unexpected exception with message:
  expected exception

-------------------------------------------------------------------------------
./failing/exceptions/implicit
-------------------------------------------------------------------------------
ExceptionTests.cpp:45
...............................................................................

ExceptionTests.cpp:45: FAILED:
due to unexpected exception with message:
  unexpected exception

-------------------------------------------------------------------------------
./failing/exceptions/implicit/2
-------------------------------------------------------------------------------
ExceptionTests.cpp:51
...............................................................................

ExceptionTests.cpp:53:
PASSED:
  CHECK( 1 == 1 )

ExceptionTests.cpp:53: FAILED:
  {Unknown expression after the reported line}
due to unexpected exception with message:
  unexpected exception

-------------------------------------------------------------------------------
./failing/exceptions/implicit/3
  section name
-------------------------------------------------------------------------------
ExceptionTests.cpp:59
...............................................................................

ExceptionTests.cpp:59: FAILED:
due to unexpected exception with message:
  unexpected exception

-------------------------------------------------------------------------------
./failing/exceptions/implicit/4
-------------------------------------------------------------------------------
ExceptionTests.cpp:66
...............................................................................

ExceptionTests.cpp:68: FAILED:
  CHECK( thisThrows() == 0 )
due to unexpected exception with message:
  expected exception

-------------------------------------------------------------------------------
./succeeding/exceptions/implicit
-------------------------------------------------------------------------------
ExceptionTests.cpp:71
...............................................................................


No assertions in test case, './succeeding/exceptions/implicit'

-------------------------------------------------------------------------------
./failing/exceptions/custom
-------------------------------------------------------------------------------
ExceptionTests.cpp:108
...............................................................................

ExceptionTests.cpp:108: FAILED:
due to unexpected exception with message:
  custom exception

-------------------------------------------------------------------------------
./failing/exceptions/custom/nothrow
-------------------------------------------------------------------------------
ExceptionTests.cpp:119
...............................................................................

ExceptionTests.cpp:121: FAILED:
  REQUIRE_NOTHROW( throwCustom() )
due to unexpected exception with message:
  custom exception - not std

-------------------------------------------------------------------------------
./failing/exceptions/custom/throw
-------------------------------------------------------------------------------
ExceptionTests.cpp:124
...............................................................................

ExceptionTests.cpp:126: FAILED:
  REQUIRE_THROWS_AS( throwCustom() )
due to unexpected exception with message:
  custom exception - not std

-------------------------------------------------------------------------------
./failing/exceptions/custom/double
-------------------------------------------------------------------------------
ExceptionTests.cpp:130
...............................................................................

ExceptionTests.cpp:130: FAILED:
due to unexpected exception with message:
  3.14

-------------------------------------------------------------------------------
./succeeding/exceptions/notimplemented
-------------------------------------------------------------------------------
ExceptionTests.cpp:140
...............................................................................

ExceptionTests.cpp:142:
PASSED:
  REQUIRE_THROWS( thisFunctionNotImplemented( 7 ) )

-------------------------------------------------------------------------------
./succeeding/generators/1
-------------------------------------------------------------------------------
GeneratorTests.cpp:19
...............................................................................

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  2 == 2

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  200 == 200

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  4 == 4

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  200 == 200

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  6 == 6

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  200 == 200

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  8 == 8

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  200 == 200

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  10 == 10

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  200 == 200

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  30 == 30

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  200 == 200

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  40 == 40

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  200 == 200

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  42 == 42

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  200 == 200

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  72 == 72

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  200 == 200

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  2 == 2

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  202 == 202

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  4 == 4

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  202 == 202

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  6 == 6

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  202 == 202

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  8 == 8

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  202 == 202

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  10 == 10

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  202 == 202

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  30 == 30

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  202 == 202

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  40 == 40

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  202 == 202

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  42 == 42

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  202 == 202

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  72 == 72

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  202 == 202

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  2 == 2

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  204 == 204

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  4 == 4

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  204 == 204

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  6 == 6

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  204 == 204

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  8 == 8

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  204 == 204

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  10 == 10

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  204 == 204

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  30 == 30

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  204 == 204

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  40 == 40

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  204 == 204

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  42 == 42

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  204 == 204

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  72 == 72

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  204 == 204

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  2 == 2

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  206 == 206

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  4 == 4

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  206 == 206

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  6 == 6

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  206 == 206

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  8 == 8

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  206 == 206

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  10 == 10

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  206 == 206

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  30 == 30

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  206 == 206

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  40 == 40

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  206 == 206

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  42 == 42

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  206 == 206

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  72 == 72

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  206 == 206

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  2 == 2

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  208 == 208

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  4 == 4

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  208 == 208

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  6 == 6

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  208 == 208

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  8 == 8

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  208 == 208

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  10 == 10

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  208 == 208

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  30 == 30

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  208 == 208

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  40 == 40

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  208 == 208

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  42 == 42

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  208 == 208

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  72 == 72

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  208 == 208

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  2 == 2

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  210 == 210

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  4 == 4

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  210 == 210

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  6 == 6

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  210 == 210

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  8 == 8

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  210 == 210

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  10 == 10

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  210 == 210

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  30 == 30

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  210 == 210

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  40 == 40

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  210 == 210

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  42 == 42

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  210 == 210

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  72 == 72

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  210 == 210

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  2 == 2

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  212 == 212

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  4 == 4

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  212 == 212

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  6 == 6

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  212 == 212

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  8 == 8

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  212 == 212

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  10 == 10

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  212 == 212

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  30 == 30

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  212 == 212

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  40 == 40

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  212 == 212

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  42 == 42

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  212 == 212

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  72 == 72

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  212 == 212

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  2 == 2

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  214 == 214

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  4 == 4

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  214 == 214

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  6 == 6

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  214 == 214

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  8 == 8

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  214 == 214

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  10 == 10

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  214 == 214

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  30 == 30

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  214 == 214

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  40 == 40

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  214 == 214

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  42 == 42

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  214 == 214

GeneratorTests.cpp:26:
PASSED:
  CATCH_REQUIRE( multiply( i, 2 ) == i*2 )
with expansion:
  72 == 72

GeneratorTests.cpp:27:
PASSED:
  CATCH_REQUIRE( multiply( j, 2 ) == j*2 )
with expansion:
  214 == 214

-------------------------------------------------------------------------------
./succeeding/generators/2
-------------------------------------------------------------------------------
GeneratorTests.cpp:32
...............................................................................

GeneratorTests.cpp:40:
PASSED:
  CATCH_REQUIRE( i->first == i->second-1 )
with expansion:
  0 == 0

GeneratorTests.cpp:40:
PASSED:
  CATCH_REQUIRE( i->first == i->second-1 )
with expansion:
  2 == 2

-------------------------------------------------------------------------------
./succeeding/message
-------------------------------------------------------------------------------
MessageTests.cpp:11
...............................................................................

MessageTests.cpp:14:
warning:
  this is a message
  this is a warning


No assertions in test case, './succeeding/message'

-------------------------------------------------------------------------------
./succeeding/succeed
-------------------------------------------------------------------------------
MessageTests.cpp:16
...............................................................................

MessageTests.cpp:18:
PASSED:
with message:
  this is a success

-------------------------------------------------------------------------------
./failing/message/info/1
-------------------------------------------------------------------------------
MessageTests.cpp:21
...............................................................................

MessageTests.cpp:26: FAILED:
  REQUIRE( a == 1 )
with expansion:
  2 == 1
with messages:
  this message should be logged
  so should this

-------------------------------------------------------------------------------
./mixed/message/info/2
-------------------------------------------------------------------------------
MessageTests.cpp:29
...............................................................................

MessageTests.cpp:33:
PASSED:
  CHECK( a == 2 )
with expansion:
  2 == 2
with message:
  this message should not be logged

MessageTests.cpp:37: FAILED:
  CHECK( a == 1 )
with expansion:
  2 == 1
with message:
  this message should be logged

MessageTests.cpp:41: FAILED:
  CHECK( a == 0 )
with expansion:
  2 == 0
with message:
  and this, but later

MessageTests.cpp:45:
PASSED:
  CHECK( a == 2 )
with expansion:
  2 == 2
with message:
  but not this

-------------------------------------------------------------------------------
./failing/message/fail
-------------------------------------------------------------------------------
MessageTests.cpp:48
...............................................................................

MessageTests.cpp:51: FAILED:
explicitly with message:
  This is a failure

-------------------------------------------------------------------------------
./failing/message/sections
  one
-------------------------------------------------------------------------------
MessageTests.cpp:56
...............................................................................

MessageTests.cpp:58: FAILED:
explicitly with message:
  Message from section one

-------------------------------------------------------------------------------
./failing/message/sections
  two
-------------------------------------------------------------------------------
MessageTests.cpp:61
...............................................................................

MessageTests.cpp:63: FAILED:
explicitly with message:
  Message from section two

Message from section one
-------------------------------------------------------------------------------
./succeeding/message/sections/stdout
  one
-------------------------------------------------------------------------------
MessageTests.cpp:69
...............................................................................


No assertions in section, 'one'

Message from section two
-------------------------------------------------------------------------------
./succeeding/message/sections/stdout
  two
-------------------------------------------------------------------------------
MessageTests.cpp:74
...............................................................................


No assertions in section, 'two'

-------------------------------------------------------------------------------
./mixed/message/scoped
-------------------------------------------------------------------------------
MessageTests.cpp:80
...............................................................................

MessageTests.cpp:86:
PASSED:
  REQUIRE( i < 10 )
with expansion:
  0 < 10
with messages:
  current counter 0
  i := 0

MessageTests.cpp:86:
PASSED:
  REQUIRE( i < 10 )
with expansion:
  1 < 10
with messages:
  current counter 1
  i := 1

MessageTests.cpp:86:
PASSED:
  REQUIRE( i < 10 )
with expansion:
  2 < 10
with messages:
  current counter 2
  i := 2

MessageTests.cpp:86:
PASSED:
  REQUIRE( i < 10 )
with expansion:
  3 < 10
with messages:
  current counter 3
  i := 3

MessageTests.cpp:86:
PASSED:
  REQUIRE( i < 10 )
with expansion:
  4 < 10
with messages:
  current counter 4
  i := 4

MessageTests.cpp:86:
PASSED:
  REQUIRE( i < 10 )
with expansion:
  5 < 10
with messages:
  current counter 5
  i := 5

MessageTests.cpp:86:
PASSED:
  REQUIRE( i < 10 )
with expansion:
  6 < 10
with messages:
  current counter 6
  i := 6

MessageTests.cpp:86:
PASSED:
  REQUIRE( i < 10 )
with expansion:
  7 < 10
with messages:
  current counter 7
  i := 7

MessageTests.cpp:86:
PASSED:
  REQUIRE( i < 10 )
with expansion:
  8 < 10
with messages:
  current counter 8
  i := 8

MessageTests.cpp:86:
PASSED:
  REQUIRE( i < 10 )
with expansion:
  9 < 10
with messages:
  current counter 9
  i := 9

MessageTests.cpp:86: FAILED:
  REQUIRE( i < 10 )
with expansion:
  10 < 10
with messages:
  current counter 10
  i := 10

-------------------------------------------------------------------------------
./succeeding/nofail
-------------------------------------------------------------------------------
MessageTests.cpp:90
...............................................................................

MessageTests.cpp:92:
FAILED - but was ok:
  CHECK_NOFAIL( 1 == 2 )


No assertions in test case, './succeeding/nofail'

-------------------------------------------------------------------------------
just info
-------------------------------------------------------------------------------
MessageTests.cpp:95
...............................................................................


No assertions in test case, 'just info'

-------------------------------------------------------------------------------
just failure
-------------------------------------------------------------------------------
MessageTests.cpp:99
...............................................................................

MessageTests.cpp:101: FAILED:
explicitly with message:
  Previous info should not be seen

-------------------------------------------------------------------------------
./succeeding/Misc/Sections
  s1
-------------------------------------------------------------------------------
MiscTests.cpp:19
...............................................................................

MiscTests.cpp:21:
PASSED:
  REQUIRE( a != b )
with expansion:
  1 != 2

MiscTests.cpp:22:
PASSED:
  REQUIRE( b != a )
with expansion:
  2 != 1

-------------------------------------------------------------------------------
./succeeding/Misc/Sections
  s2
-------------------------------------------------------------------------------
MiscTests.cpp:25
...............................................................................

MiscTests.cpp:27:
PASSED:
  REQUIRE( a != b )
with expansion:
  1 != 2

-------------------------------------------------------------------------------
./succeeding/Misc/Sections/nested
  s1
-------------------------------------------------------------------------------
MiscTests.cpp:36
...............................................................................

MiscTests.cpp:38:
PASSED:
  REQUIRE( a != b )
with expansion:
  1 != 2

MiscTests.cpp:39:
PASSED:
  REQUIRE( b != a )
with expansion:
  2 != 1

-------------------------------------------------------------------------------
./succeeding/Misc/Sections/nested
  s1
  s2
-------------------------------------------------------------------------------
MiscTests.cpp:41
...............................................................................

MiscTests.cpp:43:
PASSED:
  REQUIRE( a != b )
with expansion:
  1 != 2

-------------------------------------------------------------------------------
./mixed/Misc/Sections/nested2
  s1
  s2
-------------------------------------------------------------------------------
MiscTests.cpp:55
...............................................................................

MiscTests.cpp:57: FAILED:
  REQUIRE( a == b )
with expansion:
  1 == 2

-------------------------------------------------------------------------------
./mixed/Misc/Sections/nested2
  s1
  s3
-------------------------------------------------------------------------------
MiscTests.cpp:60
...............................................................................

MiscTests.cpp:62:
PASSED:
  REQUIRE( a != b )
with expansion:
  1 != 2

-------------------------------------------------------------------------------
./mixed/Misc/Sections/nested2
  s1
  s4
-------------------------------------------------------------------------------
MiscTests.cpp:64
...............................................................................

MiscTests.cpp:66:
PASSED:
  REQUIRE( a < b )
with expansion:
  1 < 2

-------------------------------------------------------------------------------
./Sections/nested/a/b
  c
  d (leaf)
-------------------------------------------------------------------------------
MiscTests.cpp:75
...............................................................................


No assertions in section, 'd (leaf)'

-------------------------------------------------------------------------------
./Sections/nested/a/b
  c
  e (leaf)
-------------------------------------------------------------------------------
MiscTests.cpp:79
...............................................................................


No assertions in section, 'e (leaf)'

-------------------------------------------------------------------------------
./Sections/nested/a/b
  f (leaf)
-------------------------------------------------------------------------------
MiscTests.cpp:84
...............................................................................


No assertions in section, 'f (leaf)'

-------------------------------------------------------------------------------
./mixed/Misc/Sections/loops
  s1
-------------------------------------------------------------------------------
MiscTests.cpp:97
...............................................................................

MiscTests.cpp:99: FAILED:
  CHECK( b > a )
with expansion:
  0 > 1

-------------------------------------------------------------------------------
./mixed/Misc/loops
-------------------------------------------------------------------------------
MiscTests.cpp:104
...............................................................................

MiscTests.cpp:111: FAILED:
  CHECK( ( fib[i] % 2 ) == 0 )
with expansion:
  1 == 0
with message:
  Testing if fib[0] (1) is even

MiscTests.cpp:111: FAILED:
  CHECK( ( fib[i] % 2 ) == 0 )
with expansion:
  1 == 0
with message:
  Testing if fib[1] (1) is even

MiscTests.cpp:111:
PASSED:
  CHECK( ( fib[i] % 2 ) == 0 )
with expansion:
  0 == 0
with message:
  Testing if fib[2] (2) is even

MiscTests.cpp:111: FAILED:
  CHECK( ( fib[i] % 2 ) == 0 )
with expansion:
  1 == 0
with message:
  Testing if fib[3] (3) is even

MiscTests.cpp:111: FAILED:
  CHECK( ( fib[i] % 2 ) == 0 )
with expansion:
  1 == 0
with message:
  Testing if fib[4] (5) is even

MiscTests.cpp:111:
PASSED:
  CHECK( ( fib[i] % 2 ) == 0 )
with expansion:
  0 == 0
with message:
  Testing if fib[5] (8) is even

MiscTests.cpp:111: FAILED:
  CHECK( ( fib[i] % 2 ) == 0 )
with expansion:
  1 == 0
with message:
  Testing if fib[6] (13) is even

MiscTests.cpp:111: FAILED:
  CHECK( ( fib[i] % 2 ) == 0 )
with expansion:
  1 == 0
with message:
  Testing if fib[7] (21) is even

Some information
An error
-------------------------------------------------------------------------------
./succeeding/Misc/stdout,stderr
-------------------------------------------------------------------------------
MiscTests.cpp:115
...............................................................................


No assertions in test case, './succeeding/Misc/stdout,stderr'

-------------------------------------------------------------------------------
./succeeding/Misc/null strings
-------------------------------------------------------------------------------
MiscTests.cpp:127
...............................................................................

MiscTests.cpp:129:
PASSED:
  REQUIRE( makeString( false ) != static_cast<char*>(__null) )
with expansion:
  "valid string" != {null string}

MiscTests.cpp:130:
PASSED:
  REQUIRE( makeString( true ) == static_cast<char*>(__null) )
with expansion:
  {null string} == {null string}

-------------------------------------------------------------------------------
./failing/info
-------------------------------------------------------------------------------
MiscTests.cpp:133
...............................................................................

MiscTests.cpp:138: FAILED:
  REQUIRE( false )
with messages:
  hi
  i := 7

-------------------------------------------------------------------------------
./succeeding/checkedif
-------------------------------------------------------------------------------
MiscTests.cpp:149
...............................................................................

MiscTests.cpp:143:
PASSED:
  CHECKED_IF( flag )
with expansion:
  true

MiscTests.cpp:151:
PASSED:
  REQUIRE( testCheckedIf( true ) )
with expansion:
  true

-------------------------------------------------------------------------------
./failing/checkedif
-------------------------------------------------------------------------------
MiscTests.cpp:154
...............................................................................

MiscTests.cpp:143: FAILED:
  CHECKED_IF( flag )
with expansion:
  false

MiscTests.cpp:156: FAILED:
  REQUIRE( testCheckedIf( false ) )
with expansion:
  false

-------------------------------------------------------------------------------
./succeeding/checkedelse
-------------------------------------------------------------------------------
MiscTests.cpp:167
...............................................................................

MiscTests.cpp:161:
PASSED:
  CHECKED_ELSE( flag )
with expansion:
  true

MiscTests.cpp:169:
PASSED:
  REQUIRE( testCheckedElse( true ) )
with expansion:
  true

-------------------------------------------------------------------------------
./failing/checkedelse
-------------------------------------------------------------------------------
MiscTests.cpp:172
...............................................................................

MiscTests.cpp:161: FAILED:
  CHECKED_ELSE( flag )
with expansion:
  false

MiscTests.cpp:174: FAILED:
  REQUIRE( testCheckedElse( false ) )
with expansion:
  false

-------------------------------------------------------------------------------
./misc/xmlentitycheck
  embedded xml
-------------------------------------------------------------------------------
MiscTests.cpp:179
...............................................................................


No assertions in section, 'embedded xml'

-------------------------------------------------------------------------------
./misc/xmlentitycheck
  encoded chars
-------------------------------------------------------------------------------
MiscTests.cpp:183
...............................................................................


No assertions in section, 'encoded chars'

-------------------------------------------------------------------------------
./manual/onechar
-------------------------------------------------------------------------------
MiscTests.cpp:189
...............................................................................

MiscTests.cpp:192: FAILED:
  REQUIRE( false )
with message:
  3

-------------------------------------------------------------------------------
./succeeding/atomic if
-------------------------------------------------------------------------------
MiscTests.cpp:195
...............................................................................

MiscTests.cpp:202:
PASSED:
  REQUIRE( x == 0 )
with expansion:
  0 == 0

-------------------------------------------------------------------------------
./succeeding/matchers
-------------------------------------------------------------------------------
MiscTests.cpp:210
...............................................................................

MiscTests.cpp:212:
PASSED:
  REQUIRE_THAT( testStringForMatching() Contains( "string" ) )
with expansion:
  "this string contains 'abc' as a substring" contains: "string"

MiscTests.cpp:213:
PASSED:
  CHECK_THAT( testStringForMatching() Contains( "abc" ) )
with expansion:
  "this string contains 'abc' as a substring" contains: "abc"

MiscTests.cpp:215:
PASSED:
  CHECK_THAT( testStringForMatching() StartsWith( "this" ) )
with expansion:
  "this string contains 'abc' as a substring" starts with: "this"

MiscTests.cpp:216:
PASSED:
  CHECK_THAT( testStringForMatching() EndsWith( "substring" ) )
with expansion:
  "this string contains 'abc' as a substring" ends with: "substring"

-------------------------------------------------------------------------------
./failing/matchers/Contains
-------------------------------------------------------------------------------
MiscTests.cpp:219
...............................................................................

MiscTests.cpp:221: FAILED:
  CHECK_THAT( testStringForMatching() Contains( "not there" ) )
with expansion:
  "this string contains 'abc' as a substring" contains: "not there"

-------------------------------------------------------------------------------
./failing/matchers/StartsWith
-------------------------------------------------------------------------------
MiscTests.cpp:224
...............................................................................

MiscTests.cpp:226: FAILED:
  CHECK_THAT( testStringForMatching() StartsWith( "string" ) )
with expansion:
  "this string contains 'abc' as a substring" starts with: "string"

-------------------------------------------------------------------------------
./failing/matchers/EndsWith
-------------------------------------------------------------------------------
MiscTests.cpp:229
...............................................................................

MiscTests.cpp:231: FAILED:
  CHECK_THAT( testStringForMatching() EndsWith( "this" ) )
with expansion:
  "this string contains 'abc' as a substring" ends with: "this"

-------------------------------------------------------------------------------
./failing/matchers/Equals
-------------------------------------------------------------------------------
MiscTests.cpp:234
...............................................................................

MiscTests.cpp:236: FAILED:
  CHECK_THAT( testStringForMatching() Equals( "something else" ) )
with expansion:
  "this string contains 'abc' as a substring" equals: "something else"

-------------------------------------------------------------------------------
string
-------------------------------------------------------------------------------
MiscTests.cpp:238
...............................................................................

MiscTests.cpp:240:
PASSED:
  REQUIRE_THAT( "" Equals(__null) )
with expansion:
  "" equals: ""

-------------------------------------------------------------------------------
./succeeding/matchers/AllOf
-------------------------------------------------------------------------------
MiscTests.cpp:242
...............................................................................

MiscTests.cpp:244:
PASSED:
  CHECK_THAT( testStringForMatching() AllOf( Catch::Contains( "string" ), Catch::Contains( "abc" ) ) )
with expansion:
  "this string contains 'abc' as a substring" ( contains: "string" and
  contains: "abc" )

-------------------------------------------------------------------------------
./succeeding/matchers/AnyOf
-------------------------------------------------------------------------------
MiscTests.cpp:246
...............................................................................

MiscTests.cpp:248:
PASSED:
  CHECK_THAT( testStringForMatching() AnyOf( Catch::Contains( "string" ), Catch::Contains( "not there" ) ) )
with expansion:
  "this string contains 'abc' as a substring" ( contains: "string" or contains:
  "not there" )

MiscTests.cpp:249:
PASSED:
  CHECK_THAT( testStringForMatching() AnyOf( Catch::Contains( "not there" ), Catch::Contains( "string" ) ) )
with expansion:
  "this string contains 'abc' as a substring" ( contains: "not there" or
  contains: "string" )

-------------------------------------------------------------------------------
./succeeding/matchers/Equals
-------------------------------------------------------------------------------
MiscTests.cpp:252
...............................................................................

MiscTests.cpp:254:
PASSED:
  CHECK_THAT( testStringForMatching() Equals( "this string contains 'abc' as a substring" ) )
with expansion:
  "this string contains 'abc' as a substring" equals: "this string contains
  'abc' as a substring"

-------------------------------------------------------------------------------
Factorials are computed
-------------------------------------------------------------------------------
MiscTests.cpp:263
...............................................................................

MiscTests.cpp:264:
PASSED:
  REQUIRE( Factorial(0) == 1 )
with expansion:
  1 == 1

MiscTests.cpp:265:
PASSED:
  REQUIRE( Factorial(1) == 1 )
with expansion:
  1 == 1

MiscTests.cpp:266:
PASSED:
  REQUIRE( Factorial(2) == 2 )
with expansion:
  2 == 2

MiscTests.cpp:267:
PASSED:
  REQUIRE( Factorial(3) == 6 )
with expansion:
  6 == 6

MiscTests.cpp:268:
PASSED:
  REQUIRE( Factorial(10) == 3628800 )
with expansion:
  0x<hex digits> == 3628800

-------------------------------------------------------------------------------
empty
-------------------------------------------------------------------------------
MiscTests.cpp:271
...............................................................................


No assertions in test case, 'empty'

-------------------------------------------------------------------------------
Nice descriptive name
-------------------------------------------------------------------------------
MiscTests.cpp:275
...............................................................................

MiscTests.cpp:277:
warning:
  This one ran


No assertions in test case, 'Nice descriptive name'

-------------------------------------------------------------------------------
first tag
-------------------------------------------------------------------------------
MiscTests.cpp:279
...............................................................................


No assertions in test case, 'first tag'

-------------------------------------------------------------------------------
second tag
-------------------------------------------------------------------------------
MiscTests.cpp:282
...............................................................................


No assertions in test case, 'second tag'

-------------------------------------------------------------------------------
vectors can be sized and resized
-------------------------------------------------------------------------------
MiscTests.cpp:295
...............................................................................

MiscTests.cpp:299:
PASSED:
  REQUIRE( v.size() == 5 )
with expansion:
  5 == 5

MiscTests.cpp:300:
PASSED:
  REQUIRE( v.capacity() >= 5 )
with expansion:
  5 >= 5

-------------------------------------------------------------------------------
vectors can be sized and resized
  resizing bigger changes size and capacity
-------------------------------------------------------------------------------
MiscTests.cpp:302
...............................................................................

MiscTests.cpp:305:
PASSED:
  REQUIRE( v.size() == 10 )
with expansion:
  10 == 10

MiscTests.cpp:306:
PASSED:
  REQUIRE( v.capacity() >= 10 )
with expansion:
  10 >= 10

-------------------------------------------------------------------------------
vectors can be sized and resized
-------------------------------------------------------------------------------
MiscTests.cpp:295
...............................................................................

MiscTests.cpp:299:
PASSED:
  REQUIRE( v.size() == 5 )
with expansion:
  5 == 5

MiscTests.cpp:300:
PASSED:
  REQUIRE( v.capacity() >= 5 )
with expansion:
  5 >= 5

-------------------------------------------------------------------------------
vectors can be sized and resized
  resizing smaller changes size but not capacity
-------------------------------------------------------------------------------
MiscTests.cpp:308
...............................................................................

MiscTests.cpp:311:
PASSED:
  REQUIRE( v.size() == 0 )
with expansion:
  0 == 0

MiscTests.cpp:312:
PASSED:
  REQUIRE( v.capacity() >= 5 )
with expansion:
  5 >= 5

-------------------------------------------------------------------------------
vectors can be sized and resized
  resizing smaller changes size but not capacity
  We can use the 'swap trick' to reset the capacity
-------------------------------------------------------------------------------
MiscTests.cpp:314
...............................................................................

MiscTests.cpp:318:
PASSED:
  REQUIRE( v.capacity() == 0 )
with expansion:
  0 == 0

-------------------------------------------------------------------------------
vectors can be sized and resized
-------------------------------------------------------------------------------
MiscTests.cpp:295
...............................................................................

MiscTests.cpp:299:
PASSED:
  REQUIRE( v.size() == 5 )
with expansion:
  5 == 5

MiscTests.cpp:300:
PASSED:
  REQUIRE( v.capacity() >= 5 )
with expansion:
  5 >= 5

-------------------------------------------------------------------------------
vectors can be sized and resized
  resizing smaller changes size but not capacity
-------------------------------------------------------------------------------
MiscTests.cpp:308
...............................................................................

MiscTests.cpp:311:
PASSED:
  REQUIRE( v.size() == 0 )
with expansion:
  0 == 0

MiscTests.cpp:312:
PASSED:
  REQUIRE( v.capacity() >= 5 )
with expansion:
  5 >= 5

-------------------------------------------------------------------------------
vectors can be sized and resized
-------------------------------------------------------------------------------
MiscTests.cpp:295
...............................................................................

MiscTests.cpp:299:
PASSED:
  REQUIRE( v.size() == 5 )
with expansion:
  5 == 5

MiscTests.cpp:300:
PASSED:
  REQUIRE( v.capacity() >= 5 )
with expansion:
  5 >= 5

-------------------------------------------------------------------------------
vectors can be sized and resized
  reserving bigger changes capacity but not size
-------------------------------------------------------------------------------
MiscTests.cpp:321
...............................................................................

MiscTests.cpp:324:
PASSED:
  REQUIRE( v.size() == 5 )
with expansion:
  5 == 5

MiscTests.cpp:325:
PASSED:
  REQUIRE( v.capacity() >= 10 )
with expansion:
  10 >= 10

-------------------------------------------------------------------------------
vectors can be sized and resized
-------------------------------------------------------------------------------
MiscTests.cpp:295
...............................................................................

MiscTests.cpp:299:
PASSED:
  REQUIRE( v.size() == 5 )
with expansion:
  5 == 5

MiscTests.cpp:300:
PASSED:
  REQUIRE( v.capacity() >= 5 )
with expansion:
  5 >= 5

-------------------------------------------------------------------------------
vectors can be sized and resized
  reserving smaller does not change size or capacity
-------------------------------------------------------------------------------
MiscTests.cpp:327
...............................................................................

MiscTests.cpp:330:
PASSED:
  REQUIRE( v.size() == 5 )
with expansion:
  5 == 5

MiscTests.cpp:331:
PASSED:
  REQUIRE( v.capacity() >= 5 )
with expansion:
  5 >= 5

-------------------------------------------------------------------------------
selftest/main
  selftest/expected result
  selftest/expected result/failing tests
-------------------------------------------------------------------------------
TestMain.cpp:23
...............................................................................

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

catch_self_test.hpp:120:
PASSED:
with message:
  Tests failed, as expected

-------------------------------------------------------------------------------
selftest/main
  selftest/expected result
  selftest/expected result/succeeding tests
-------------------------------------------------------------------------------
TestMain.cpp:28
...............................................................................

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

Message from section one
Message from section two
catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

Some information
An error
catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

catch_self_test.hpp:109:
PASSED:
with message:
  Tests passed, as expected

Message from section one
Message from section two
Some information
An error
-------------------------------------------------------------------------------
selftest/main
  selftest/test counts
  selftest/test counts/succeeding tests
-------------------------------------------------------------------------------
TestMain.cpp:39
...............................................................................

TestMain.cpp:41:
PASSED:
  CHECK( totals.assertions.passed == 296 )
with expansion:
  296 == 296

TestMain.cpp:42:
PASSED:
  CHECK( totals.assertions.failed == 0 )
with expansion:
  0 == 0

-------------------------------------------------------------------------------
selftest/main
  selftest/test counts
  selftest/test counts/failing tests
-------------------------------------------------------------------------------
TestMain.cpp:46
...............................................................................

TestMain.cpp:48:
PASSED:
  CHECK( totals.assertions.passed == 1 )
with expansion:
  1 == 1

TestMain.cpp:49:
PASSED:
  CHECK( totals.assertions.failed == 74 )
with expansion:
  74 == 74

-------------------------------------------------------------------------------
meta/Misc/Sections
-------------------------------------------------------------------------------
TestMain.cpp:54
...............................................................................

TestMain.cpp:58:
PASSED:
  CHECK( totals.assertions.passed == 2 )
with expansion:
  2 == 2

TestMain.cpp:59:
PASSED:
  CHECK( totals.assertions.failed == 1 )
with expansion:
  1 == 1

-------------------------------------------------------------------------------
Process can be configured on command line
  default - no arguments
-------------------------------------------------------------------------------
TestMain.cpp:96
...............................................................................

TestMain.cpp:98:
PASSED:
  CHECK_NOTHROW( parseIntoConfig( argv, config ) )

TestMain.cpp:100:
PASSED:
  CHECK( config.shouldDebugBreak == false )
with expansion:
  false == false

TestMain.cpp:101:
PASSED:
  CHECK( config.abortAfter == -1 )
with expansion:
  -1 == -1

TestMain.cpp:102:
PASSED:
  CHECK( config.noThrow == false )
with expansion:
  false == false

TestMain.cpp:103:
PASSED:
  CHECK( config.reporterName.empty() )
with expansion:
  true

-------------------------------------------------------------------------------
Process can be configured on command line
  test lists
  1 test
-------------------------------------------------------------------------------
TestMain.cpp:107
...............................................................................

TestMain.cpp:109:
PASSED:
  CHECK_NOTHROW( parseIntoConfig( argv, config ) )

TestMain.cpp:112:
PASSED:
  REQUIRE( cfg.filters().size() == 1 )
with expansion:
  1 == 1

TestMain.cpp:113:
PASSED:
  REQUIRE( cfg.filters()[0].shouldInclude( fakeTestCase( "notIncluded" ) ) == false )
with expansion:
  false == false

TestMain.cpp:114:
PASSED:
  REQUIRE( cfg.filters()[0].shouldInclude( fakeTestCase( "test1" ) ) )
with expansion:
  true

-------------------------------------------------------------------------------
Process can be configured on command line
  test lists
  Specify one test case exclusion using exclude:
-------------------------------------------------------------------------------
TestMain.cpp:116
...............................................................................

TestMain.cpp:118:
PASSED:
  CHECK_NOTHROW( parseIntoConfig( argv, config ) )

TestMain.cpp:121:
PASSED:
  REQUIRE( cfg.filters().size() == 1 )
with expansion:
  1 == 1

TestMain.cpp:122:
PASSED:
  REQUIRE( cfg.filters()[0].shouldInclude( fakeTestCase( "test1" ) ) == false )
with expansion:
  false == false

TestMain.cpp:123:
PASSED:
  REQUIRE( cfg.filters()[0].shouldInclude( fakeTestCase( "alwaysIncluded" ) ) )
with expansion:
  true

-------------------------------------------------------------------------------
Process can be configured on command line
  test lists
  Specify one test case exclusion using ~
-------------------------------------------------------------------------------
TestMain.cpp:126
...............................................................................

TestMain.cpp:128:
PASSED:
  CHECK_NOTHROW( parseIntoConfig( argv, config ) )

TestMain.cpp:131:
PASSED:
  REQUIRE( cfg.filters().size() == 1 )
with expansion:
  1 == 1

TestMain.cpp:132:
PASSED:
  REQUIRE( cfg.filters()[0].shouldInclude( fakeTestCase( "test1" ) ) == false )
with expansion:
  false == false

TestMain.cpp:133:
PASSED:
  REQUIRE( cfg.filters()[0].shouldInclude( fakeTestCase( "alwaysIncluded" ) ) )
with expansion:
  true

-------------------------------------------------------------------------------
Process can be configured on command line
  test lists
  Specify two test cases using -t
-------------------------------------------------------------------------------
TestMain.cpp:136
...............................................................................

TestMain.cpp:138:
PASSED:
  CHECK_NOTHROW( parseIntoConfig( argv, config ) )

TestMain.cpp:141:
PASSED:
  REQUIRE( cfg.filters().size() == 1 )
with expansion:
  1 == 1

TestMain.cpp:142:
PASSED:
  REQUIRE( cfg.filters()[0].shouldInclude( fakeTestCase( "notIncluded" ) ) == false )
with expansion:
  false == false

TestMain.cpp:143:
PASSED:
  REQUIRE( cfg.filters()[0].shouldInclude( fakeTestCase( "test1" ) ) )
with expansion:
  true

TestMain.cpp:144:
PASSED:
  REQUIRE( cfg.filters()[0].shouldInclude( fakeTestCase( "test2" ) ) )
with expansion:
  true

-------------------------------------------------------------------------------
Process can be configured on command line
  reporter
  -r/console
-------------------------------------------------------------------------------
TestMain.cpp:149
...............................................................................

TestMain.cpp:151:
PASSED:
  CHECK_NOTHROW( parseIntoConfig( argv, config ) )

TestMain.cpp:153:
PASSED:
  REQUIRE( config.reporterName == "console" )
with expansion:
  "console" == "console"

-------------------------------------------------------------------------------
Process can be configured on command line
  reporter
  -r/xml
-------------------------------------------------------------------------------
TestMain.cpp:155
...............................................................................

TestMain.cpp:157:
PASSED:
  CHECK_NOTHROW( parseIntoConfig( argv, config ) )

TestMain.cpp:159:
PASSED:
  REQUIRE( config.reporterName == "xml" )
with expansion:
  "xml" == "xml"

-------------------------------------------------------------------------------
Process can be configured on command line
  reporter
  --reporter/junit
-------------------------------------------------------------------------------
TestMain.cpp:161
...............................................................................

TestMain.cpp:163:
PASSED:
  CHECK_NOTHROW( parseIntoConfig( argv, config ) )

TestMain.cpp:165:
PASSED:
  REQUIRE( config.reporterName == "junit" )
with expansion:
  "junit" == "junit"

-------------------------------------------------------------------------------
Process can be configured on command line
  debugger
  -b
-------------------------------------------------------------------------------
TestMain.cpp:170
...............................................................................

TestMain.cpp:172:
PASSED:
  CHECK_NOTHROW( parseIntoConfig( argv, config ) )

TestMain.cpp:174:
PASSED:
  REQUIRE( config.shouldDebugBreak == true )
with expansion:
  true == true

-------------------------------------------------------------------------------
Process can be configured on command line
  debugger
  --break
-------------------------------------------------------------------------------
TestMain.cpp:176
...............................................................................

TestMain.cpp:178:
PASSED:
  CHECK_NOTHROW( parseIntoConfig( argv, config ) )

TestMain.cpp:180:
PASSED:
  REQUIRE( config.shouldDebugBreak )
with expansion:
  true

-------------------------------------------------------------------------------
Process can be configured on command line
  abort
  -a aborts after first failure
-------------------------------------------------------------------------------
TestMain.cpp:185
...............................................................................

TestMain.cpp:187:
PASSED:
  CHECK_NOTHROW( parseIntoConfig( argv, config ) )

TestMain.cpp:189:
PASSED:
  REQUIRE( config.abortAfter == 1 )
with expansion:
  1 == 1

-------------------------------------------------------------------------------
Process can be configured on command line
  abort
  -x 2 aborts after two failures
-------------------------------------------------------------------------------
TestMain.cpp:191
...............................................................................

TestMain.cpp:193:
PASSED:
  CHECK_NOTHROW( parseIntoConfig( argv, config ) )

TestMain.cpp:195:
PASSED:
  REQUIRE( config.abortAfter == 2 )
with expansion:
  2 == 2

-------------------------------------------------------------------------------
Process can be configured on command line
  abort
  -x must be greater than zero
-------------------------------------------------------------------------------
TestMain.cpp:197
...............................................................................

TestMain.cpp:199:
PASSED:
  REQUIRE_THAT( parseIntoConfigAndReturnError( argv, config ) Contains( "greater than zero" ) )
with expansion:
  "Value after -x or --abortAfter must be greater than zero while parsing: (-x,
  --abortx <number of failures>)" contains: "greater than zero"

-------------------------------------------------------------------------------
Process can be configured on command line
  abort
  -x must be numeric
-------------------------------------------------------------------------------
TestMain.cpp:201
...............................................................................

TestMain.cpp:203:
PASSED:
  REQUIRE_THAT( parseIntoConfigAndReturnError( argv, config ) Contains( "-x" ) )
with expansion:
  "Unable to convert oops to destination type while parsing: (-x, --abortx
  <number of failures>)" contains: "-x"

-------------------------------------------------------------------------------
Process can be configured on command line
  nothrow
  -e
-------------------------------------------------------------------------------
TestMain.cpp:208
...............................................................................

TestMain.cpp:210:
PASSED:
  CHECK_NOTHROW( parseIntoConfig( argv, config ) )

TestMain.cpp:212:
PASSED:
  REQUIRE( config.noThrow == true )
with expansion:
  true == true

-------------------------------------------------------------------------------
Process can be configured on command line
  nothrow
  --nothrow
-------------------------------------------------------------------------------
TestMain.cpp:214
...............................................................................

TestMain.cpp:216:
PASSED:
  CHECK_NOTHROW( parseIntoConfig( argv, config ) )

TestMain.cpp:218:
PASSED:
  REQUIRE( config.noThrow == true )
with expansion:
  true == true

-------------------------------------------------------------------------------
Process can be configured on command line
  output filename
  -o filename
-------------------------------------------------------------------------------
TestMain.cpp:223
...............................................................................

TestMain.cpp:225:
PASSED:
  CHECK_NOTHROW( parseIntoConfig( argv, config ) )

TestMain.cpp:227:
PASSED:
  REQUIRE( config.outputFilename == "filename.ext" )
with expansion:
  "filename.ext" == "filename.ext"

-------------------------------------------------------------------------------
Process can be configured on command line
  output filename
  --out
-------------------------------------------------------------------------------
TestMain.cpp:229
...............................................................................

TestMain.cpp:231:
PASSED:
  CHECK_NOTHROW( parseIntoConfig( argv, config ) )

TestMain.cpp:233:
PASSED:
  REQUIRE( config.outputFilename == "filename.ext" )
with expansion:
  "filename.ext" == "filename.ext"

-------------------------------------------------------------------------------
Process can be configured on command line
  combinations
  Single character flags can be combined
-------------------------------------------------------------------------------
TestMain.cpp:238
...............................................................................

TestMain.cpp:240:
PASSED:
  CHECK_NOTHROW( parseIntoConfig( argv, config ) )

TestMain.cpp:242:
PASSED:
  CHECK( config.abortAfter == 1 )
with expansion:
  1 == 1

TestMain.cpp:243:
PASSED:
  CHECK( config.shouldDebugBreak )
with expansion:
  true

TestMain.cpp:244:
PASSED:
  CHECK( config.noThrow == true )
with expansion:
  true == true

-------------------------------------------------------------------------------
selftest/test filter
-------------------------------------------------------------------------------
TestMain.cpp:249
...............................................................................

TestMain.cpp:253:
PASSED:
  CHECK( matchAny.shouldInclude( fakeTestCase( "any" ) ) )
with expansion:
  true

TestMain.cpp:254:
PASSED:
  CHECK( matchNone.shouldInclude( fakeTestCase( "any" ) ) == false )
with expansion:
  false == false

TestMain.cpp:259:
PASSED:
  CHECK( matchHidden.shouldInclude( fakeTestCase( "any" ) ) == false )
with expansion:
  false == false

TestMain.cpp:260:
PASSED:
  CHECK( matchNonHidden.shouldInclude( fakeTestCase( "any" ) ) )
with expansion:
  true

TestMain.cpp:262:
PASSED:
  CHECK( matchHidden.shouldInclude( fakeTestCase( "./any" ) ) )
with expansion:
  true

TestMain.cpp:263:
PASSED:
  CHECK( matchNonHidden.shouldInclude( fakeTestCase( "./any" ) ) == false )
with expansion:
  false == false

-------------------------------------------------------------------------------
selftest/test filters
-------------------------------------------------------------------------------
TestMain.cpp:266
...............................................................................

TestMain.cpp:274:
PASSED:
  CHECK( matchHidden.shouldInclude( fakeTestCase( "./something" ) ) )
with expansion:
  true

TestMain.cpp:276:
PASSED:
  CHECK( filters.shouldInclude( fakeTestCase( "any" ) ) == false )
with expansion:
  false == false

TestMain.cpp:277:
PASSED:
  CHECK( filters.shouldInclude( fakeTestCase( "./something" ) ) )
with expansion:
  true

TestMain.cpp:278:
PASSED:
  CHECK( filters.shouldInclude( fakeTestCase( "./anything" ) ) == false )
with expansion:
  false == false

-------------------------------------------------------------------------------
selftest/filter/prefix wildcard
-------------------------------------------------------------------------------
TestMain.cpp:281
...............................................................................

TestMain.cpp:284:
PASSED:
  CHECK( matchBadgers.shouldInclude( fakeTestCase( "big badger" ) ) )
with expansion:
  true

TestMain.cpp:285:
PASSED:
  CHECK( matchBadgers.shouldInclude( fakeTestCase( "little badgers" ) ) == false )
with expansion:
  false == false

-------------------------------------------------------------------------------
selftest/filter/wildcard at both ends
-------------------------------------------------------------------------------
TestMain.cpp:287
...............................................................................

TestMain.cpp:290:
PASSED:
  CHECK( matchBadgers.shouldInclude( fakeTestCase( "big badger" ) ) )
with expansion:
  true

TestMain.cpp:291:
PASSED:
  CHECK( matchBadgers.shouldInclude( fakeTestCase( "little badgers" ) ) )
with expansion:
  true

TestMain.cpp:292:
PASSED:
  CHECK( matchBadgers.shouldInclude( fakeTestCase( "badgers are big" ) ) )
with expansion:
  true

TestMain.cpp:293:
PASSED:
  CHECK( matchBadgers.shouldInclude( fakeTestCase( "hedgehogs" ) ) == false )
with expansion:
  false == false

-------------------------------------------------------------------------------
selftest/tags
  one tag
-------------------------------------------------------------------------------
TestMain.cpp:310
...............................................................................

TestMain.cpp:313:
PASSED:
  CHECK( oneTag.getTestCaseInfo().description == "" )
with expansion:
  "" == ""

TestMain.cpp:314:
PASSED:
  CHECK( oneTag.hasTag( "one" ) )
with expansion:
  true

TestMain.cpp:315:
PASSED:
  CHECK( oneTag.getTags().size() == 1 )
with expansion:
  1 == 1

TestMain.cpp:317:
PASSED:
  CHECK( oneTag.matchesTags( p1 ) == true )
with expansion:
  true == true

TestMain.cpp:318:
PASSED:
  CHECK( oneTag.matchesTags( p2 ) == true )
with expansion:
  true == true

TestMain.cpp:319:
PASSED:
  CHECK( oneTag.matchesTags( p3 ) == false )
with expansion:
  false == false

TestMain.cpp:320:
PASSED:
  CHECK( oneTag.matchesTags( p4 ) == false )
with expansion:
  false == false

TestMain.cpp:321:
PASSED:
  CHECK( oneTag.matchesTags( p5 ) == false )
with expansion:
  false == false

-------------------------------------------------------------------------------
selftest/tags
  two tags
-------------------------------------------------------------------------------
TestMain.cpp:324
...............................................................................

TestMain.cpp:327:
PASSED:
  CHECK( twoTags.getTestCaseInfo().description == "" )
with expansion:
  "" == ""

TestMain.cpp:328:
PASSED:
  CHECK( twoTags.hasTag( "one" ) )
with expansion:
  true

TestMain.cpp:329:
PASSED:
  CHECK( twoTags.hasTag( "two" ) )
with expansion:
  true

TestMain.cpp:330:
PASSED:
  CHECK( twoTags.hasTag( "Two" ) )
with expansion:
  true

TestMain.cpp:331:
PASSED:
  CHECK( twoTags.hasTag( "three" ) == false )
with expansion:
  false == false

TestMain.cpp:332:
PASSED:
  CHECK( twoTags.getTags().size() == 2 )
with expansion:
  2 == 2

TestMain.cpp:334:
PASSED:
  CHECK( twoTags.matchesTags( p1 ) == true )
with expansion:
  true == true

TestMain.cpp:335:
PASSED:
  CHECK( twoTags.matchesTags( p2 ) == true )
with expansion:
  true == true

TestMain.cpp:336:
PASSED:
  CHECK( twoTags.matchesTags( p3 ) == true )
with expansion:
  true == true

TestMain.cpp:337:
PASSED:
  CHECK( twoTags.matchesTags( p4 ) == true )
with expansion:
  true == true

TestMain.cpp:338:
PASSED:
  CHECK( twoTags.matchesTags( p5 ) == true )
with expansion:
  true == true

-------------------------------------------------------------------------------
selftest/tags
  one tag with characters either side
-------------------------------------------------------------------------------
TestMain.cpp:341
...............................................................................

TestMain.cpp:344:
PASSED:
  CHECK( oneTagWithExtras.getTestCaseInfo().description == "1234" )
with expansion:
  "1234" == "1234"

TestMain.cpp:345:
PASSED:
  CHECK( oneTagWithExtras.hasTag( "one" ) )
with expansion:
  true

TestMain.cpp:346:
PASSED:
  CHECK( oneTagWithExtras.hasTag( "two" ) == false )
with expansion:
  false == false

TestMain.cpp:347:
PASSED:
  CHECK( oneTagWithExtras.getTags().size() == 1 )
with expansion:
  1 == 1

-------------------------------------------------------------------------------
selftest/tags
  start of a tag, but not closed
-------------------------------------------------------------------------------
TestMain.cpp:350
...............................................................................

TestMain.cpp:354:
PASSED:
  CHECK( oneTagOpen.getTestCaseInfo().description == "[one" )
with expansion:
  "[one" == "[one"

TestMain.cpp:355:
PASSED:
  CHECK( oneTagOpen.hasTag( "one" ) == false )
with expansion:
  false == false

TestMain.cpp:356:
PASSED:
  CHECK( oneTagOpen.getTags().size() == 0 )
with expansion:
  0 == 0

-------------------------------------------------------------------------------
selftest/tags
  hidden
-------------------------------------------------------------------------------
TestMain.cpp:359
...............................................................................

TestMain.cpp:362:
PASSED:
  CHECK( oneTag.getTestCaseInfo().description == "" )
with expansion:
  "" == ""

TestMain.cpp:363:
PASSED:
  CHECK( oneTag.hasTag( "hide" ) )
with expansion:
  true

TestMain.cpp:364:
PASSED:
  CHECK( oneTag.isHidden() )
with expansion:
  true

TestMain.cpp:366:
PASSED:
  CHECK( oneTag.matchesTags( "~[hide]" ) == false )
with expansion:
  false == false

-------------------------------------------------------------------------------
Long strings can be wrapped
  plain string
  No wrapping
-------------------------------------------------------------------------------
TestMain.cpp:378
...............................................................................

TestMain.cpp:379:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 80 ) ).toString() == testString )
with expansion:
  "one two three four"
  ==
  "one two three four"

TestMain.cpp:380:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 18 ) ).toString() == testString )
with expansion:
  "one two three four"
  ==
  "one two three four"

-------------------------------------------------------------------------------
Long strings can be wrapped
  plain string
  Wrapped once
-------------------------------------------------------------------------------
TestMain.cpp:382
...............................................................................

TestMain.cpp:383:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 17 ) ).toString() == "one two three\nfour" )
with expansion:
  "one two three
  four"
  ==
  "one two three
  four"

TestMain.cpp:384:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 16 ) ).toString() == "one two three\nfour" )
with expansion:
  "one two three
  four"
  ==
  "one two three
  four"

TestMain.cpp:385:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 14 ) ).toString() == "one two three\nfour" )
with expansion:
  "one two three
  four"
  ==
  "one two three
  four"

TestMain.cpp:386:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 13 ) ).toString() == "one two three\nfour" )
with expansion:
  "one two three
  four"
  ==
  "one two three
  four"

TestMain.cpp:387:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 12 ) ).toString() == "one two\nthree four" )
with expansion:
  "one two
  three four"
  ==
  "one two
  three four"

-------------------------------------------------------------------------------
Long strings can be wrapped
  plain string
  Wrapped twice
-------------------------------------------------------------------------------
TestMain.cpp:389
...............................................................................

TestMain.cpp:390:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 9 ) ).toString() == "one two\nthree\nfour" )
with expansion:
  "one two
  three
  four"
  ==
  "one two
  three
  four"

TestMain.cpp:391:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 8 ) ).toString() == "one two\nthree\nfour" )
with expansion:
  "one two
  three
  four"
  ==
  "one two
  three
  four"

TestMain.cpp:392:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 7 ) ).toString() == "one two\nthree\nfour" )
with expansion:
  "one two
  three
  four"
  ==
  "one two
  three
  four"

-------------------------------------------------------------------------------
Long strings can be wrapped
  plain string
  Wrapped three times
-------------------------------------------------------------------------------
TestMain.cpp:394
...............................................................................

TestMain.cpp:395:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 6 ) ).toString() == "one\ntwo\nthree\nfour" )
with expansion:
  "one
  two
  three
  four"
  ==
  "one
  two
  three
  four"

TestMain.cpp:396:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 5 ) ).toString() == "one\ntwo\nthree\nfour" )
with expansion:
  "one
  two
  three
  four"
  ==
  "one
  two
  three
  four"

-------------------------------------------------------------------------------
Long strings can be wrapped
  plain string
  Short wrap
-------------------------------------------------------------------------------
TestMain.cpp:398
...............................................................................

TestMain.cpp:399:
PASSED:
  CHECK( Text( "abcdef", TextAttributes().setWidth( 4 ) ).toString() == "abc-\ndef" )
with expansion:
  "abc-
  def"
  ==
  "abc-
  def"

TestMain.cpp:400:
PASSED:
  CHECK( Text( "abcdefg", TextAttributes().setWidth( 4 ) ).toString() == "abc-\ndefg" )
with expansion:
  "abc-
  defg"
  ==
  "abc-
  defg"

TestMain.cpp:401:
PASSED:
  CHECK( Text( "abcdefgh", TextAttributes().setWidth( 4 ) ).toString() == "abc-\ndef-\ngh" )
with expansion:
  "abc-
  def-
  gh"
  ==
  "abc-
  def-
  gh"

TestMain.cpp:403:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 4 ) ).toString() == "one\ntwo\nthr-\nee\nfour" )
with expansion:
  "one
  two
  thr-
  ee
  four"
  ==
  "one
  two
  thr-
  ee
  four"

TestMain.cpp:404:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 3 ) ).toString() == "one\ntwo\nth-\nree\nfo-\nur" )
with expansion:
  "one
  two
  th-
  ree
  fo-
  ur"
  ==
  "one
  two
  th-
  ree
  fo-
  ur"

-------------------------------------------------------------------------------
Long strings can be wrapped
  plain string
  As container
-------------------------------------------------------------------------------
TestMain.cpp:406
...............................................................................

TestMain.cpp:408:
PASSED:
  REQUIRE( text.size() == 4 )
with expansion:
  4 == 4

TestMain.cpp:409:
PASSED:
  CHECK( text[0] == "one" )
with expansion:
  "one" == "one"

TestMain.cpp:410:
PASSED:
  CHECK( text[1] == "two" )
with expansion:
  "two" == "two"

TestMain.cpp:411:
PASSED:
  CHECK( text[2] == "three" )
with expansion:
  "three" == "three"

TestMain.cpp:412:
PASSED:
  CHECK( text[3] == "four" )
with expansion:
  "four" == "four"

-------------------------------------------------------------------------------
Long strings can be wrapped
  plain string
  Indent first line differently
-------------------------------------------------------------------------------
TestMain.cpp:414
...............................................................................

TestMain.cpp:419:
PASSED:
  CHECK( text.toString() == " one two\n    three\n    four" )
with expansion:
  " one two
      three
      four"
  ==
  " one two
      three
      four"

-------------------------------------------------------------------------------
Long strings can be wrapped
  With newlines
  No wrapping
-------------------------------------------------------------------------------
TestMain.cpp:429
...............................................................................

TestMain.cpp:430:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 80 ) ).toString() == testString )
with expansion:
  "one two
  three four"
  ==
  "one two
  three four"

TestMain.cpp:431:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 18 ) ).toString() == testString )
with expansion:
  "one two
  three four"
  ==
  "one two
  three four"

TestMain.cpp:432:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 10 ) ).toString() == testString )
with expansion:
  "one two
  three four"
  ==
  "one two
  three four"

-------------------------------------------------------------------------------
Long strings can be wrapped
  With newlines
  Trailing newline
-------------------------------------------------------------------------------
TestMain.cpp:434
...............................................................................

TestMain.cpp:435:
PASSED:
  CHECK( Text( "abcdef\n", TextAttributes().setWidth( 10 ) ).toString() == "abcdef\n" )
with expansion:
  "abcdef
  "
  ==
  "abcdef
  "

TestMain.cpp:436:
PASSED:
  CHECK( Text( "abcdef", TextAttributes().setWidth( 6 ) ).toString() == "abcdef" )
with expansion:
  "abcdef" == "abcdef"

TestMain.cpp:437:
PASSED:
  CHECK( Text( "abcdef\n", TextAttributes().setWidth( 6 ) ).toString() == "abcdef\n" )
with expansion:
  "abcdef
  "
  ==
  "abcdef
  "

-------------------------------------------------------------------------------
Long strings can be wrapped
  With newlines
  Wrapped once
-------------------------------------------------------------------------------
TestMain.cpp:439
...............................................................................

TestMain.cpp:440:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 9 ) ).toString() == "one two\nthree\nfour" )
with expansion:
  "one two
  three
  four"
  ==
  "one two
  three
  four"

TestMain.cpp:441:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 8 ) ).toString() == "one two\nthree\nfour" )
with expansion:
  "one two
  three
  four"
  ==
  "one two
  three
  four"

TestMain.cpp:442:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 7 ) ).toString() == "one two\nthree\nfour" )
with expansion:
  "one two
  three
  four"
  ==
  "one two
  three
  four"

-------------------------------------------------------------------------------
Long strings can be wrapped
  With newlines
  Wrapped twice
-------------------------------------------------------------------------------
TestMain.cpp:444
...............................................................................

TestMain.cpp:445:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 6 ) ).toString() == "one\ntwo\nthree\nfour" )
with expansion:
  "one
  two
  three
  four"
  ==
  "one
  two
  three
  four"

-------------------------------------------------------------------------------
Long strings can be wrapped
  With tabs
-------------------------------------------------------------------------------
TestMain.cpp:449
...............................................................................

TestMain.cpp:455:
PASSED:
  CHECK( Text( testString, TextAttributes().setWidth( 15 ) ).toString() == "one two three\n        four\n        five\n        six" )
with expansion:
  "one two three
          four
          five
          six"
  ==
  "one two three
          four
          five
          six"

hello
hello
-------------------------------------------------------------------------------
Strings can be rendered with colour
-------------------------------------------------------------------------------
TestMain.cpp:534
...............................................................................


No assertions in test case, 'Strings can be rendered with colour'

-------------------------------------------------------------------------------
Text can be formatted using the Text class
-------------------------------------------------------------------------------
TestMain.cpp:553
...............................................................................

TestMain.cpp:555:
PASSED:
  CHECK( Text( "hi there" ).toString() == "hi there" )
with expansion:
  "hi there" == "hi there"

TestMain.cpp:560:
PASSED:
  CHECK( Text( "hi there", narrow ).toString() == "hi\nthere" )
with expansion:
  "hi
  there"
  ==
  "hi
  there"

-------------------------------------------------------------------------------
./succeeding/Tricky/std::pair
-------------------------------------------------------------------------------
TrickyTests.cpp:32
...............................................................................

TrickyTests.cpp:37:
PASSED:
  REQUIRE( (std::pair<int, int>( 1, 2 )) == aNicePair )
with expansion:
  std::pair( 1, 2 ) == std::pair( 1, 2 )

-------------------------------------------------------------------------------
./inprogress/failing/Tricky/trailing expression
-------------------------------------------------------------------------------
TrickyTests.cpp:46
...............................................................................

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'

-------------------------------------------------------------------------------
./inprogress/failing/Tricky/compound lhs
-------------------------------------------------------------------------------
TrickyTests.cpp:62
...............................................................................

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'

-------------------------------------------------------------------------------
./failing/Tricky/non streamable type
-------------------------------------------------------------------------------
TrickyTests.cpp:88
...............................................................................

TrickyTests.cpp:95: FAILED:
  CHECK( &o1 == &o2 )
with expansion:
  0x<hex digits> == 0x<hex digits>

TrickyTests.cpp:96: FAILED:
  CHECK( o1 == o2 )
with expansion:
  {?} == {?}

-------------------------------------------------------------------------------
./failing/string literals
-------------------------------------------------------------------------------
TrickyTests.cpp:104
...............................................................................

TrickyTests.cpp:106: FAILED:
  REQUIRE( std::string( "first" ) == "second" )
with expansion:
  "first" == "second"

-------------------------------------------------------------------------------
./succeeding/side-effects
-------------------------------------------------------------------------------
TrickyTests.cpp:115
...............................................................................

TrickyTests.cpp:119:
PASSED:
  REQUIRE( i++ == 7 )
with expansion:
  7 == 7

TrickyTests.cpp:120:
PASSED:
  REQUIRE( i++ == 8 )
with expansion:
  8 == 8

-------------------------------------------------------------------------------
./succeeding/koenig
-------------------------------------------------------------------------------
TrickyTests.cpp:183
...............................................................................

TrickyTests.cpp:186:
PASSED:
  REQUIRE( 0x<hex digits> == o )
with expansion:
  0x<hex digits> == {?}

-------------------------------------------------------------------------------
./succeeding/non-const==
-------------------------------------------------------------------------------
TrickyTests.cpp:209
...............................................................................

TrickyTests.cpp:212:
PASSED:
  REQUIRE( t == 1u )
with expansion:
  {?} == 1

-------------------------------------------------------------------------------
./succeeding/enum/bits
-------------------------------------------------------------------------------
TrickyTests.cpp:222
...............................................................................

TrickyTests.cpp:224:
PASSED:
  REQUIRE( 0x<hex digits> == bit30and31 )
with expansion:
  0x<hex digits> == 3221225472

-------------------------------------------------------------------------------
./succeeding/boolean member
-------------------------------------------------------------------------------
TrickyTests.cpp:236
...............................................................................

TrickyTests.cpp:239:
PASSED:
  REQUIRE( obj.prop != __null )
with expansion:
  0x<hex digits> != 0

-------------------------------------------------------------------------------
./succeeding/unimplemented static bool
  compare to true
-------------------------------------------------------------------------------
TrickyTests.cpp:257
...............................................................................

TrickyTests.cpp:259:
PASSED:
  REQUIRE( is_true<true>::value == true )
with expansion:
  true == true

TrickyTests.cpp:260:
PASSED:
  REQUIRE( true == is_true<true>::value )
with expansion:
  true == true

-------------------------------------------------------------------------------
./succeeding/unimplemented static bool
  compare to false
-------------------------------------------------------------------------------
TrickyTests.cpp:262
...............................................................................

TrickyTests.cpp:264:
PASSED:
  REQUIRE( is_true<false>::value == false )
with expansion:
  false == false

TrickyTests.cpp:265:
PASSED:
  REQUIRE( false == is_true<false>::value )
with expansion:
  false == false

-------------------------------------------------------------------------------
./succeeding/unimplemented static bool
  negation
-------------------------------------------------------------------------------
TrickyTests.cpp:268
...............................................................................

TrickyTests.cpp:270:
PASSED:
  REQUIRE( !is_true<false>::value )
with expansion:
  true

-------------------------------------------------------------------------------
./succeeding/unimplemented static bool
  double negation
-------------------------------------------------------------------------------
TrickyTests.cpp:273
...............................................................................

TrickyTests.cpp:275:
PASSED:
  REQUIRE( !!is_true<true>::value )
with expansion:
  true

-------------------------------------------------------------------------------
./succeeding/unimplemented static bool
  direct
-------------------------------------------------------------------------------
TrickyTests.cpp:278
...............................................................................

TrickyTests.cpp:280:
PASSED:
  REQUIRE( is_true<true>::value )
with expansion:
  true

TrickyTests.cpp:281:
PASSED:
  REQUIRE_FALSE( is_true<false>::value )
with expansion:
  !false

-------------------------------------------------------------------------------
./succeeding/SafeBool
-------------------------------------------------------------------------------
TrickyTests.cpp:308
...............................................................................

TrickyTests.cpp:313:
PASSED:
  CHECK( True )
with expansion:
  true

TrickyTests.cpp:314:
PASSED:
  CHECK( !False )
with expansion:
  true

TrickyTests.cpp:315:
PASSED:
  CHECK_FALSE( False )
with expansion:
  !false

-------------------------------------------------------------------------------
Assertions then sections
-------------------------------------------------------------------------------
TrickyTests.cpp:318
...............................................................................

TrickyTests.cpp:323:
PASSED:
  REQUIRE( Catch::isTrue( true ) )
with expansion:
  true

-------------------------------------------------------------------------------
Assertions then sections
  A section
-------------------------------------------------------------------------------
TrickyTests.cpp:325
...............................................................................

TrickyTests.cpp:327:
PASSED:
  REQUIRE( Catch::isTrue( true ) )
with expansion:
  true

-------------------------------------------------------------------------------
Assertions then sections
  A section
  Another section
-------------------------------------------------------------------------------
TrickyTests.cpp:329
...............................................................................

TrickyTests.cpp:331:
PASSED:
  REQUIRE( Catch::isTrue( true ) )
with expansion:
  true

-------------------------------------------------------------------------------
Assertions then sections
-------------------------------------------------------------------------------
TrickyTests.cpp:318
...............................................................................

TrickyTests.cpp:323:
PASSED:
  REQUIRE( Catch::isTrue( true ) )
with expansion:
  true

-------------------------------------------------------------------------------
Assertions then sections
  A section
-------------------------------------------------------------------------------
TrickyTests.cpp:325
...............................................................................

TrickyTests.cpp:327:
PASSED:
  REQUIRE( Catch::isTrue( true ) )
with expansion:
  true

-------------------------------------------------------------------------------
Assertions then sections
  A section
  Another other section
-------------------------------------------------------------------------------
TrickyTests.cpp:333
...............................................................................

TrickyTests.cpp:335:
PASSED:
  REQUIRE( Catch::isTrue( true ) )
with expansion:
  true

-------------------------------------------------------------------------------
non streamable - with conv. op
-------------------------------------------------------------------------------
TrickyTests.cpp:345
...............................................................................

TrickyTests.cpp:349:
PASSED:
  REQUIRE( s == "7" )
with expansion:
  "7" == "7"

-------------------------------------------------------------------------------
Anonymous test case 1
-------------------------------------------------------------------------------
VariadicMacrosTests.cpp:13
...............................................................................

VariadicMacrosTests.cpp:15:
PASSED:
with message:
  anonymous test case

-------------------------------------------------------------------------------
Test case with one argument
-------------------------------------------------------------------------------
VariadicMacrosTests.cpp:18
...............................................................................

VariadicMacrosTests.cpp:20:
PASSED:
with message:
  no assertions

-------------------------------------------------------------------------------
Variadic macros
  Section with one argument
-------------------------------------------------------------------------------
VariadicMacrosTests.cpp:25
...............................................................................

VariadicMacrosTests.cpp:27:
PASSED:
with message:
  no assertions

-------------------------------------------------------------------------------
Scenario: Do that thing with the thing
     Given: This stuff exists
      When: I do this
      Then: it should do this
-------------------------------------------------------------------------------
BDDTests.cpp:19
...............................................................................

BDDTests.cpp:21:
PASSED:
  REQUIRE( itDoesThis() )
with expansion:
  true

-------------------------------------------------------------------------------
Scenario: Do that thing with the thing
     Given: This stuff exists
      When: I do this
      Then: it should do this
       And: do that
-------------------------------------------------------------------------------
BDDTests.cpp:22
...............................................................................

BDDTests.cpp:23:
PASSED:
  REQUIRE( itDoesThat() )
with expansion:
  true

-------------------------------------------------------------------------------
Scenario: Vector resizing affects size and capacity
     Given: an empty vector
-------------------------------------------------------------------------------
BDDTests.cpp:30
...............................................................................

BDDTests.cpp:32:
PASSED:
  REQUIRE( v.size() == 0 )
with expansion:
  0 == 0

-------------------------------------------------------------------------------
Scenario: Vector resizing affects size and capacity
     Given: an empty vector
      When: it is made larger
      Then: the size and capacity go up
-------------------------------------------------------------------------------
BDDTests.cpp:36
...............................................................................

BDDTests.cpp:37:
PASSED:
  REQUIRE( v.size() == 10 )
with expansion:
  10 == 10

BDDTests.cpp:38:
PASSED:
  REQUIRE( v.capacity() >= 10 )
with expansion:
  10 >= 10

-------------------------------------------------------------------------------
Scenario: Vector resizing affects size and capacity
     Given: an empty vector
      When: it is made larger
      Then: the size and capacity go up
  And when: it is made smaller again
      Then: the size goes down but the capacity stays the same
-------------------------------------------------------------------------------
BDDTests.cpp:42
...............................................................................

BDDTests.cpp:43:
PASSED:
  REQUIRE( v.size() == 5 )
with expansion:
  5 == 5

BDDTests.cpp:44:
PASSED:
  REQUIRE( v.capacity() >= 10 )
with expansion:
  10 >= 10

-------------------------------------------------------------------------------
Scenario: Vector resizing affects size and capacity
     Given: an empty vector
-------------------------------------------------------------------------------
BDDTests.cpp:30
...............................................................................

BDDTests.cpp:32:
PASSED:
  REQUIRE( v.size() == 0 )
with expansion:
  0 == 0

-------------------------------------------------------------------------------
Scenario: Vector resizing affects size and capacity
     Given: an empty vector
      When: it is made larger
      Then: the size and capacity go up
-------------------------------------------------------------------------------
BDDTests.cpp:36
...............................................................................

BDDTests.cpp:37:
PASSED:
  REQUIRE( v.size() == 10 )
with expansion:
  10 == 10

BDDTests.cpp:38:
PASSED:
  REQUIRE( v.capacity() >= 10 )
with expansion:
  10 >= 10

-------------------------------------------------------------------------------
Scenario: Vector resizing affects size and capacity
     Given: an empty vector
-------------------------------------------------------------------------------
BDDTests.cpp:30
...............................................................................

BDDTests.cpp:32:
PASSED:
  REQUIRE( v.size() == 0 )
with expansion:
  0 == 0

-------------------------------------------------------------------------------
Scenario: Vector resizing affects size and capacity
     Given: an empty vector
      When: it is made larger
      Then: the size and capacity go up
-------------------------------------------------------------------------------
BDDTests.cpp:36
...............................................................................

BDDTests.cpp:37:
PASSED:
  REQUIRE( v.size() == 10 )
with expansion:
  10 == 10

BDDTests.cpp:38:
PASSED:
  REQUIRE( v.capacity() >= 10 )
with expansion:
  10 >= 10

-------------------------------------------------------------------------------
Scenario: Vector resizing affects size and capacity
     Given: an empty vector
-------------------------------------------------------------------------------
BDDTests.cpp:30
...............................................................................

BDDTests.cpp:32:
PASSED:
  REQUIRE( v.size() == 0 )
with expansion:
  0 == 0

-------------------------------------------------------------------------------
Scenario: Vector resizing affects size and capacity
     Given: an empty vector
-------------------------------------------------------------------------------
BDDTests.cpp:30
...............................................................................

BDDTests.cpp:32:
PASSED:
  REQUIRE( v.size() == 0 )
with expansion:
  0 == 0

-------------------------------------------------------------------------------
Scenario: Vector resizing affects size and capacity
     Given: an empty vector
      When: we reserve more space
      Then: The capacity is increased but the size remains the same
-------------------------------------------------------------------------------
BDDTests.cpp:52
...............................................................................

BDDTests.cpp:53:
PASSED:
  REQUIRE( v.capacity() >= 10 )
with expansion:
  10 >= 10

BDDTests.cpp:54:
PASSED:
  REQUIRE( v.size() == 0 )
with expansion:
  0 == 0

-------------------------------------------------------------------------------
Scenario: This is a really long scenario name to see how the list command deals
          with wrapping
     Given: A section name that is so long that it cannot fit in a single
            console width
      When: The test headers are printed as part of the normal running of the
            scenario
      Then: The, deliberately very long and overly verbose (you see what I did
            there?) section names must wrap, along with an indent
-------------------------------------------------------------------------------
BDDTests.cpp:66
...............................................................................

BDDTests.cpp:67:
PASSED:
with message:
  boo!

-------------------------------------------------------------------------------
cmdline
  process name
-------------------------------------------------------------------------------
CmdLineTests.cpp:60
...............................................................................

CmdLineTests.cpp:64:
PASSED:
  CHECK( config.processName == "test" )
with expansion:
  "test" == "test"

-------------------------------------------------------------------------------
cmdline
  arg separated by spaces
-------------------------------------------------------------------------------
CmdLineTests.cpp:66
...............................................................................

CmdLineTests.cpp:70:
PASSED:
  CHECK( config.fileName == "filename.ext" )
with expansion:
  "filename.ext" == "filename.ext"

-------------------------------------------------------------------------------
cmdline
  arg separated by colon
-------------------------------------------------------------------------------
CmdLineTests.cpp:72
...............................................................................

CmdLineTests.cpp:76:
PASSED:
  CHECK( config.fileName == "filename.ext" )
with expansion:
  "filename.ext" == "filename.ext"

-------------------------------------------------------------------------------
cmdline
  arg separated by =
-------------------------------------------------------------------------------
CmdLineTests.cpp:78
...............................................................................

CmdLineTests.cpp:82:
PASSED:
  CHECK( config.fileName == "filename.ext" )
with expansion:
  "filename.ext" == "filename.ext"

-------------------------------------------------------------------------------
cmdline
  long opt
-------------------------------------------------------------------------------
CmdLineTests.cpp:84
...............................................................................

CmdLineTests.cpp:88:
PASSED:
  CHECK( config.fileName == "%stdout" )
with expansion:
  "%stdout" == "%stdout"

-------------------------------------------------------------------------------
cmdline
  a number
-------------------------------------------------------------------------------
CmdLineTests.cpp:95
...............................................................................

CmdLineTests.cpp:99:
PASSED:
  CHECK( config.number == 42 )
with expansion:
  42 == 42

-------------------------------------------------------------------------------
cmdline
  not a number
-------------------------------------------------------------------------------
CmdLineTests.cpp:101
...............................................................................

CmdLineTests.cpp:103:
PASSED:
  CHECK_THROWS( parseInto( cli, argv, config ) )

CmdLineTests.cpp:105:
PASSED:
  CHECK( config.number == 0 )
with expansion:
  0 == 0

-------------------------------------------------------------------------------
cmdline
  two parsers
-------------------------------------------------------------------------------
CmdLineTests.cpp:108
...............................................................................

CmdLineTests.cpp:123:
PASSED:
  CHECK( config1.number == 42 )
with expansion:
  42 == 42

CmdLineTests.cpp:125:
PASSED:
  REQUIRE_FALSE( unusedTokens.empty() )
with expansion:
  !false

CmdLineTests.cpp:127:
PASSED:
  CHECK( config2.description == "some text" )
with expansion:
  "some text" == "some text"

-------------------------------------------------------------------------------
cmdline
  methods
  in range
-------------------------------------------------------------------------------
CmdLineTests.cpp:136
...............................................................................

CmdLineTests.cpp:140:
PASSED:
  REQUIRE( config.index == 3 )
with expansion:
  3 == 3

-------------------------------------------------------------------------------
cmdline
  methods
  out of range
-------------------------------------------------------------------------------
CmdLineTests.cpp:142
...............................................................................

CmdLineTests.cpp:145:
PASSED:
  REQUIRE_THROWS( parseInto( cli, argv, config ) )

-------------------------------------------------------------------------------
cmdline
  flags
  set
-------------------------------------------------------------------------------
CmdLineTests.cpp:154
...............................................................................

CmdLineTests.cpp:158:
PASSED:
  REQUIRE( config.flag )
with expansion:
  true

-------------------------------------------------------------------------------
cmdline
  flags
  not set
-------------------------------------------------------------------------------
CmdLineTests.cpp:160
...............................................................................

CmdLineTests.cpp:164:
PASSED:
  REQUIRE( config.flag == false )
with expansion:
  false == false

-------------------------------------------------------------------------------
cmdline
  positional
-------------------------------------------------------------------------------
CmdLineTests.cpp:167
...............................................................................

CmdLineTests.cpp:185:
PASSED:
  REQUIRE( config.firstPos == "1st" )
with expansion:
  "1st" == "1st"

CmdLineTests.cpp:186:
PASSED:
  REQUIRE( config.secondPos == "2nd" )
with expansion:
  "2nd" == "2nd"

CmdLineTests.cpp:187:
PASSED:
  REQUIRE( config.unpositional == "3rd" )
with expansion:
  "3rd" == "3rd"

===============================================================================
113 test cases - 49 failed (705 assertions - 106 failed)

No test cases matched '~dummy 4'
No tests ran

<testsuites>
  <testsuite name="~dummy" errors="10" failures="78" tests="705" 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="global" name="Approximate PI" 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.1415926535 == 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.1415926535 != 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.199999999999999" 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:337
      </failure>
      <failure message="true != true" type="CHECK">
ConditionTests.cpp:338
      </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="!true" type="CHECK_FALSE">
ConditionTests.cpp:343
      </failure>
      <failure message="false" type="CHECK">
ConditionTests.cpp:345
      </failure>
      <failure message="!(1 == 1)" type="CHECK_FALSE">
ConditionTests.cpp:346
      </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:40
      </error>
      <failure message="thisDoesntThrow()" type="CHECK_THROWS_AS">
ExceptionTests.cpp:41
      </failure>
      <error message="thisThrows()" type="CHECK_NOTHROW">
ExceptionTests.cpp:42
      </error>
    </testcase>
    <testcase classname="global" name="./failing/exceptions/implicit" time="tbd">
      <error type="TEST_CASE">
ExceptionTests.cpp:45
      </error>
    </testcase>
    <testcase classname="global" name="./failing/exceptions/implicit/2" time="tbd">
      <error message="{Unknown expression after the reported line}">
ExceptionTests.cpp:53
      </error>
    </testcase>
    <testcase classname="global" name="./failing/exceptions/implicit/3" time="tbd">
      <error type="TEST_CASE">
ExceptionTests.cpp:59
      </error>
    </testcase>
    <testcase classname="global" name="./failing/exceptions/implicit/4" time="tbd">
      <error message="thisThrows() == 0" type="CHECK">
ExceptionTests.cpp:68
      </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:108
      </error>
    </testcase>
    <testcase classname="global" name="./failing/exceptions/custom/nothrow" time="tbd">
      <error message="throwCustom()" type="REQUIRE_NOTHROW">
ExceptionTests.cpp:121
      </error>
    </testcase>
    <testcase classname="global" name="./failing/exceptions/custom/throw" time="tbd">
      <error message="throwCustom()" type="REQUIRE_THROWS_AS">
ExceptionTests.cpp:126
      </error>
    </testcase>
    <testcase classname="global" name="./failing/exceptions/custom/double" time="tbd">
      <error type="TEST_CASE">
ExceptionTests.cpp:130
      </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/generators/2" time="tbd"/>
    <testcase classname="global" name="./succeeding/message" time="tbd">
      <info type="INFO">
MessageTests.cpp:13
      </info>
      <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: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 type="SCOPED_INFO">
MessageTests.cpp:84
      </info>
      <info type="SCOPED_CAPTURE">
MessageTests.cpp:85
      </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="just info" time="tbd"/>
    <testcase classname="global" name="just failure" time="tbd">
      <failure type="FAIL">
MessageTests.cpp:101
      </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:57
      </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:99
      </failure>
    </testcase>
    <testcase classname="global" name="./mixed/Misc/loops" time="tbd">
      <info type="INFO">
MiscTests.cpp:110
      </info>
      <failure message="1 == 0" type="CHECK">
MiscTests.cpp:111
      </failure>
      <info type="INFO">
MiscTests.cpp:110
      </info>
      <failure message="1 == 0" type="CHECK">
MiscTests.cpp:111
      </failure>
      <info type="INFO">
MiscTests.cpp:110
      </info>
      <failure message="1 == 0" type="CHECK">
MiscTests.cpp:111
      </failure>
      <info type="INFO">
MiscTests.cpp:110
      </info>
      <failure message="1 == 0" type="CHECK">
MiscTests.cpp:111
      </failure>
      <info type="INFO">
MiscTests.cpp:110
      </info>
      <failure message="1 == 0" type="CHECK">
MiscTests.cpp:111
      </failure>
      <info type="INFO">
MiscTests.cpp:110
      </info>
      <failure message="1 == 0" type="CHECK">
MiscTests.cpp:111
      </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:135
      </info>
      <info type="CAPTURE">
MiscTests.cpp:137
      </info>
      <failure message="false" type="REQUIRE">
MiscTests.cpp:138
      </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:143
      </failure>
      <failure message="false" type="REQUIRE">
MiscTests.cpp:156
      </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:161
      </failure>
      <failure message="false" type="REQUIRE">
MiscTests.cpp:174
      </failure>
    </testcase>
    <testcase classname="global" name="./misc/xmlentitycheck" time="tbd"/>
    <testcase classname="global" name="./manual/onechar" time="tbd">
      <info type="INFO">
MiscTests.cpp:191
      </info>
      <failure message="false" type="REQUIRE">
MiscTests.cpp:192
      </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:221
      </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:226
      </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:231
      </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:236
      </failure>
    </testcase>
    <testcase classname="global" name="string" time="tbd"/>
    <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="Factorials are computed" time="tbd"/>
    <testcase classname="global" name="empty" time="tbd"/>
    <testcase classname="global" name="Nice descriptive name" time="tbd">
      <warning type="WARN">
MiscTests.cpp:277
      </warning>
    </testcase>
    <testcase classname="global" name="first tag" time="tbd"/>
    <testcase classname="global" name="second tag" time="tbd"/>
    <testcase classname="global" name="vectors can be sized and resized" 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="Process can be configured on command line" 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/tags" time="tbd"/>
    <testcase classname="global" name="Long strings can be wrapped" time="tbd"/>
    <testcase classname="global" name="Strings can be rendered with colour" time="tbd">
      <system-out>
hello
hello
      </system-out>
    </testcase>
    <testcase classname="global" name="Text can be formatted using the Text class" 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="Assertions then sections" time="tbd"/>
    <testcase classname="global" name="non streamable - with conv. op" time="tbd"/>
    <testcase classname="global" name="Anonymous test case 1" time="tbd"/>
    <testcase classname="global" name="Test case with one argument" time="tbd"/>
    <testcase classname="global" name="Variadic macros" time="tbd"/>
    <testcase classname="global" name="Scenario: Do that thing with the thing" time="tbd"/>
    <testcase classname="global" name="Scenario: Vector resizing affects size and capacity" time="tbd"/>
    <testcase classname="global" name="Scenario: This is a really long scenario name to see how the list command deals with wrapping" time="tbd"/>
    <testcase classname="global" name="cmdline" 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

hello
hello
  </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="Approximate PI">
ApproxTests.cpp" line="110">
        <Original>
          divide( 22, 7 ) == Approx( 3.141 ).epsilon( 0.001 )
        </Original>
        <Expanded>
          3.142857142857143 == Approx( 3.141 )
        </Expanded>
      </Expression>
ApproxTests.cpp" line="111">
        <Original>
          divide( 22, 7 ) != Approx( 3.141 ).epsilon( 0.0001 )
        </Original>
        <Expanded>
          3.142857142857143 != Approx( 3.141 )
        </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.1415926535 == 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.1415926535 == 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.1415926535 != 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.1415926535 != 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.199999999999999
        </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.199999999999999
        </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 == 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 == 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="226">
        <Original>
          long_var == unsigned_char_var
        </Original>
        <Expanded>
          1 == 1
        </Expanded>
      </Expression>
ConditionTests.cpp" line="227">
        <Original>
          long_var == unsigned_short_var
        </Original>
        <Expanded>
          1 == 1
        </Expanded>
      </Expression>
ConditionTests.cpp" line="228">
        <Original>
          long_var == unsigned_int_var
        </Original>
        <Expanded>
          1 == 1
        </Expanded>
      </Expression>
ConditionTests.cpp" line="229">
        <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="240">
        <Original>
          unsigned_char_var == 1
        </Original>
        <Expanded>
          1 == 1
        </Expanded>
      </Expression>
ConditionTests.cpp" line="241">
        <Original>
          unsigned_short_var == 1
        </Original>
        <Expanded>
          1 == 1
        </Expanded>
      </Expression>
ConditionTests.cpp" line="242">
        <Original>
          unsigned_int_var == 1
        </Original>
        <Expanded>
          1 == 1
        </Expanded>
      </Expression>
ConditionTests.cpp" line="243">
        <Original>
          unsigned_long_var == 1
        </Original>
        <Expanded>
          1 == 1
        </Expanded>
      </Expression>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="./succeeding/conditions/negative ints">
ConditionTests.cpp" line="249">
        <Original>
          ( -1 > 2u )
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
ConditionTests.cpp" line="250">
        <Original>
          -1 > 2u
        </Original>
        <Expanded>
          -1 > 2
        </Expanded>
      </Expression>
ConditionTests.cpp" line="252">
        <Original>
          ( 2u &lt; -1 )
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
ConditionTests.cpp" line="253">
        <Original>
          2u &lt; -1
        </Original>
        <Expanded>
          2 &lt; -1
        </Expanded>
      </Expression>
ConditionTests.cpp" line="256">
        <Original>
          ( minInt > 2u )
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
ConditionTests.cpp" line="257">
        <Original>
          minInt > 2u
        </Original>
        <Expanded>
          -2147483648 > 2
        </Expanded>
      </Expression>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="./succeeding/conditions/computed ints">
ConditionTests.cpp" line="272">
        <Original>
          54 == 6*9
        </Original>
        <Expanded>
          54 == 54
        </Expanded>
      </Expression>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="./succeeding/conditions/ptr">
ConditionTests.cpp" line="288">
        <Original>
          p == __null
        </Original>
        <Expanded>
          __null == 0
        </Expanded>
      </Expression>
ConditionTests.cpp" line="289">
        <Original>
          p == pNULL
        </Original>
        <Expanded>
          __null == __null
        </Expanded>
      </Expression>
ConditionTests.cpp" line="294">
        <Original>
          p != __null
        </Original>
        <Expanded>
          0x<hex digits> != 0
        </Expanded>
      </Expression>
ConditionTests.cpp" line="297">
        <Original>
          cp != __null
        </Original>
        <Expanded>
          0x<hex digits> != 0
        </Expanded>
      </Expression>
ConditionTests.cpp" line="300">
        <Original>
          cpc != __null
        </Original>
        <Expanded>
          0x<hex digits> != 0
        </Expanded>
      </Expression>
ConditionTests.cpp" line="302">
        <Original>
          returnsNull() == __null
        </Original>
        <Expanded>
          {null string} == 0
        </Expanded>
      </Expression>
ConditionTests.cpp" line="303">
        <Original>
          returnsConstNull() == __null
        </Original>
        <Expanded>
          {null string} == 0
        </Expanded>
      </Expression>
ConditionTests.cpp" line="305">
        <Original>
          __null != p
        </Original>
        <Expanded>
          0 != 0x<hex digits>
        </Expanded>
      </Expression>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="./succeeding/conditions/not">
ConditionTests.cpp" line="320">
        <Original>
          false == false
        </Original>
        <Expanded>
          false == false
        </Expanded>
      </Expression>
ConditionTests.cpp" line="321">
        <Original>
          true == true
        </Original>
        <Expanded>
          true == true
        </Expanded>
      </Expression>
ConditionTests.cpp" line="322">
        <Original>
          !false
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
ConditionTests.cpp" line="323">
        <Original>
          !false
        </Original>
        <Expanded>
          !false
        </Expanded>
      </Expression>
ConditionTests.cpp" line="325">
        <Original>
          !falseValue
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
ConditionTests.cpp" line="326">
        <Original>
          !falseValue
        </Original>
        <Expanded>
          !false
        </Expanded>
      </Expression>
ConditionTests.cpp" line="328">
        <Original>
          !(1 == 2)
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
ConditionTests.cpp" line="329">
        <Original>
          !1 == 2
        </Original>
        <Expanded>
          !(1 == 2)
        </Expanded>
      </Expression>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="./failing/conditions/not">
ConditionTests.cpp" line="337">
        <Original>
          false != false
        </Original>
        <Expanded>
          false != false
        </Expanded>
      </Expression>
ConditionTests.cpp" line="338">
        <Original>
          true != true
        </Original>
        <Expanded>
          true != true
        </Expanded>
      </Expression>
ConditionTests.cpp" line="339">
        <Original>
          !true
        </Original>
        <Expanded>
          false
        </Expanded>
      </Expression>
ConditionTests.cpp" line="340">
        <Original>
          !true
        </Original>
        <Expanded>
          !true
        </Expanded>
      </Expression>
ConditionTests.cpp" line="342">
        <Original>
          !trueValue
        </Original>
        <Expanded>
          false
        </Expanded>
      </Expression>
ConditionTests.cpp" line="343">
        <Original>
          !trueValue
        </Original>
        <Expanded>
          !true
        </Expanded>
      </Expression>
ConditionTests.cpp" line="345">
        <Original>
          !(1 == 1)
        </Original>
        <Expanded>
          false
        </Expanded>
      </Expression>
ConditionTests.cpp" line="346">
        <Original>
          !1 == 1
        </Original>
        <Expanded>
          !(1 == 1)
        </Expanded>
      </Expression>
      <OverallResult success="false"/>
    </TestCase>
    <TestCase name="./succeeding/exceptions/explicit">
ExceptionTests.cpp" line="33">
        <Original>
          thisThrows()
        </Original>
        <Expanded>
          thisThrows()
        </Expanded>
      </Expression>
ExceptionTests.cpp" line="34">
        <Original>
          thisDoesntThrow()
        </Original>
        <Expanded>
          thisDoesntThrow()
        </Expanded>
      </Expression>
ExceptionTests.cpp" line="35">
        <Original>
          thisThrows()
        </Original>
        <Expanded>
          thisThrows()
        </Expanded>
      </Expression>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="./failing/exceptions/explicit">
ExceptionTests.cpp" line="40">
        <Original>
          thisThrows()
        </Original>
        <Expanded>
          thisThrows()
        </Expanded>
ExceptionTests.cpp" line="40">
          expected exception
        </Exception>
      </Expression>
ExceptionTests.cpp" line="41">
        <Original>
          thisDoesntThrow()
        </Original>
        <Expanded>
          thisDoesntThrow()
        </Expanded>
      </Expression>
ExceptionTests.cpp" line="42">
        <Original>
          thisThrows()
        </Original>
        <Expanded>
          thisThrows()
        </Expanded>
ExceptionTests.cpp" line="42">
          expected exception
        </Exception>
      </Expression>
      <OverallResult success="false"/>
    </TestCase>
    <TestCase name="./failing/exceptions/implicit">
ExceptionTests.cpp" line="45">
        unexpected exception
      </Exception>
      <OverallResult success="false"/>
    </TestCase>
    <TestCase name="./failing/exceptions/implicit/2">
ExceptionTests.cpp" line="53">
        <Original>
          1 == 1
        </Original>
        <Expanded>
          1 == 1
        </Expanded>
      </Expression>
ExceptionTests.cpp" line="53">
        <Original>
          {Unknown expression after the reported line}
        </Original>
        <Expanded>
          {Unknown expression after the reported line}
        </Expanded>
ExceptionTests.cpp" line="53">
          unexpected exception
        </Exception>
      </Expression>
      <OverallResult success="false"/>
    </TestCase>
    <TestCase name="./failing/exceptions/implicit/3">
      <Section name="section name">
ExceptionTests.cpp" line="59">
          unexpected exception
        </Exception>
        <OverallResults successes="0" failures="1"/>
      </Section>
      <OverallResult success="false"/>
    </TestCase>
    <TestCase name="./failing/exceptions/implicit/4">
ExceptionTests.cpp" line="68">
        <Original>
          thisThrows() == 0
        </Original>
        <Expanded>
          thisThrows() == 0
        </Expanded>
ExceptionTests.cpp" line="68">
          expected exception
        </Exception>
      </Expression>
      <OverallResult success="false"/>
    </TestCase>
    <TestCase name="./succeeding/exceptions/implicit">
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="./failing/exceptions/custom">
ExceptionTests.cpp" line="108">
        custom exception
      </Exception>
      <OverallResult success="false"/>
    </TestCase>
    <TestCase name="./failing/exceptions/custom/nothrow">
ExceptionTests.cpp" line="121">
        <Original>
          throwCustom()
        </Original>
        <Expanded>
          throwCustom()
        </Expanded>
ExceptionTests.cpp" line="121">
          custom exception - not std
        </Exception>
      </Expression>
      <OverallResult success="false"/>
    </TestCase>
    <TestCase name="./failing/exceptions/custom/throw">
ExceptionTests.cpp" line="126">
        <Original>
          throwCustom()
        </Original>
        <Expanded>
          throwCustom()
        </Expanded>
ExceptionTests.cpp" line="126">
          custom exception - not std
        </Exception>
      </Expression>
      <OverallResult success="false"/>
    </TestCase>
    <TestCase name="./failing/exceptions/custom/double">
ExceptionTests.cpp" line="130">
        3.14
      </Exception>
      <OverallResult success="false"/>
    </TestCase>
    <TestCase name="./succeeding/exceptions/notimplemented">
ExceptionTests.cpp" line="142">
        <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/generators/2">
GeneratorTests.cpp" line="40">
        <Original>
          i->first == i->second-1
        </Original>
        <Expanded>
          0 == 0
        </Expanded>
      </Expression>
GeneratorTests.cpp" line="40">
        <Original>
          i->first == i->second-1
        </Original>
        <Expanded>
          2 == 2
        </Expanded>
      </Expression>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="./succeeding/message">
      <Info>
        this is a message
      </Info>
      <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>
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>
      <Info>
        current counter 10
      </Info>
      <Info>
        i := 10
      </Info>
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="just info">
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="just failure">
      <Failure>
        Previous info should not be seen
      </Failure>
      <OverallResult success="false"/>
    </TestCase>
    <TestCase name="./succeeding/Misc/Sections">
      <Section name="s1" description="doesn't equal">
MiscTests.cpp" line="21">
          <Original>
            a != b
          </Original>
          <Expanded>
            1 != 2
          </Expanded>
        </Expression>
MiscTests.cpp" line="22">
          <Original>
            b != a
          </Original>
          <Expanded>
            2 != 1
          </Expanded>
        </Expression>
        <OverallResults successes="2" failures="0"/>
      </Section>
      <Section name="s2" description="not equal">
MiscTests.cpp" line="27">
          <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="38">
          <Original>
            a != b
          </Original>
          <Expanded>
            1 != 2
          </Expanded>
        </Expression>
MiscTests.cpp" line="39">
          <Original>
            b != a
          </Original>
          <Expanded>
            2 != 1
          </Expanded>
        </Expression>
        <Section name="s2" description="not equal">
MiscTests.cpp" line="43">
            <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="57">
            <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="62">
            <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="66">
            <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="99">
          <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="111">
        <Original>
          ( fib[i] % 2 ) == 0
        </Original>
        <Expanded>
          1 == 0
        </Expanded>
      </Expression>
      <Info>
        Testing if fib[1] (1) is even
      </Info>
MiscTests.cpp" line="111">
        <Original>
          ( fib[i] % 2 ) == 0
        </Original>
        <Expanded>
          1 == 0
        </Expanded>
      </Expression>
MiscTests.cpp" line="111">
        <Original>
          ( fib[i] % 2 ) == 0
        </Original>
        <Expanded>
          0 == 0
        </Expanded>
      </Expression>
      <Info>
        Testing if fib[3] (3) is even
      </Info>
MiscTests.cpp" line="111">
        <Original>
          ( fib[i] % 2 ) == 0
        </Original>
        <Expanded>
          1 == 0
        </Expanded>
      </Expression>
      <Info>
        Testing if fib[4] (5) is even
      </Info>
MiscTests.cpp" line="111">
        <Original>
          ( fib[i] % 2 ) == 0
        </Original>
        <Expanded>
          1 == 0
        </Expanded>
      </Expression>
MiscTests.cpp" line="111">
        <Original>
          ( fib[i] % 2 ) == 0
        </Original>
        <Expanded>
          0 == 0
        </Expanded>
      </Expression>
      <Info>
        Testing if fib[6] (13) is even
      </Info>
MiscTests.cpp" line="111">
        <Original>
          ( fib[i] % 2 ) == 0
        </Original>
        <Expanded>
          1 == 0
        </Expanded>
      </Expression>
      <Info>
        Testing if fib[7] (21) is even
      </Info>
MiscTests.cpp" line="111">
        <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="129">
        <Original>
          makeString( false ) != static_cast&lt;char*>(__null)
        </Original>
        <Expanded>
          &quot;valid string&quot; != {null string}
        </Expanded>
      </Expression>
MiscTests.cpp" line="130">
        <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="138">
        <Original>
          false
        </Original>
        <Expanded>
          false
        </Expanded>
      </Expression>
      <OverallResult success="false"/>
    </TestCase>
    <TestCase name="./succeeding/checkedif">
MiscTests.cpp" line="143">
        <Original>
          flag
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
MiscTests.cpp" line="151">
        <Original>
          testCheckedIf( true )
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="./failing/checkedif">
MiscTests.cpp" line="143">
        <Original>
          flag
        </Original>
        <Expanded>
          false
        </Expanded>
      </Expression>
MiscTests.cpp" line="156">
        <Original>
          testCheckedIf( false )
        </Original>
        <Expanded>
          false
        </Expanded>
      </Expression>
      <OverallResult success="false"/>
    </TestCase>
    <TestCase name="./succeeding/checkedelse">
MiscTests.cpp" line="161">
        <Original>
          flag
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
MiscTests.cpp" line="169">
        <Original>
          testCheckedElse( true )
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="./failing/checkedelse">
MiscTests.cpp" line="161">
        <Original>
          flag
        </Original>
        <Expanded>
          false
        </Expanded>
      </Expression>
MiscTests.cpp" line="174">
        <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="192">
        <Original>
          false
        </Original>
        <Expanded>
          false
        </Expanded>
      </Expression>
      <OverallResult success="false"/>
    </TestCase>
    <TestCase name="./succeeding/atomic if">
MiscTests.cpp" line="202">
        <Original>
          x == 0
        </Original>
        <Expanded>
          0 == 0
        </Expanded>
      </Expression>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="./succeeding/matchers">
MiscTests.cpp" line="212">
        <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="213">
        <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="215">
        <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="216">
        <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="221">
        <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="226">
        <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="231">
        <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="236">
        <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="string">
MiscTests.cpp" line="240">
        <Original>
          &quot;&quot; Equals(__null)
        </Original>
        <Expanded>
          &quot;&quot; equals: &quot;&quot;
        </Expanded>
      </Expression>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="./succeeding/matchers/AllOf">
MiscTests.cpp" line="244">
        <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="248">
        <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="249">
        <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="254">
        <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="Factorials are computed">
MiscTests.cpp" line="264">
        <Original>
          Factorial(0) == 1
        </Original>
        <Expanded>
          1 == 1
        </Expanded>
      </Expression>
MiscTests.cpp" line="265">
        <Original>
          Factorial(1) == 1
        </Original>
        <Expanded>
          1 == 1
        </Expanded>
      </Expression>
MiscTests.cpp" line="266">
        <Original>
          Factorial(2) == 2
        </Original>
        <Expanded>
          2 == 2
        </Expanded>
      </Expression>
MiscTests.cpp" line="267">
        <Original>
          Factorial(3) == 6
        </Original>
        <Expanded>
          6 == 6
        </Expanded>
      </Expression>
MiscTests.cpp" line="268">
        <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="vectors can be sized and resized">
MiscTests.cpp" line="299">
        <Original>
          v.size() == 5
        </Original>
        <Expanded>
          5 == 5
        </Expanded>
      </Expression>
MiscTests.cpp" line="300">
        <Original>
          v.capacity() >= 5
        </Original>
        <Expanded>
          5 >= 5
        </Expanded>
      </Expression>
      <Section name="resizing bigger changes size and capacity">
MiscTests.cpp" line="305">
          <Original>
            v.size() == 10
          </Original>
          <Expanded>
            10 == 10
          </Expanded>
        </Expression>
MiscTests.cpp" line="306">
          <Original>
            v.capacity() >= 10
          </Original>
          <Expanded>
            10 >= 10
          </Expanded>
        </Expression>
        <OverallResults successes="2" failures="0"/>
      </Section>
MiscTests.cpp" line="299">
        <Original>
          v.size() == 5
        </Original>
        <Expanded>
          5 == 5
        </Expanded>
      </Expression>
MiscTests.cpp" line="300">
        <Original>
          v.capacity() >= 5
        </Original>
        <Expanded>
          5 >= 5
        </Expanded>
      </Expression>
      <Section name="resizing smaller changes size but not capacity">
MiscTests.cpp" line="311">
          <Original>
            v.size() == 0
          </Original>
          <Expanded>
            0 == 0
          </Expanded>
        </Expression>
MiscTests.cpp" line="312">
          <Original>
            v.capacity() >= 5
          </Original>
          <Expanded>
            5 >= 5
          </Expanded>
        </Expression>
        <Section name="We can use the 'swap trick' to reset the capacity">
MiscTests.cpp" line="318">
            <Original>
              v.capacity() == 0
            </Original>
            <Expanded>
              0 == 0
            </Expanded>
          </Expression>
          <OverallResults successes="1" failures="0"/>
        </Section>
        <OverallResults successes="3" failures="0"/>
      </Section>
MiscTests.cpp" line="299">
        <Original>
          v.size() == 5
        </Original>
        <Expanded>
          5 == 5
        </Expanded>
      </Expression>
MiscTests.cpp" line="300">
        <Original>
          v.capacity() >= 5
        </Original>
        <Expanded>
          5 >= 5
        </Expanded>
      </Expression>
      <Section name="resizing smaller changes size but not capacity">
MiscTests.cpp" line="311">
          <Original>
            v.size() == 0
          </Original>
          <Expanded>
            0 == 0
          </Expanded>
        </Expression>
MiscTests.cpp" line="312">
          <Original>
            v.capacity() >= 5
          </Original>
          <Expanded>
            5 >= 5
          </Expanded>
        </Expression>
        <OverallResults successes="2" failures="0"/>
      </Section>
MiscTests.cpp" line="299">
        <Original>
          v.size() == 5
        </Original>
        <Expanded>
          5 == 5
        </Expanded>
      </Expression>
MiscTests.cpp" line="300">
        <Original>
          v.capacity() >= 5
        </Original>
        <Expanded>
          5 >= 5
        </Expanded>
      </Expression>
      <Section name="reserving bigger changes capacity but not size">
MiscTests.cpp" line="324">
          <Original>
            v.size() == 5
          </Original>
          <Expanded>
            5 == 5
          </Expanded>
        </Expression>
MiscTests.cpp" line="325">
          <Original>
            v.capacity() >= 10
          </Original>
          <Expanded>
            10 >= 10
          </Expanded>
        </Expression>
        <OverallResults successes="2" failures="0"/>
      </Section>
MiscTests.cpp" line="299">
        <Original>
          v.size() == 5
        </Original>
        <Expanded>
          5 == 5
        </Expanded>
      </Expression>
MiscTests.cpp" line="300">
        <Original>
          v.capacity() >= 5
        </Original>
        <Expanded>
          5 >= 5
        </Expanded>
      </Expression>
      <Section name="reserving smaller does not change size or capacity">
MiscTests.cpp" line="330">
          <Original>
            v.size() == 5
          </Original>
          <Expanded>
            5 == 5
          </Expanded>
        </Expression>
MiscTests.cpp" line="331">
          <Original>
            v.capacity() >= 5
          </Original>
          <Expanded>
            5 >= 5
          </Expanded>
        </Expression>
        <OverallResults successes="2" failures="0"/>
      </Section>
      <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="27" failures="0"/>
        </Section>
        <OverallResults successes="27" failures="0"/>
      </Section>
      <Section name="selftest/expected result" description="Tests do what they claim">
        <Section name="selftest/expected result/succeeding tests" description="Tests in the 'succeeding' branch succeed">
          <OverallResults successes="46" failures="0"/>
        </Section>
        <OverallResults successes="46" failures="0"/>
      </Section>
      <Section name="selftest/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="41">
            <Original>
              totals.assertions.passed == 296
            </Original>
            <Expanded>
              296 == 296
            </Expanded>
          </Expression>
TestMain.cpp" line="42">
            <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="48">
            <Original>
              totals.assertions.passed == 1
            </Original>
            <Expanded>
              1 == 1
            </Expanded>
          </Expression>
TestMain.cpp" line="49">
            <Original>
              totals.assertions.failed == 74
            </Original>
            <Expanded>
              74 == 74
            </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="58">
        <Original>
          totals.assertions.passed == 2
        </Original>
        <Expanded>
          2 == 2
        </Expanded>
      </Expression>
TestMain.cpp" line="59">
        <Original>
          totals.assertions.failed == 1
        </Original>
        <Expanded>
          1 == 1
        </Expanded>
      </Expression>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="Process can be configured on command line">
      <Section name="default - no arguments">
TestMain.cpp" line="98">
          <Original>
            parseIntoConfig( argv, config )
          </Original>
          <Expanded>
            parseIntoConfig( argv, config )
          </Expanded>
        </Expression>
TestMain.cpp" line="100">
          <Original>
            config.shouldDebugBreak == false
          </Original>
          <Expanded>
            false == false
          </Expanded>
        </Expression>
TestMain.cpp" line="101">
          <Original>
            config.abortAfter == -1
          </Original>
          <Expanded>
            -1 == -1
          </Expanded>
        </Expression>
TestMain.cpp" line="102">
          <Original>
            config.noThrow == false
          </Original>
          <Expanded>
            false == false
          </Expanded>
        </Expression>
TestMain.cpp" line="103">
          <Original>
            config.reporterName.empty()
          </Original>
          <Expanded>
            true
          </Expanded>
        </Expression>
        <OverallResults successes="5" failures="0"/>
      </Section>
      <Section name="test lists">
        <Section name="1 test" description="Specify one test case using">
TestMain.cpp" line="109">
            <Original>
              parseIntoConfig( argv, config )
            </Original>
            <Expanded>
              parseIntoConfig( argv, config )
            </Expanded>
          </Expression>
TestMain.cpp" line="112">
            <Original>
              cfg.filters().size() == 1
            </Original>
            <Expanded>
              1 == 1
            </Expanded>
          </Expression>
TestMain.cpp" line="113">
            <Original>
              cfg.filters()[0].shouldInclude( fakeTestCase( &quot;notIncluded&quot; ) ) == false
            </Original>
            <Expanded>
              false == false
            </Expanded>
          </Expression>
TestMain.cpp" line="114">
            <Original>
              cfg.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="Specify one test case exclusion using exclude:">
TestMain.cpp" line="118">
            <Original>
              parseIntoConfig( argv, config )
            </Original>
            <Expanded>
              parseIntoConfig( argv, config )
            </Expanded>
          </Expression>
TestMain.cpp" line="121">
            <Original>
              cfg.filters().size() == 1
            </Original>
            <Expanded>
              1 == 1
            </Expanded>
          </Expression>
TestMain.cpp" line="122">
            <Original>
              cfg.filters()[0].shouldInclude( fakeTestCase( &quot;test1&quot; ) ) == false
            </Original>
            <Expanded>
              false == false
            </Expanded>
          </Expression>
TestMain.cpp" line="123">
            <Original>
              cfg.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="Specify one test case exclusion using ~">
TestMain.cpp" line="128">
            <Original>
              parseIntoConfig( argv, config )
            </Original>
            <Expanded>
              parseIntoConfig( argv, config )
            </Expanded>
          </Expression>
TestMain.cpp" line="131">
            <Original>
              cfg.filters().size() == 1
            </Original>
            <Expanded>
              1 == 1
            </Expanded>
          </Expression>
TestMain.cpp" line="132">
            <Original>
              cfg.filters()[0].shouldInclude( fakeTestCase( &quot;test1&quot; ) ) == false
            </Original>
            <Expanded>
              false == false
            </Expanded>
          </Expression>
TestMain.cpp" line="133">
            <Original>
              cfg.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="Specify two test cases using -t">
TestMain.cpp" line="138">
            <Original>
              parseIntoConfig( argv, config )
            </Original>
            <Expanded>
              parseIntoConfig( argv, config )
            </Expanded>
          </Expression>
TestMain.cpp" line="141">
            <Original>
              cfg.filters().size() == 1
            </Original>
            <Expanded>
              1 == 1
            </Expanded>
          </Expression>
TestMain.cpp" line="142">
            <Original>
              cfg.filters()[0].shouldInclude( fakeTestCase( &quot;notIncluded&quot; ) ) == false
            </Original>
            <Expanded>
              false == false
            </Expanded>
          </Expression>
TestMain.cpp" line="143">
            <Original>
              cfg.filters()[0].shouldInclude( fakeTestCase( &quot;test1&quot; ) )
            </Original>
            <Expanded>
              true
            </Expanded>
          </Expression>
TestMain.cpp" line="144">
            <Original>
              cfg.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">
        <OverallResults successes="0" failures="0"/>
      </Section>
      <Section name="reporter">
        <Section name="-r/console">
TestMain.cpp" line="151">
            <Original>
              parseIntoConfig( argv, config )
            </Original>
            <Expanded>
              parseIntoConfig( argv, config )
            </Expanded>
          </Expression>
TestMain.cpp" line="153">
            <Original>
              config.reporterName == &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="157">
            <Original>
              parseIntoConfig( argv, config )
            </Original>
            <Expanded>
              parseIntoConfig( argv, config )
            </Expanded>
          </Expression>
TestMain.cpp" line="159">
            <Original>
              config.reporterName == &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="163">
            <Original>
              parseIntoConfig( argv, config )
            </Original>
            <Expanded>
              parseIntoConfig( argv, config )
            </Expanded>
          </Expression>
TestMain.cpp" line="165">
            <Original>
              config.reporterName == &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">
        <OverallResults successes="0" failures="0"/>
      </Section>
      <Section name="debugger">
        <Section name="-b">
TestMain.cpp" line="172">
            <Original>
              parseIntoConfig( argv, config )
            </Original>
            <Expanded>
              parseIntoConfig( argv, config )
            </Expanded>
          </Expression>
TestMain.cpp" line="174">
            <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="178">
            <Original>
              parseIntoConfig( argv, config )
            </Original>
            <Expanded>
              parseIntoConfig( argv, config )
            </Expanded>
          </Expression>
TestMain.cpp" line="180">
            <Original>
              config.shouldDebugBreak
            </Original>
            <Expanded>
              true
            </Expanded>
          </Expression>
          <OverallResults successes="2" failures="0"/>
        </Section>
        <OverallResults successes="2" failures="0"/>
      </Section>
      <Section name="debugger">
        <OverallResults successes="0" failures="0"/>
      </Section>
      <Section name="abort">
        <Section name="-a aborts after first failure">
TestMain.cpp" line="187">
            <Original>
              parseIntoConfig( argv, config )
            </Original>
            <Expanded>
              parseIntoConfig( argv, config )
            </Expanded>
          </Expression>
TestMain.cpp" line="189">
            <Original>
              config.abortAfter == 1
            </Original>
            <Expanded>
              1 == 1
            </Expanded>
          </Expression>
          <OverallResults successes="2" failures="0"/>
        </Section>
        <OverallResults successes="2" failures="0"/>
      </Section>
      <Section name="abort">
        <Section name="-x 2 aborts after two failures">
TestMain.cpp" line="193">
            <Original>
              parseIntoConfig( argv, config )
            </Original>
            <Expanded>
              parseIntoConfig( argv, config )
            </Expanded>
          </Expression>
TestMain.cpp" line="195">
            <Original>
              config.abortAfter == 2
            </Original>
            <Expanded>
              2 == 2
            </Expanded>
          </Expression>
          <OverallResults successes="2" failures="0"/>
        </Section>
        <OverallResults successes="2" failures="0"/>
      </Section>
      <Section name="abort">
        <Section name="-x must be greater than zero">
TestMain.cpp" line="199">
            <Original>
              parseIntoConfigAndReturnError( argv, config ) Contains( &quot;greater than zero&quot; )
            </Original>
            <Expanded>
              &quot;Value after -x or --abortAfter must be greater than zero while parsing: (-x, --abortx &lt;number of failures>)&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="-x must be numeric">
TestMain.cpp" line="203">
            <Original>
              parseIntoConfigAndReturnError( argv, config ) Contains( &quot;-x&quot; )
            </Original>
            <Expanded>
              &quot;Unable to convert oops to destination type while parsing: (-x, --abortx &lt;number of failures>)&quot; contains: &quot;-x&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="-e">
TestMain.cpp" line="210">
            <Original>
              parseIntoConfig( argv, config )
            </Original>
            <Expanded>
              parseIntoConfig( argv, config )
            </Expanded>
          </Expression>
TestMain.cpp" line="212">
            <Original>
              config.noThrow == true
            </Original>
            <Expanded>
              true == true
            </Expanded>
          </Expression>
          <OverallResults successes="2" failures="0"/>
        </Section>
        <OverallResults successes="2" failures="0"/>
      </Section>
      <Section name="nothrow">
        <Section name="--nothrow">
TestMain.cpp" line="216">
            <Original>
              parseIntoConfig( argv, config )
            </Original>
            <Expanded>
              parseIntoConfig( argv, config )
            </Expanded>
          </Expression>
TestMain.cpp" line="218">
            <Original>
              config.noThrow == true
            </Original>
            <Expanded>
              true == true
            </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="output filename">
        <Section name="-o filename">
TestMain.cpp" line="225">
            <Original>
              parseIntoConfig( argv, config )
            </Original>
            <Expanded>
              parseIntoConfig( argv, config )
            </Expanded>
          </Expression>
TestMain.cpp" line="227">
            <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="output filename">
        <Section name="--out">
TestMain.cpp" line="231">
            <Original>
              parseIntoConfig( argv, config )
            </Original>
            <Expanded>
              parseIntoConfig( argv, config )
            </Expanded>
          </Expression>
TestMain.cpp" line="233">
            <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="output filename">
        <OverallResults successes="0" failures="0"/>
      </Section>
      <Section name="combinations">
        <Section name="Single character flags can be combined">
TestMain.cpp" line="240">
            <Original>
              parseIntoConfig( argv, config )
            </Original>
            <Expanded>
              parseIntoConfig( argv, config )
            </Expanded>
          </Expression>
TestMain.cpp" line="242">
            <Original>
              config.abortAfter == 1
            </Original>
            <Expanded>
              1 == 1
            </Expanded>
          </Expression>
TestMain.cpp" line="243">
            <Original>
              config.shouldDebugBreak
            </Original>
            <Expanded>
              true
            </Expanded>
          </Expression>
TestMain.cpp" line="244">
            <Original>
              config.noThrow == true
            </Original>
            <Expanded>
              true == true
            </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="253">
        <Original>
          matchAny.shouldInclude( fakeTestCase( &quot;any&quot; ) )
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
TestMain.cpp" line="254">
        <Original>
          matchNone.shouldInclude( fakeTestCase( &quot;any&quot; ) ) == false
        </Original>
        <Expanded>
          false == false
        </Expanded>
      </Expression>
TestMain.cpp" line="259">
        <Original>
          matchHidden.shouldInclude( fakeTestCase( &quot;any&quot; ) ) == false
        </Original>
        <Expanded>
          false == false
        </Expanded>
      </Expression>
TestMain.cpp" line="260">
        <Original>
          matchNonHidden.shouldInclude( fakeTestCase( &quot;any&quot; ) )
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
TestMain.cpp" line="262">
        <Original>
          matchHidden.shouldInclude( fakeTestCase( &quot;./any&quot; ) )
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
TestMain.cpp" line="263">
        <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="274">
        <Original>
          matchHidden.shouldInclude( fakeTestCase( &quot;./something&quot; ) )
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
TestMain.cpp" line="276">
        <Original>
          filters.shouldInclude( fakeTestCase( &quot;any&quot; ) ) == false
        </Original>
        <Expanded>
          false == false
        </Expanded>
      </Expression>
TestMain.cpp" line="277">
        <Original>
          filters.shouldInclude( fakeTestCase( &quot;./something&quot; ) )
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
TestMain.cpp" line="278">
        <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="284">
        <Original>
          matchBadgers.shouldInclude( fakeTestCase( &quot;big badger&quot; ) )
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
TestMain.cpp" line="285">
        <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="290">
        <Original>
          matchBadgers.shouldInclude( fakeTestCase( &quot;big badger&quot; ) )
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
TestMain.cpp" line="291">
        <Original>
          matchBadgers.shouldInclude( fakeTestCase( &quot;little badgers&quot; ) )
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
TestMain.cpp" line="292">
        <Original>
          matchBadgers.shouldInclude( fakeTestCase( &quot;badgers are big&quot; ) )
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
TestMain.cpp" line="293">
        <Original>
          matchBadgers.shouldInclude( fakeTestCase( &quot;hedgehogs&quot; ) ) == false
        </Original>
        <Expanded>
          false == false
        </Expanded>
      </Expression>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="selftest/tags">
      <Section name="one tag">
TestMain.cpp" line="313">
          <Original>
            oneTag.getTestCaseInfo().description == &quot;&quot;
          </Original>
          <Expanded>
            &quot;&quot; == &quot;&quot;
          </Expanded>
        </Expression>
TestMain.cpp" line="314">
          <Original>
            oneTag.hasTag( &quot;one&quot; )
          </Original>
          <Expanded>
            true
          </Expanded>
        </Expression>
TestMain.cpp" line="315">
          <Original>
            oneTag.getTags().size() == 1
          </Original>
          <Expanded>
            1 == 1
          </Expanded>
        </Expression>
TestMain.cpp" line="317">
          <Original>
            oneTag.matchesTags( p1 ) == true
          </Original>
          <Expanded>
            true == true
          </Expanded>
        </Expression>
TestMain.cpp" line="318">
          <Original>
            oneTag.matchesTags( p2 ) == true
          </Original>
          <Expanded>
            true == true
          </Expanded>
        </Expression>
TestMain.cpp" line="319">
          <Original>
            oneTag.matchesTags( p3 ) == false
          </Original>
          <Expanded>
            false == false
          </Expanded>
        </Expression>
TestMain.cpp" line="320">
          <Original>
            oneTag.matchesTags( p4 ) == false
          </Original>
          <Expanded>
            false == false
          </Expanded>
        </Expression>
TestMain.cpp" line="321">
          <Original>
            oneTag.matchesTags( p5 ) == false
          </Original>
          <Expanded>
            false == false
          </Expanded>
        </Expression>
        <OverallResults successes="8" failures="0"/>
      </Section>
      <Section name="two tags">
TestMain.cpp" line="327">
          <Original>
            twoTags.getTestCaseInfo().description == &quot;&quot;
          </Original>
          <Expanded>
            &quot;&quot; == &quot;&quot;
          </Expanded>
        </Expression>
TestMain.cpp" line="328">
          <Original>
            twoTags.hasTag( &quot;one&quot; )
          </Original>
          <Expanded>
            true
          </Expanded>
        </Expression>
TestMain.cpp" line="329">
          <Original>
            twoTags.hasTag( &quot;two&quot; )
          </Original>
          <Expanded>
            true
          </Expanded>
        </Expression>
TestMain.cpp" line="330">
          <Original>
            twoTags.hasTag( &quot;Two&quot; )
          </Original>
          <Expanded>
            true
          </Expanded>
        </Expression>
TestMain.cpp" line="331">
          <Original>
            twoTags.hasTag( &quot;three&quot; ) == false
          </Original>
          <Expanded>
            false == false
          </Expanded>
        </Expression>
TestMain.cpp" line="332">
          <Original>
            twoTags.getTags().size() == 2
          </Original>
          <Expanded>
            2 == 2
          </Expanded>
        </Expression>
TestMain.cpp" line="334">
          <Original>
            twoTags.matchesTags( p1 ) == true
          </Original>
          <Expanded>
            true == true
          </Expanded>
        </Expression>
TestMain.cpp" line="335">
          <Original>
            twoTags.matchesTags( p2 ) == true
          </Original>
          <Expanded>
            true == true
          </Expanded>
        </Expression>
TestMain.cpp" line="336">
          <Original>
            twoTags.matchesTags( p3 ) == true
          </Original>
          <Expanded>
            true == true
          </Expanded>
        </Expression>
TestMain.cpp" line="337">
          <Original>
            twoTags.matchesTags( p4 ) == true
          </Original>
          <Expanded>
            true == true
          </Expanded>
        </Expression>
TestMain.cpp" line="338">
          <Original>
            twoTags.matchesTags( p5 ) == true
          </Original>
          <Expanded>
            true == true
          </Expanded>
        </Expression>
        <OverallResults successes="11" failures="0"/>
      </Section>
      <Section name="one tag with characters either side">
TestMain.cpp" line="344">
          <Original>
            oneTagWithExtras.getTestCaseInfo().description == &quot;1234&quot;
          </Original>
          <Expanded>
            &quot;1234&quot; == &quot;1234&quot;
          </Expanded>
        </Expression>
TestMain.cpp" line="345">
          <Original>
            oneTagWithExtras.hasTag( &quot;one&quot; )
          </Original>
          <Expanded>
            true
          </Expanded>
        </Expression>
TestMain.cpp" line="346">
          <Original>
            oneTagWithExtras.hasTag( &quot;two&quot; ) == false
          </Original>
          <Expanded>
            false == false
          </Expanded>
        </Expression>
TestMain.cpp" line="347">
          <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="354">
          <Original>
            oneTagOpen.getTestCaseInfo().description == &quot;[one&quot;
          </Original>
          <Expanded>
            &quot;[one&quot; == &quot;[one&quot;
          </Expanded>
        </Expression>
TestMain.cpp" line="355">
          <Original>
            oneTagOpen.hasTag( &quot;one&quot; ) == false
          </Original>
          <Expanded>
            false == false
          </Expanded>
        </Expression>
TestMain.cpp" line="356">
          <Original>
            oneTagOpen.getTags().size() == 0
          </Original>
          <Expanded>
            0 == 0
          </Expanded>
        </Expression>
        <OverallResults successes="3" failures="0"/>
      </Section>
      <Section name="hidden">
TestMain.cpp" line="362">
          <Original>
            oneTag.getTestCaseInfo().description == &quot;&quot;
          </Original>
          <Expanded>
            &quot;&quot; == &quot;&quot;
          </Expanded>
        </Expression>
TestMain.cpp" line="363">
          <Original>
            oneTag.hasTag( &quot;hide&quot; )
          </Original>
          <Expanded>
            true
          </Expanded>
        </Expression>
TestMain.cpp" line="364">
          <Original>
            oneTag.isHidden()
          </Original>
          <Expanded>
            true
          </Expanded>
        </Expression>
TestMain.cpp" line="366">
          <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="Long strings can be wrapped">
      <Section name="plain string">
        <Section name="No wrapping">
TestMain.cpp" line="379">
            <Original>
              Text( testString, TextAttributes().setWidth( 80 ) ).toString() == testString
            </Original>
            <Expanded>
              &quot;one two three four&quot;
==
&quot;one two three four&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="380">
            <Original>
              Text( testString, TextAttributes().setWidth( 18 ) ).toString() == testString
            </Original>
            <Expanded>
              &quot;one two three four&quot;
==
&quot;one two three four&quot;
            </Expanded>
          </Expression>
          <OverallResults successes="2" failures="0"/>
        </Section>
        <OverallResults successes="2" failures="0"/>
      </Section>
      <Section name="plain string">
        <Section name="Wrapped once">
TestMain.cpp" line="383">
            <Original>
              Text( testString, TextAttributes().setWidth( 17 ) ).toString() == &quot;one two three\nfour&quot;
            </Original>
            <Expanded>
              &quot;one two three
four&quot;
==
&quot;one two three
four&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="384">
            <Original>
              Text( testString, TextAttributes().setWidth( 16 ) ).toString() == &quot;one two three\nfour&quot;
            </Original>
            <Expanded>
              &quot;one two three
four&quot;
==
&quot;one two three
four&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="385">
            <Original>
              Text( testString, TextAttributes().setWidth( 14 ) ).toString() == &quot;one two three\nfour&quot;
            </Original>
            <Expanded>
              &quot;one two three
four&quot;
==
&quot;one two three
four&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="386">
            <Original>
              Text( testString, TextAttributes().setWidth( 13 ) ).toString() == &quot;one two three\nfour&quot;
            </Original>
            <Expanded>
              &quot;one two three
four&quot;
==
&quot;one two three
four&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="387">
            <Original>
              Text( testString, TextAttributes().setWidth( 12 ) ).toString() == &quot;one two\nthree four&quot;
            </Original>
            <Expanded>
              &quot;one two
three four&quot;
==
&quot;one two
three four&quot;
            </Expanded>
          </Expression>
          <OverallResults successes="5" failures="0"/>
        </Section>
        <OverallResults successes="5" failures="0"/>
      </Section>
      <Section name="plain string">
        <Section name="Wrapped twice">
TestMain.cpp" line="390">
            <Original>
              Text( testString, TextAttributes().setWidth( 9 ) ).toString() == &quot;one two\nthree\nfour&quot;
            </Original>
            <Expanded>
              &quot;one two
three
four&quot;
==
&quot;one two
three
four&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="391">
            <Original>
              Text( testString, TextAttributes().setWidth( 8 ) ).toString() == &quot;one two\nthree\nfour&quot;
            </Original>
            <Expanded>
              &quot;one two
three
four&quot;
==
&quot;one two
three
four&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="392">
            <Original>
              Text( testString, TextAttributes().setWidth( 7 ) ).toString() == &quot;one two\nthree\nfour&quot;
            </Original>
            <Expanded>
              &quot;one two
three
four&quot;
==
&quot;one two
three
four&quot;
            </Expanded>
          </Expression>
          <OverallResults successes="3" failures="0"/>
        </Section>
        <OverallResults successes="3" failures="0"/>
      </Section>
      <Section name="plain string">
        <Section name="Wrapped three times">
TestMain.cpp" line="395">
            <Original>
              Text( testString, TextAttributes().setWidth( 6 ) ).toString() == &quot;one\ntwo\nthree\nfour&quot;
            </Original>
            <Expanded>
              &quot;one
two
three
four&quot;
==
&quot;one
two
three
four&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="396">
            <Original>
              Text( testString, TextAttributes().setWidth( 5 ) ).toString() == &quot;one\ntwo\nthree\nfour&quot;
            </Original>
            <Expanded>
              &quot;one
two
three
four&quot;
==
&quot;one
two
three
four&quot;
            </Expanded>
          </Expression>
          <OverallResults successes="2" failures="0"/>
        </Section>
        <OverallResults successes="2" failures="0"/>
      </Section>
      <Section name="plain string">
        <Section name="Short wrap">
TestMain.cpp" line="399">
            <Original>
              Text( &quot;abcdef&quot;, TextAttributes().setWidth( 4 ) ).toString() == &quot;abc-\ndef&quot;
            </Original>
            <Expanded>
              &quot;abc-
def&quot;
==
&quot;abc-
def&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="400">
            <Original>
              Text( &quot;abcdefg&quot;, TextAttributes().setWidth( 4 ) ).toString() == &quot;abc-\ndefg&quot;
            </Original>
            <Expanded>
              &quot;abc-
defg&quot;
==
&quot;abc-
defg&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="401">
            <Original>
              Text( &quot;abcdefgh&quot;, TextAttributes().setWidth( 4 ) ).toString() == &quot;abc-\ndef-\ngh&quot;
            </Original>
            <Expanded>
              &quot;abc-
def-
gh&quot;
==
&quot;abc-
def-
gh&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="403">
            <Original>
              Text( testString, TextAttributes().setWidth( 4 ) ).toString() == &quot;one\ntwo\nthr-\nee\nfour&quot;
            </Original>
            <Expanded>
              &quot;one
two
thr-
ee
four&quot;
==
&quot;one
two
thr-
ee
four&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="404">
            <Original>
              Text( testString, TextAttributes().setWidth( 3 ) ).toString() == &quot;one\ntwo\nth-\nree\nfo-\nur&quot;
            </Original>
            <Expanded>
              &quot;one
two
th-
ree
fo-
ur&quot;
==
&quot;one
two
th-
ree
fo-
ur&quot;
            </Expanded>
          </Expression>
          <OverallResults successes="5" failures="0"/>
        </Section>
        <OverallResults successes="5" failures="0"/>
      </Section>
      <Section name="plain string">
        <Section name="As container">
TestMain.cpp" line="408">
            <Original>
              text.size() == 4
            </Original>
            <Expanded>
              4 == 4
            </Expanded>
          </Expression>
TestMain.cpp" line="409">
            <Original>
              text[0] == &quot;one&quot;
            </Original>
            <Expanded>
              &quot;one&quot; == &quot;one&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="410">
            <Original>
              text[1] == &quot;two&quot;
            </Original>
            <Expanded>
              &quot;two&quot; == &quot;two&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="411">
            <Original>
              text[2] == &quot;three&quot;
            </Original>
            <Expanded>
              &quot;three&quot; == &quot;three&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="412">
            <Original>
              text[3] == &quot;four&quot;
            </Original>
            <Expanded>
              &quot;four&quot; == &quot;four&quot;
            </Expanded>
          </Expression>
          <OverallResults successes="5" failures="0"/>
        </Section>
        <OverallResults successes="5" failures="0"/>
      </Section>
      <Section name="plain string">
        <Section name="Indent first line differently">
TestMain.cpp" line="419">
            <Original>
              text.toString() == &quot; one two\n    three\n    four&quot;
            </Original>
            <Expanded>
              &quot; one two
    three
    four&quot;
==
&quot; one two
    three
    four&quot;
            </Expanded>
          </Expression>
          <OverallResults successes="1" failures="0"/>
        </Section>
        <OverallResults successes="1" failures="0"/>
      </Section>
      <Section name="plain string">
        <OverallResults successes="0" failures="0"/>
      </Section>
      <Section name="With newlines">
        <Section name="No wrapping">
TestMain.cpp" line="430">
            <Original>
              Text( testString, TextAttributes().setWidth( 80 ) ).toString() == testString
            </Original>
            <Expanded>
              &quot;one two
three four&quot;
==
&quot;one two
three four&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="431">
            <Original>
              Text( testString, TextAttributes().setWidth( 18 ) ).toString() == testString
            </Original>
            <Expanded>
              &quot;one two
three four&quot;
==
&quot;one two
three four&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="432">
            <Original>
              Text( testString, TextAttributes().setWidth( 10 ) ).toString() == testString
            </Original>
            <Expanded>
              &quot;one two
three four&quot;
==
&quot;one two
three four&quot;
            </Expanded>
          </Expression>
          <OverallResults successes="3" failures="0"/>
        </Section>
        <OverallResults successes="3" failures="0"/>
      </Section>
      <Section name="With newlines">
        <Section name="Trailing newline">
TestMain.cpp" line="435">
            <Original>
              Text( &quot;abcdef\n&quot;, TextAttributes().setWidth( 10 ) ).toString() == &quot;abcdef\n&quot;
            </Original>
            <Expanded>
              &quot;abcdef
&quot;
==
&quot;abcdef
&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="436">
            <Original>
              Text( &quot;abcdef&quot;, TextAttributes().setWidth( 6 ) ).toString() == &quot;abcdef&quot;
            </Original>
            <Expanded>
              &quot;abcdef&quot; == &quot;abcdef&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="437">
            <Original>
              Text( &quot;abcdef\n&quot;, TextAttributes().setWidth( 6 ) ).toString() == &quot;abcdef\n&quot;
            </Original>
            <Expanded>
              &quot;abcdef
&quot;
==
&quot;abcdef
&quot;
            </Expanded>
          </Expression>
          <OverallResults successes="3" failures="0"/>
        </Section>
        <OverallResults successes="3" failures="0"/>
      </Section>
      <Section name="With newlines">
        <Section name="Wrapped once">
TestMain.cpp" line="440">
            <Original>
              Text( testString, TextAttributes().setWidth( 9 ) ).toString() == &quot;one two\nthree\nfour&quot;
            </Original>
            <Expanded>
              &quot;one two
three
four&quot;
==
&quot;one two
three
four&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="441">
            <Original>
              Text( testString, TextAttributes().setWidth( 8 ) ).toString() == &quot;one two\nthree\nfour&quot;
            </Original>
            <Expanded>
              &quot;one two
three
four&quot;
==
&quot;one two
three
four&quot;
            </Expanded>
          </Expression>
TestMain.cpp" line="442">
            <Original>
              Text( testString, TextAttributes().setWidth( 7 ) ).toString() == &quot;one two\nthree\nfour&quot;
            </Original>
            <Expanded>
              &quot;one two
three
four&quot;
==
&quot;one two
three
four&quot;
            </Expanded>
          </Expression>
          <OverallResults successes="3" failures="0"/>
        </Section>
        <OverallResults successes="3" failures="0"/>
      </Section>
      <Section name="With newlines">
        <Section name="Wrapped twice">
TestMain.cpp" line="445">
            <Original>
              Text( testString, TextAttributes().setWidth( 6 ) ).toString() == &quot;one\ntwo\nthree\nfour&quot;
            </Original>
            <Expanded>
              &quot;one
two
three
four&quot;
==
&quot;one
two
three
four&quot;
            </Expanded>
          </Expression>
          <OverallResults successes="1" failures="0"/>
        </Section>
        <OverallResults successes="1" failures="0"/>
      </Section>
      <Section name="With newlines">
        <OverallResults successes="0" failures="0"/>
      </Section>
      <Section name="With tabs">
TestMain.cpp" line="455">
          <Original>
            Text( testString, TextAttributes().setWidth( 15 ) ).toString() == &quot;one two three\n        four\n        five\n        six&quot;
          </Original>
          <Expanded>
            &quot;one two three
        four
        five
        six&quot;
==
&quot;one two three
        four
        five
        six&quot;
          </Expanded>
        </Expression>
        <OverallResults successes="1" failures="0"/>
      </Section>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="Strings can be rendered with colour">
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="Text can be formatted using the Text class">
TestMain.cpp" line="555">
        <Original>
          Text( &quot;hi there&quot; ).toString() == &quot;hi there&quot;
        </Original>
        <Expanded>
          &quot;hi there&quot; == &quot;hi there&quot;
        </Expanded>
      </Expression>
TestMain.cpp" line="560">
        <Original>
          Text( &quot;hi there&quot;, narrow ).toString() == &quot;hi\nthere&quot;
        </Original>
        <Expanded>
          &quot;hi
there&quot;
==
&quot;hi
there&quot;
        </Expanded>
      </Expression>
      <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="Assertions then sections">
TrickyTests.cpp" line="323">
        <Original>
          Catch::isTrue( true )
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
      <Section name="A section">
TrickyTests.cpp" line="327">
          <Original>
            Catch::isTrue( true )
          </Original>
          <Expanded>
            true
          </Expanded>
        </Expression>
        <Section name="Another section">
TrickyTests.cpp" line="331">
            <Original>
              Catch::isTrue( true )
            </Original>
            <Expanded>
              true
            </Expanded>
          </Expression>
          <OverallResults successes="1" failures="0"/>
        </Section>
        <OverallResults successes="2" failures="0"/>
      </Section>
TrickyTests.cpp" line="323">
        <Original>
          Catch::isTrue( true )
        </Original>
        <Expanded>
          true
        </Expanded>
      </Expression>
      <Section name="A section">
TrickyTests.cpp" line="327">
          <Original>
            Catch::isTrue( true )
          </Original>
          <Expanded>
            true
          </Expanded>
        </Expression>
        <Section name="Another other section">
TrickyTests.cpp" line="335">
            <Original>
              Catch::isTrue( true )
            </Original>
            <Expanded>
              true
            </Expanded>
          </Expression>
          <OverallResults successes="1" failures="0"/>
        </Section>
        <OverallResults successes="2" failures="0"/>
      </Section>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="non streamable - with conv. op">
TrickyTests.cpp" line="349">
        <Original>
          s == &quot;7&quot;
        </Original>
        <Expanded>
          &quot;7&quot; == &quot;7&quot;
        </Expanded>
      </Expression>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="Anonymous test case 1">
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="Test case with one argument">
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="Variadic macros">
      <Section name="Section with one argument">
        <OverallResults successes="1" failures="0"/>
      </Section>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="Scenario: Do that thing with the thing">
      <Section name="   Given: This stuff exists">
        <Section name="    When: I do this">
          <Section name="    Then: it should do this">
BDDTests.cpp" line="21">
              <Original>
                itDoesThis()
              </Original>
              <Expanded>
                true
              </Expanded>
            </Expression>
            <Section name="     And: do that">
BDDTests.cpp" line="23">
                <Original>
                  itDoesThat()
                </Original>
                <Expanded>
                  true
                </Expanded>
              </Expression>
              <OverallResults successes="1" failures="0"/>
            </Section>
            <OverallResults successes="2" failures="0"/>
          </Section>
          <OverallResults successes="2" failures="0"/>
        </Section>
        <OverallResults successes="2" failures="0"/>
      </Section>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="Scenario: Vector resizing affects size and capacity">
      <Section name="   Given: an empty vector">
BDDTests.cpp" line="32">
          <Original>
            v.size() == 0
          </Original>
          <Expanded>
            0 == 0
          </Expanded>
        </Expression>
        <Section name="    When: it is made larger">
          <Section name="    Then: the size and capacity go up">
BDDTests.cpp" line="37">
              <Original>
                v.size() == 10
              </Original>
              <Expanded>
                10 == 10
              </Expanded>
            </Expression>
BDDTests.cpp" line="38">
              <Original>
                v.capacity() >= 10
              </Original>
              <Expanded>
                10 >= 10
              </Expanded>
            </Expression>
            <Section name="And when: it is made smaller again">
              <Section name="    Then: the size goes down but the capacity stays the same">
BDDTests.cpp" line="43">
                  <Original>
                    v.size() == 5
                  </Original>
                  <Expanded>
                    5 == 5
                  </Expanded>
                </Expression>
BDDTests.cpp" line="44">
                  <Original>
                    v.capacity() >= 10
                  </Original>
                  <Expanded>
                    10 >= 10
                  </Expanded>
                </Expression>
                <OverallResults successes="2" failures="0"/>
              </Section>
              <OverallResults successes="2" failures="0"/>
            </Section>
            <OverallResults successes="4" failures="0"/>
          </Section>
          <OverallResults successes="4" failures="0"/>
        </Section>
        <OverallResults successes="5" failures="0"/>
      </Section>
      <Section name="   Given: an empty vector">
BDDTests.cpp" line="32">
          <Original>
            v.size() == 0
          </Original>
          <Expanded>
            0 == 0
          </Expanded>
        </Expression>
        <Section name="    When: it is made larger">
          <Section name="    Then: the size and capacity go up">
BDDTests.cpp" line="37">
              <Original>
                v.size() == 10
              </Original>
              <Expanded>
                10 == 10
              </Expanded>
            </Expression>
BDDTests.cpp" line="38">
              <Original>
                v.capacity() >= 10
              </Original>
              <Expanded>
                10 >= 10
              </Expanded>
            </Expression>
            <Section name="And when: it is made smaller again">
              <OverallResults successes="0" failures="0"/>
            </Section>
            <OverallResults successes="2" failures="0"/>
          </Section>
          <OverallResults successes="2" failures="0"/>
        </Section>
        <OverallResults successes="3" failures="0"/>
      </Section>
      <Section name="   Given: an empty vector">
BDDTests.cpp" line="32">
          <Original>
            v.size() == 0
          </Original>
          <Expanded>
            0 == 0
          </Expanded>
        </Expression>
        <Section name="    When: it is made larger">
          <Section name="    Then: the size and capacity go up">
BDDTests.cpp" line="37">
              <Original>
                v.size() == 10
              </Original>
              <Expanded>
                10 == 10
              </Expanded>
            </Expression>
BDDTests.cpp" line="38">
              <Original>
                v.capacity() >= 10
              </Original>
              <Expanded>
                10 >= 10
              </Expanded>
            </Expression>
            <OverallResults successes="2" failures="0"/>
          </Section>
          <OverallResults successes="2" failures="0"/>
        </Section>
        <OverallResults successes="3" failures="0"/>
      </Section>
      <Section name="   Given: an empty vector">
BDDTests.cpp" line="32">
          <Original>
            v.size() == 0
          </Original>
          <Expanded>
            0 == 0
          </Expanded>
        </Expression>
        <Section name="    When: it is made larger">
          <OverallResults successes="0" failures="0"/>
        </Section>
        <OverallResults successes="1" failures="0"/>
      </Section>
      <Section name="   Given: an empty vector">
BDDTests.cpp" line="32">
          <Original>
            v.size() == 0
          </Original>
          <Expanded>
            0 == 0
          </Expanded>
        </Expression>
        <Section name="    When: we reserve more space">
          <Section name="    Then: The capacity is increased but the size remains the same">
BDDTests.cpp" line="53">
              <Original>
                v.capacity() >= 10
              </Original>
              <Expanded>
                10 >= 10
              </Expanded>
            </Expression>
BDDTests.cpp" line="54">
              <Original>
                v.size() == 0
              </Original>
              <Expanded>
                0 == 0
              </Expanded>
            </Expression>
            <OverallResults successes="2" failures="0"/>
          </Section>
          <OverallResults successes="2" failures="0"/>
        </Section>
        <OverallResults successes="3" failures="0"/>
      </Section>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="Scenario: This is a really long scenario name to see how the list command deals with wrapping">
      <Section name="   Given: A section name that is so long that it cannot fit in a single console width">
        <Section name="    When: The test headers are printed as part of the normal running of the scenario">
          <Section name="    Then: The, deliberately very long and overly verbose (you see what I did there?) section names must wrap, along with an indent">
            <OverallResults successes="1" failures="0"/>
          </Section>
          <OverallResults successes="1" failures="0"/>
        </Section>
        <OverallResults successes="1" failures="0"/>
      </Section>
      <OverallResult success="true"/>
    </TestCase>
    <TestCase name="cmdline">
      <Section name="process name">
CmdLineTests.cpp" line="64">
          <Original>
            config.processName == &quot;test&quot;
          </Original>
          <Expanded>
            &quot;test&quot; == &quot;test&quot;
          </Expanded>
        </Expression>
        <OverallResults successes="1" failures="0"/>
      </Section>
      <Section name="arg separated by spaces">
CmdLineTests.cpp" line="70">
          <Original>
            config.fileName == &quot;filename.ext&quot;
          </Original>
          <Expanded>
            &quot;filename.ext&quot; == &quot;filename.ext&quot;
          </Expanded>
        </Expression>
        <OverallResults successes="1" failures="0"/>
      </Section>
      <Section name="arg separated by colon">
CmdLineTests.cpp" line="76">
          <Original>
            config.fileName == &quot;filename.ext&quot;
          </Original>
          <Expanded>
            &quot;filename.ext&quot; == &quot;filename.ext&quot;
          </Expanded>
        </Expression>
        <OverallResults successes="1" failures="0"/>
      </Section>
      <Section name="arg separated by =">
CmdLineTests.cpp" line="82">
          <Original>
            config.fileName == &quot;filename.ext&quot;
          </Original>
          <Expanded>
            &quot;filename.ext&quot; == &quot;filename.ext&quot;
          </Expanded>
        </Expression>
        <OverallResults successes="1" failures="0"/>
      </Section>
      <Section name="long opt">
CmdLineTests.cpp" line="88">
          <Original>
            config.fileName == &quot;%stdout&quot;
          </Original>
          <Expanded>
            &quot;%stdout&quot; == &quot;%stdout&quot;
          </Expanded>
        </Expression>
        <OverallResults successes="1" failures="0"/>
      </Section>
      <Section name="a number">
CmdLineTests.cpp" line="99">
          <Original>
            config.number == 42
          </Original>
          <Expanded>
            42 == 42
          </Expanded>
        </Expression>
        <OverallResults successes="1" failures="0"/>
      </Section>
      <Section name="not a number">
CmdLineTests.cpp" line="103">
          <Original>
            parseInto( cli, argv, config )
          </Original>
          <Expanded>
            parseInto( cli, argv, config )
          </Expanded>
        </Expression>
CmdLineTests.cpp" line="105">
          <Original>
            config.number == 0
          </Original>
          <Expanded>
            0 == 0
          </Expanded>
        </Expression>
        <OverallResults successes="2" failures="0"/>
      </Section>
      <Section name="two parsers">
CmdLineTests.cpp" line="123">
          <Original>
            config1.number == 42
          </Original>
          <Expanded>
            42 == 42
          </Expanded>
        </Expression>
CmdLineTests.cpp" line="125">
          <Original>
            !unusedTokens.empty()
          </Original>
          <Expanded>
            !false
          </Expanded>
        </Expression>
CmdLineTests.cpp" line="127">
          <Original>
            config2.description == &quot;some text&quot;
          </Original>
          <Expanded>
            &quot;some text&quot; == &quot;some text&quot;
          </Expanded>
        </Expression>
        <OverallResults successes="3" failures="0"/>
      </Section>
      <Section name="methods">
        <Section name="in range">
CmdLineTests.cpp" line="140">
            <Original>
              config.index == 3
            </Original>
            <Expanded>
              3 == 3
            </Expanded>
          </Expression>
          <OverallResults successes="1" failures="0"/>
        </Section>
        <OverallResults successes="1" failures="0"/>
      </Section>
      <Section name="methods">
        <Section name="out of range">
CmdLineTests.cpp" line="145">
            <Original>
              parseInto( cli, argv, config )
            </Original>
            <Expanded>
              parseInto( cli, argv, config )
            </Expanded>
          </Expression>
          <OverallResults successes="1" failures="0"/>
        </Section>
        <OverallResults successes="1" failures="0"/>
      </Section>
      <Section name="methods">
        <OverallResults successes="0" failures="0"/>
      </Section>
      <Section name="flags">
        <Section name="set">
CmdLineTests.cpp" line="158">
            <Original>
              config.flag
            </Original>
            <Expanded>
              true
            </Expanded>
          </Expression>
          <OverallResults successes="1" failures="0"/>
        </Section>
        <OverallResults successes="1" failures="0"/>
      </Section>
      <Section name="flags">
        <Section name="not set">
CmdLineTests.cpp" line="164">
            <Original>
              config.flag == false
            </Original>
            <Expanded>
              false == false
            </Expanded>
          </Expression>
          <OverallResults successes="1" failures="0"/>
        </Section>
        <OverallResults successes="1" failures="0"/>
      </Section>
      <Section name="flags">
        <OverallResults successes="0" failures="0"/>
      </Section>
      <Section name="positional">
CmdLineTests.cpp" line="185">
          <Original>
            config.firstPos == &quot;1st&quot;
          </Original>
          <Expanded>
            &quot;1st&quot; == &quot;1st&quot;
          </Expanded>
        </Expression>
CmdLineTests.cpp" line="186">
          <Original>
            config.secondPos == &quot;2nd&quot;
          </Original>
          <Expanded>
            &quot;2nd&quot; == &quot;2nd&quot;
          </Expanded>
        </Expression>
CmdLineTests.cpp" line="187">
          <Original>
            config.unpositional == &quot;3rd&quot;
          </Original>
          <Expanded>
            &quot;3rd&quot; == &quot;3rd&quot;
          </Expanded>
        </Expression>
        <OverallResults successes="3" failures="0"/>
      </Section>
      <OverallResult success="true"/>
    </TestCase>
    <OverallResults successes="599" failures="106"/>
  </Group>
  <OverallResults successes="599" failures="106"/>
</Catch>
[Started testing: CatchSelfTest]
[Started group: '~dummy']

[Running: ./succeeding/Approx/simple]
ApproxTests.cpp:20: d == Approx( 1.23 ) succeeded for: 1.23 == Approx( 1.23 )
ApproxTests.cpp:21: d != Approx( 1.22 ) succeeded for: 1.23 != Approx( 1.22 )
ApproxTests.cpp:22: d != Approx( 1.24 ) succeeded for: 1.23 != Approx( 1.24 )
ApproxTests.cpp:24: Approx( d ) == 1.23 succeeded for: Approx( 1.23 ) == 1.23
ApproxTests.cpp:25: Approx( d ) != 1.22 succeeded for: Approx( 1.23 ) != 1.22
ApproxTests.cpp:26: Approx( d ) != 1.24 succeeded for: Approx( 1.23 ) != 1.24
[Finished: './succeeding/Approx/simple' All tests passed (6 assertions in 1 test case)]

[Running: ./succeeding/Approx/epsilon]
ApproxTests.cpp:38: d != Approx( 1.231 ) succeeded for: 1.23 != Approx( 1.231 )
ApproxTests.cpp:39: d == Approx( 1.231 ).epsilon( 0.1 ) succeeded for: 1.23 == Approx( 1.231 )
[Finished: './succeeding/Approx/epsilon' All tests passed (2 assertions in 1 test case)]

[Running: ./succeeding/Approx/float]
ApproxTests.cpp:49: 1.23f == Approx( 1.23f ) succeeded for: 1.23 == Approx( 1.23 )
ApproxTests.cpp:50: 0.0f == Approx( 0.0f ) succeeded for: 0 == Approx( 0 )
[Finished: './succeeding/Approx/float' All tests passed (2 assertions in 1 test case)]

[Running: ./succeeding/Approx/int]
ApproxTests.cpp:60: 1 == Approx( 1 ) succeeded
ApproxTests.cpp:61: 0 == Approx( 0 ) succeeded
[Finished: './succeeding/Approx/int' All tests passed (2 assertions in 1 test case)]

[Running: ./succeeding/Approx/mixed]
ApproxTests.cpp:75: 1.0f == Approx( 1 ) succeeded for: 1 == Approx( 1 )
ApproxTests.cpp:76: 0 == Approx( dZero) succeeded for: 0 == Approx( 0 )
ApproxTests.cpp:77: 0 == Approx( dSmall ).epsilon( 0.001 ) succeeded for: 0 == Approx( 1e-05 )
ApproxTests.cpp:78: 1.234f == Approx( dMedium ) succeeded for: 1.234 == Approx( 1.234 )
ApproxTests.cpp:79: dMedium == Approx( 1.234f ) succeeded for: 1.234 == Approx( 1.234 )
[Finished: './succeeding/Approx/mixed' All tests passed (5 assertions in 1 test case)]

[Running: ./succeeding/Approx/custom]
ApproxTests.cpp:93: d == approx( 1.23 ) succeeded for: 1.23 == Approx( 1.23 )
ApproxTests.cpp:94: d == approx( 1.22 ) succeeded for: 1.23 == Approx( 1.22 )
ApproxTests.cpp:95: d == approx( 1.24 ) succeeded for: 1.23 == Approx( 1.24 )
ApproxTests.cpp:96: d != approx( 1.25 ) succeeded for: 1.23 != Approx( 1.25 )
ApproxTests.cpp:98: approx( d ) == 1.23 succeeded for: Approx( 1.23 ) == 1.23
ApproxTests.cpp:99: approx( d ) == 1.22 succeeded for: Approx( 1.23 ) == 1.22
ApproxTests.cpp:100: approx( d ) == 1.24 succeeded for: Approx( 1.23 ) == 1.24
ApproxTests.cpp:101: approx( d ) != 1.25 succeeded for: Approx( 1.23 ) != 1.25
[Finished: './succeeding/Approx/custom' All tests passed (8 assertions in 1 test case)]

[Running: Approximate PI]
ApproxTests.cpp:110: divide( 22, 7 ) == Approx( 3.141 ).epsilon( 0.001 ) succeeded for: 3.142857142857143 == Approx( 3.141 )
ApproxTests.cpp:111: divide( 22, 7 ) != Approx( 3.141 ).epsilon( 0.0001 ) succeeded for: 3.142857142857143 != Approx( 3.141 )
[Finished: 'Approximate PI' All tests passed (2 assertions in 1 test case)]

[Running: ./succeeding/TestClass/succeedingCase]
ClassTests.cpp:24: s == "hello" succeeded for: "hello" == "hello"
[Finished: './succeeding/TestClass/succeedingCase' All tests passed (1 assertion in 1 test case)]

[Running: ./failing/TestClass/failingCase]
ClassTests.cpp:28: s == "world" failed for: "hello" == "world"
[Finished: './failing/TestClass/failingCase' 1 test case failed (1 assertion failed)]

[Running: ./succeeding/Fixture/succeedingCase]
ClassTests.cpp:47: m_a == 1 succeeded for: 1 == 1
[Finished: './succeeding/Fixture/succeedingCase' All tests passed (1 assertion in 1 test case)]

[Running: ./failing/Fixture/failingCase]
ClassTests.cpp:55: m_a == 2 failed for: 1 == 2
[Finished: './failing/Fixture/failingCase' 1 test case failed (1 assertion failed)]

[Running: ./succeeding/conditions/equality]
ConditionTests.cpp:55: data.int_seven == 7 succeeded for: 7 == 7
ConditionTests.cpp:56: data.float_nine_point_one == Approx( 9.1f ) succeeded for: 9.1 == Approx( 9.1 )
ConditionTests.cpp:57: data.double_pi == Approx( 3.1415926535 ) succeeded for: 3.1415926535 == Approx( 3.14159 )
ConditionTests.cpp:58: data.str_hello == "hello" succeeded for: "hello" == "hello"
ConditionTests.cpp:59: "hello" == data.str_hello succeeded for: "hello" == "hello"
ConditionTests.cpp:60: data.str_hello.size() == 5 succeeded for: 5 == 5
ConditionTests.cpp:63: x == Approx( 1.3 ) succeeded for: 1.3 == Approx( 1.3 )
[Finished: './succeeding/conditions/equality' All tests passed (7 assertions in 1 test case)]

[Running: ./failing/conditions/equality]
ConditionTests.cpp:71: data.int_seven == 6 failed for: 7 == 6
ConditionTests.cpp:72: data.int_seven == 8 failed for: 7 == 8
ConditionTests.cpp:73: data.int_seven == 0 failed for: 7 == 0
ConditionTests.cpp:74: data.float_nine_point_one == Approx( 9.11f ) failed for: 9.1 == Approx( 9.11 )
ConditionTests.cpp:75: data.float_nine_point_one == Approx( 9.0f ) failed for: 9.1 == Approx( 9 )
ConditionTests.cpp:76: data.float_nine_point_one == Approx( 1 ) failed for: 9.1 == Approx( 1 )
ConditionTests.cpp:77: data.float_nine_point_one == Approx( 0 ) failed for: 9.1 == Approx( 0 )
ConditionTests.cpp:78: data.double_pi == Approx( 3.1415 ) failed for: 3.1415926535 == Approx( 3.1415 )
ConditionTests.cpp:79: data.str_hello == "goodbye" failed for: "hello" == "goodbye"
ConditionTests.cpp:80: data.str_hello == "hell" failed for: "hello" == "hell"
ConditionTests.cpp:81: data.str_hello == "hello1" failed for: "hello" == "hello1"
ConditionTests.cpp:82: data.str_hello.size() == 6 failed for: 5 == 6
ConditionTests.cpp:85: x == Approx( 1.301 ) failed for: 1.3 == Approx( 1.301 )
[Finished: './failing/conditions/equality' 1 test case failed (All 13 assertions failed)]

[Running: ./succeeding/conditions/inequality]
ConditionTests.cpp:93: data.int_seven != 6 succeeded for: 7 != 6
ConditionTests.cpp:94: data.int_seven != 8 succeeded for: 7 != 8
ConditionTests.cpp:95: data.float_nine_point_one != Approx( 9.11f ) succeeded for: 9.1 != Approx( 9.11 )
ConditionTests.cpp:96: data.float_nine_point_one != Approx( 9.0f ) succeeded for: 9.1 != Approx( 9 )
ConditionTests.cpp:97: data.float_nine_point_one != Approx( 1 ) succeeded for: 9.1 != Approx( 1 )
ConditionTests.cpp:98: data.float_nine_point_one != Approx( 0 ) succeeded for: 9.1 != Approx( 0 )
ConditionTests.cpp:99: data.double_pi != Approx( 3.1415 ) succeeded for: 3.1415926535 != Approx( 3.1415 )
ConditionTests.cpp:100: data.str_hello != "goodbye" succeeded for: "hello" != "goodbye"
ConditionTests.cpp:101: data.str_hello != "hell" succeeded for: "hello" != "hell"
ConditionTests.cpp:102: data.str_hello != "hello1" succeeded for: "hello" != "hello1"
ConditionTests.cpp:103: data.str_hello.size() != 6 succeeded for: 5 != 6
[Finished: './succeeding/conditions/inequality' All tests passed (11 assertions in 1 test case)]

[Running: ./failing/conditions/inequality]
ConditionTests.cpp:111: data.int_seven != 7 failed for: 7 != 7
ConditionTests.cpp:112: data.float_nine_point_one != Approx( 9.1f ) failed for: 9.1 != Approx( 9.1 )
ConditionTests.cpp:113: data.double_pi != Approx( 3.1415926535 ) failed for: 3.1415926535 != Approx( 3.14159 )
ConditionTests.cpp:114: data.str_hello != "hello" failed for: "hello" != "hello"
ConditionTests.cpp:115: data.str_hello.size() != 5 failed for: 5 != 5
[Finished: './failing/conditions/inequality' 1 test case failed (All 5 assertions failed)]

[Running: ./succeeding/conditions/ordered]
ConditionTests.cpp:124: data.int_seven < 8 succeeded for: 7 < 8
ConditionTests.cpp:125: data.int_seven > 6 succeeded for: 7 > 6
ConditionTests.cpp:126: data.int_seven > 0 succeeded for: 7 > 0
ConditionTests.cpp:127: data.int_seven > -1 succeeded for: 7 > -1
ConditionTests.cpp:129: data.int_seven >= 7 succeeded for: 7 >= 7
ConditionTests.cpp:130: data.int_seven >= 6 succeeded for: 7 >= 6
ConditionTests.cpp:131: data.int_seven <= 7 succeeded for: 7 <= 7
ConditionTests.cpp:132: data.int_seven <= 8 succeeded for: 7 <= 8
ConditionTests.cpp:134: data.float_nine_point_one > 9 succeeded for: 9.1 > 9
ConditionTests.cpp:135: data.float_nine_point_one < 10 succeeded for: 9.1 < 10
ConditionTests.cpp:136: data.float_nine_point_one < 9.2 succeeded for: 9.1 < 9.199999999999999
ConditionTests.cpp:138: data.str_hello <= "hello" succeeded for: "hello" <= "hello"
ConditionTests.cpp:139: data.str_hello >= "hello" succeeded for: "hello" >= "hello"
ConditionTests.cpp:141: data.str_hello < "hellp" succeeded for: "hello" < "hellp"
ConditionTests.cpp:142: data.str_hello < "zebra" succeeded for: "hello" < "zebra"
ConditionTests.cpp:143: data.str_hello > "hellm" succeeded for: "hello" > "hellm"
ConditionTests.cpp:144: data.str_hello > "a" succeeded for: "hello" > "a"
[Finished: './succeeding/conditions/ordered' All tests passed (17 assertions in 1 test case)]

[Running: ./failing/conditions/ordered]
ConditionTests.cpp:152: data.int_seven > 7 failed for: 7 > 7
ConditionTests.cpp:153: data.int_seven < 7 failed for: 7 < 7
ConditionTests.cpp:154: data.int_seven > 8 failed for: 7 > 8
ConditionTests.cpp:155: data.int_seven < 6 failed for: 7 < 6
ConditionTests.cpp:156: data.int_seven < 0 failed for: 7 < 0
ConditionTests.cpp:157: data.int_seven < -1 failed for: 7 < -1
ConditionTests.cpp:159: data.int_seven >= 8 failed for: 7 >= 8
ConditionTests.cpp:160: data.int_seven <= 6 failed for: 7 <= 6
ConditionTests.cpp:162: data.float_nine_point_one < 9 failed for: 9.1 < 9
ConditionTests.cpp:163: data.float_nine_point_one > 10 failed for: 9.1 > 10
ConditionTests.cpp:164: data.float_nine_point_one > 9.2 failed for: 9.1 > 9.199999999999999
ConditionTests.cpp:166: data.str_hello > "hello" failed for: "hello" > "hello"
ConditionTests.cpp:167: data.str_hello < "hello" failed for: "hello" < "hello"
ConditionTests.cpp:168: data.str_hello > "hellp" failed for: "hello" > "hellp"
ConditionTests.cpp:169: data.str_hello > "z" failed for: "hello" > "z"
ConditionTests.cpp:170: data.str_hello < "hellm" failed for: "hello" < "hellm"
ConditionTests.cpp:171: data.str_hello < "a" failed for: "hello" < "a"
ConditionTests.cpp:173: data.str_hello >= "z" failed for: "hello" >= "z"
ConditionTests.cpp:174: data.str_hello <= "a" failed for: "hello" <= "a"
[Finished: './failing/conditions/ordered' 1 test case failed (All 19 assertions failed)]

[Running: ./succeeding/conditions/int literals]
ConditionTests.cpp:188: i == 1 succeeded for: 1 == 1
ConditionTests.cpp:189: ui == 2 succeeded for: 2 == 2
ConditionTests.cpp:190: l == 3 succeeded for: 3 == 3
ConditionTests.cpp:191: ul == 4 succeeded for: 4 == 4
ConditionTests.cpp:192: c == 5 succeeded for: 5 == 5
ConditionTests.cpp:193: uc == 6 succeeded for: 6 == 6
ConditionTests.cpp:195: 1 == i succeeded for: 1 == 1
ConditionTests.cpp:196: 2 == ui succeeded for: 2 == 2
ConditionTests.cpp:197: 3 == l succeeded for: 3 == 3
ConditionTests.cpp:198: 4 == ul succeeded for: 4 == 4
ConditionTests.cpp:199: 5 == c succeeded for: 5 == 5
ConditionTests.cpp:200: 6 == uc succeeded for: 6 == 6
ConditionTests.cpp:202: (std::numeric_limits<unsigned long>::max)() > ul succeeded for: 0x<hex digits> > 4
[Finished: './succeeding/conditions/int literals' All tests passed (13 assertions in 1 test case)]

[Running: ./succeeding/conditions//long_to_unsigned_x]
ConditionTests.cpp:226: long_var == unsigned_char_var succeeded for: 1 == 1
ConditionTests.cpp:227: long_var == unsigned_short_var succeeded for: 1 == 1
ConditionTests.cpp:228: long_var == unsigned_int_var succeeded for: 1 == 1
ConditionTests.cpp:229: long_var == unsigned_long_var succeeded for: 1 == 1
[Finished: './succeeding/conditions//long_to_unsigned_x' All tests passed (4 assertions in 1 test case)]

[Running: ./succeeding/conditions/const ints to int literal]
ConditionTests.cpp:240: unsigned_char_var == 1 succeeded for: 1 == 1
ConditionTests.cpp:241: unsigned_short_var == 1 succeeded for: 1 == 1
ConditionTests.cpp:242: unsigned_int_var == 1 succeeded for: 1 == 1
ConditionTests.cpp:243: unsigned_long_var == 1 succeeded for: 1 == 1
[Finished: './succeeding/conditions/const ints to int literal' All tests passed (4 assertions in 1 test case)]

[Running: ./succeeding/conditions/negative ints]
ConditionTests.cpp:249: ( -1 > 2u ) succeeded for: true
ConditionTests.cpp:250: -1 > 2u succeeded for: -1 > 2
ConditionTests.cpp:252: ( 2u < -1 ) succeeded for: true
ConditionTests.cpp:253: 2u < -1 succeeded for: 2 < -1
ConditionTests.cpp:256: ( minInt > 2u ) succeeded for: true
ConditionTests.cpp:257: minInt > 2u succeeded for: -2147483648 > 2
[Finished: './succeeding/conditions/negative ints' All tests passed (6 assertions in 1 test case)]

[Running: ./succeeding/conditions/computed ints]
ConditionTests.cpp:272: 54 == 6*9 succeeded for: 54 == 54
[Finished: './succeeding/conditions/computed ints' All tests passed (1 assertion in 1 test case)]

[Running: ./succeeding/conditions/ptr]
ConditionTests.cpp:288: p == __null succeeded for: __null == 0
ConditionTests.cpp:289: p == pNULL succeeded for: __null == __null
ConditionTests.cpp:294: p != __null succeeded for: 0x<hex digits> != 0
ConditionTests.cpp:297: cp != __null succeeded for: 0x<hex digits> != 0
ConditionTests.cpp:300: cpc != __null succeeded for: 0x<hex digits> != 0
ConditionTests.cpp:302: returnsNull() == __null succeeded for: {null string} == 0
ConditionTests.cpp:303: returnsConstNull() == __null succeeded for: {null string} == 0
ConditionTests.cpp:305: __null != p succeeded for: 0 != 0x<hex digits>
[Finished: './succeeding/conditions/ptr' All tests passed (8 assertions in 1 test case)]

[Running: ./succeeding/conditions/not]
ConditionTests.cpp:320: false == false succeeded
ConditionTests.cpp:321: true == true succeeded
ConditionTests.cpp:322: !false succeeded for: true
ConditionTests.cpp:323: !false succeeded
ConditionTests.cpp:325: !falseValue succeeded for: true
ConditionTests.cpp:326: !falseValue succeeded for: !false
ConditionTests.cpp:328: !(1 == 2) succeeded for: true
ConditionTests.cpp:329: !1 == 2 succeeded for: !(1 == 2)
[Finished: './succeeding/conditions/not' All tests passed (8 assertions in 1 test case)]

[Running: ./failing/conditions/not]
ConditionTests.cpp:337: false != false failed
ConditionTests.cpp:338: true != true failed
ConditionTests.cpp:339: !true failed for: false
ConditionTests.cpp:340: !true failed
ConditionTests.cpp:342: !trueValue failed for: false
ConditionTests.cpp:343: !trueValue failed for: !true
ConditionTests.cpp:345: !(1 == 1) failed for: false
ConditionTests.cpp:346: !1 == 1 failed for: !(1 == 1)
[Finished: './failing/conditions/not' 1 test case failed (All 8 assertions failed)]

[Running: ./succeeding/exceptions/explicit]
ExceptionTests.cpp:33: thisThrows() succeeded
ExceptionTests.cpp:34: thisDoesntThrow() succeeded
ExceptionTests.cpp:35: thisThrows() succeeded
[Finished: './succeeding/exceptions/explicit' All tests passed (3 assertions in 1 test case)]

[Running: ./failing/exceptions/explicit]
ExceptionTests.cpp:40: thisThrows() failed with unexpected exception with message: 'expected exception'
ExceptionTests.cpp:41: thisDoesntThrow() failed because no exception was thrown where one was expected
ExceptionTests.cpp:42: thisThrows() failed with unexpected exception with message: 'expected exception'
[Finished: './failing/exceptions/explicit' 1 test case failed (All 3 assertions failed)]

[Running: ./failing/exceptions/implicit]
ExceptionTests.cpp:45: Unexpected exception with message: 'unexpected exception'
[Finished: './failing/exceptions/implicit' 1 test case failed (1 assertion failed)]

[Running: ./failing/exceptions/implicit/2]
ExceptionTests.cpp:53: 1 == 1 succeeded
ExceptionTests.cpp:53: {Unknown expression after the reported line} failed with unexpected exception with message: 'unexpected exception'
[Finished: './failing/exceptions/implicit/2' 1 test case failed (1 of 2 assertions failed)]

[Running: ./failing/exceptions/implicit/3]

[Started section: 'section name']
ExceptionTests.cpp:59: Unexpected exception with message: 'unexpected exception'
[End of section: 'section name' 1 assertion failed]

[Finished: './failing/exceptions/implicit/3' 1 test case failed (1 assertion failed)]

[Running: ./failing/exceptions/implicit/4]
ExceptionTests.cpp:68: thisThrows() == 0 failed with unexpected exception with message: 'expected exception'
[Finished: './failing/exceptions/implicit/4' 1 test case failed (1 assertion failed)]

[Running: ./succeeding/exceptions/implicit]

No assertions in test case, './succeeding/exceptions/implicit'

[Finished: './succeeding/exceptions/implicit' 1 test case failed (1 assertion failed)]

[Running: ./failing/exceptions/custom]
ExceptionTests.cpp:108: Unexpected exception with message: 'custom exception'
[Finished: './failing/exceptions/custom' 1 test case failed (1 assertion failed)]

[Running: ./failing/exceptions/custom/nothrow]
ExceptionTests.cpp:121: throwCustom() failed with unexpected exception with message: 'custom exception - not std'
[Finished: './failing/exceptions/custom/nothrow' 1 test case failed (1 assertion failed)]

[Running: ./failing/exceptions/custom/throw]
ExceptionTests.cpp:126: throwCustom() failed with unexpected exception with message: 'custom exception - not std'
[Finished: './failing/exceptions/custom/throw' 1 test case failed (1 assertion failed)]

[Running: ./failing/exceptions/custom/double]
ExceptionTests.cpp:130: Unexpected exception with message: '3.14'
[Finished: './failing/exceptions/custom/double' 1 test case failed (1 assertion failed)]

[Running: ./succeeding/exceptions/notimplemented]
ExceptionTests.cpp:142: thisFunctionNotImplemented( 7 ) succeeded
[Finished: './succeeding/exceptions/notimplemented' All tests passed (1 assertion in 1 test case)]

[Running: ./succeeding/generators/1]
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 200 == 200
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 202 == 202
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 204 == 204
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 206 == 206
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 208 == 208
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 210 == 210
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 212 == 212
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 2 == 2
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 4 == 4
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 6 == 6
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 8 == 8
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 10 == 10
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 30 == 30
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 40 == 40
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 42 == 42
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
GeneratorTests.cpp:26: multiply( i, 2 ) == i*2 succeeded for: 72 == 72
GeneratorTests.cpp:27: multiply( j, 2 ) == j*2 succeeded for: 214 == 214
[Finished: './succeeding/generators/1' All tests passed (144 assertions in 1 test case)]

[Running: ./succeeding/generators/2]
GeneratorTests.cpp:40: i->first == i->second-1 succeeded for: 0 == 0
GeneratorTests.cpp:40: i->first == i->second-1 succeeded for: 2 == 2
[Finished: './succeeding/generators/2' All tests passed (2 assertions in 1 test case)]

[Running: ./succeeding/message]
MessageTests.cpp:13: [info: this is a message]
MessageTests.cpp:14: [warning: this is a warning]

No assertions in test case, './succeeding/message'

[Finished: './succeeding/message' 1 test case failed (1 assertion failed)]

[Running: ./succeeding/succeed]
MessageTests.cpp:18:  succeeded
[with message: this is a success]
[Finished: './succeeding/succeed' All tests passed (1 assertion in 1 test case)]

[Running: ./failing/message/info/1]
MessageTests.cpp:23: [info: this message should be logged]
MessageTests.cpp:24: [info: so should this]
MessageTests.cpp:26: a == 1 failed for: 2 == 1
[Finished: './failing/message/info/1' 1 test case failed (1 assertion failed)]

[Running: ./mixed/message/info/2]
MessageTests.cpp:33: a == 2 succeeded for: 2 == 2
MessageTests.cpp:35: [info: this message should be logged]
MessageTests.cpp:37: a == 1 failed for: 2 == 1
MessageTests.cpp:39: [info: and this, but later]
MessageTests.cpp:41: a == 0 failed for: 2 == 0
MessageTests.cpp:45: a == 2 succeeded for: 2 == 2
[Finished: './mixed/message/info/2' 1 test case failed (2 of 4 assertions failed)]

[Running: ./failing/message/fail]
MessageTests.cpp:51: failed with message: 'This is a failure'
[Finished: './failing/message/fail' 1 test case failed (1 assertion failed)]

[Running: ./failing/message/sections]
[Started section: 'one']
MessageTests.cpp:58: failed with message: 'Message from section one'
[End of section: 'one' 1 assertion failed]

[Started section: 'two']
MessageTests.cpp:63: failed with message: 'Message from section two'
[End of section: 'two' 1 assertion failed]

[Finished: './failing/message/sections' 1 test case failed (All 2 assertions failed)]
Message from section one

[Running: ./succeeding/message/sections/stdout]
[Started section: 'one']

No assertions in section, 'one'

[End of section: 'one' 1 assertion failed]

Message from section two
[Started section: 'two']

No assertions in section, 'two'

[End of section: 'two' 1 assertion failed]

[Finished: './succeeding/message/sections/stdout' 1 test case failed (All 2 assertions failed)]

[Running: ./mixed/message/scoped]
MessageTests.cpp:86: i < 10 succeeded for: 0 < 10
MessageTests.cpp:86: i < 10 succeeded for: 1 < 10
MessageTests.cpp:86: i < 10 succeeded for: 2 < 10
MessageTests.cpp:86: i < 10 succeeded for: 3 < 10
MessageTests.cpp:86: i < 10 succeeded for: 4 < 10
MessageTests.cpp:86: i < 10 succeeded for: 5 < 10
MessageTests.cpp:86: i < 10 succeeded for: 6 < 10
MessageTests.cpp:86: i < 10 succeeded for: 7 < 10
MessageTests.cpp:86: i < 10 succeeded for: 8 < 10
MessageTests.cpp:86: i < 10 succeeded for: 9 < 10
MessageTests.cpp:84: [info: current counter 10]
MessageTests.cpp:85: [info: i := 10]
MessageTests.cpp:86: i < 10 failed for: 10 < 10
[Finished: './mixed/message/scoped' 1 test case failed (1 of 11 assertions failed)]

[Running: ./succeeding/nofail]
MessageTests.cpp:92: 1 == 2 failed - but was ok

No assertions in test case, './succeeding/nofail'

[Finished: './succeeding/nofail' 1 test case failed (1 assertion failed)]

[Running: just info]

No assertions in test case, 'just info'

[Finished: 'just info' 1 test case failed (1 assertion failed)]

[Running: just failure]
MessageTests.cpp:101: failed with message: 'Previous info should not be seen'
[Finished: 'just failure' 1 test case failed (1 assertion failed)]

[Running: ./succeeding/Misc/Sections]
[Started section: 's1']
MiscTests.cpp:21: a != b succeeded for: 1 != 2
MiscTests.cpp:22: b != a succeeded for: 2 != 1
[End of section: 's1' All 2 assertions passed]

[Started section: 's2']
MiscTests.cpp:27: a != b succeeded for: 1 != 2
[End of section: 's2' 1 assertion passed]

[Finished: './succeeding/Misc/Sections' All tests passed (3 assertions in 1 test case)]

[Running: ./succeeding/Misc/Sections/nested]
[Started section: 's1']
MiscTests.cpp:38: a != b succeeded for: 1 != 2
MiscTests.cpp:39: b != a succeeded for: 2 != 1
[Started section: 's2']
MiscTests.cpp:43: a != b succeeded for: 1 != 2
[End of section: 's2' 1 assertion passed]

[End of section: 's1' All 3 assertions passed]

[Finished: './succeeding/Misc/Sections/nested' All tests passed (3 assertions in 1 test case)]

[Running: ./mixed/Misc/Sections/nested2]
[Started section: 's1']
[Started section: 's2']
MiscTests.cpp:57: a == b failed for: 1 == 2
[End of section: 's2' 1 assertion failed]

[End of section: 's1' 1 assertion failed]

[Started section: 's1']
[Started section: 's3']
MiscTests.cpp:62: a != b succeeded for: 1 != 2
[End of section: 's3' 1 assertion passed]

[End of section: 's1' 1 assertion passed]

[Started section: 's1']
[Started section: 's4']
MiscTests.cpp:66: a < b succeeded for: 1 < 2
[End of section: 's4' 1 assertion passed]

[End of section: 's1' 1 assertion passed]

[Finished: './mixed/Misc/Sections/nested2' 1 test case failed (1 of 3 assertions failed)]

[Running: ./Sections/nested/a/b]
[Started section: 'c']
[Started section: 'd (leaf)']

No assertions in section, 'd (leaf)'

[End of section: 'd (leaf)' 1 assertion failed]

[End of section: 'c' 1 assertion failed]

[Started section: 'c']
[Started section: 'e (leaf)']

No assertions in section, 'e (leaf)'

[End of section: 'e (leaf)' 1 assertion failed]

[End of section: 'c' 1 assertion failed]

[Started section: 'f (leaf)']

No assertions in section, 'f (leaf)'

[End of section: 'f (leaf)' 1 assertion failed]

[Finished: './Sections/nested/a/b' 1 test case failed (All 3 assertions failed)]

[Running: ./mixed/Misc/Sections/loops]
[Started section: 's1']
MiscTests.cpp:99: b > a failed for: 0 > 1
[End of section: 's1' 1 assertion failed]

[Finished: './mixed/Misc/Sections/loops' 1 test case failed (1 assertion failed)]

[Running: ./mixed/Misc/loops]
MiscTests.cpp:110: [info: Testing if fib[0] (1) is even]
MiscTests.cpp:111: ( fib[i] % 2 ) == 0 failed for: 1 == 0
MiscTests.cpp:110: [info: Testing if fib[1] (1) is even]
MiscTests.cpp:111: ( fib[i] % 2 ) == 0 failed for: 1 == 0
MiscTests.cpp:111: ( fib[i] % 2 ) == 0 succeeded for: 0 == 0
MiscTests.cpp:110: [info: Testing if fib[3] (3) is even]
MiscTests.cpp:111: ( fib[i] % 2 ) == 0 failed for: 1 == 0
MiscTests.cpp:110: [info: Testing if fib[4] (5) is even]
MiscTests.cpp:111: ( fib[i] % 2 ) == 0 failed for: 1 == 0
MiscTests.cpp:111: ( fib[i] % 2 ) == 0 succeeded for: 0 == 0
MiscTests.cpp:110: [info: Testing if fib[6] (13) is even]
MiscTests.cpp:111: ( fib[i] % 2 ) == 0 failed for: 1 == 0
MiscTests.cpp:110: [info: Testing if fib[7] (21) is even]
MiscTests.cpp:111: ( fib[i] % 2 ) == 0 failed for: 1 == 0
[Finished: './mixed/Misc/loops' 1 test case failed (6 of 8 assertions failed)]
Some information
An error

[Running: ./succeeding/Misc/stdout,stderr]

No assertions in test case, './succeeding/Misc/stdout,stderr'

[Finished: './succeeding/Misc/stdout,stderr' 1 test case failed (1 assertion failed)]

[Running: ./succeeding/Misc/null strings]
MiscTests.cpp:129: makeString( false ) != static_cast<char*>(__null) succeeded for: "valid string" != {null string}
MiscTests.cpp:130: makeString( true ) == static_cast<char*>(__null) succeeded for: {null string} == {null string}
[Finished: './succeeding/Misc/null strings' All tests passed (2 assertions in 1 test case)]

[Running: ./failing/info]
MiscTests.cpp:135: [info: hi]
MiscTests.cpp:137: [info: i := 7]
MiscTests.cpp:138: false failed
[Finished: './failing/info' 1 test case failed (1 assertion failed)]

[Running: ./succeeding/checkedif]
MiscTests.cpp:143: flag succeeded for: true
MiscTests.cpp:151: testCheckedIf( true ) succeeded for: true
[Finished: './succeeding/checkedif' All tests passed (2 assertions in 1 test case)]

[Running: ./failing/checkedif]
MiscTests.cpp:143: flag failed for: false
MiscTests.cpp:156: testCheckedIf( false ) failed for: false
[Finished: './failing/checkedif' 1 test case failed (All 2 assertions failed)]

[Running: ./succeeding/checkedelse]
MiscTests.cpp:161: flag succeeded for: true
MiscTests.cpp:169: testCheckedElse( true ) succeeded for: true
[Finished: './succeeding/checkedelse' All tests passed (2 assertions in 1 test case)]

[Running: ./failing/checkedelse]
MiscTests.cpp:161: flag failed for: false
MiscTests.cpp:174: testCheckedElse( false ) failed for: false
[Finished: './failing/checkedelse' 1 test case failed (All 2 assertions failed)]

[Running: ./misc/xmlentitycheck]
[Started section: 'embedded xml']

No assertions in section, 'embedded xml'

[End of section: 'embedded xml' 1 assertion failed]

[Started section: 'encoded chars']

No assertions in section, 'encoded chars'

[End of section: 'encoded chars' 1 assertion failed]

[Finished: './misc/xmlentitycheck' 1 test case failed (All 2 assertions failed)]

[Running: ./manual/onechar]
MiscTests.cpp:191: [info: 3]
MiscTests.cpp:192: false failed
[Finished: './manual/onechar' 1 test case failed (1 assertion failed)]

[Running: ./succeeding/atomic if]
MiscTests.cpp:202: x == 0 succeeded for: 0 == 0
[Finished: './succeeding/atomic if' All tests passed (1 assertion in 1 test case)]

[Running: ./succeeding/matchers]
MiscTests.cpp:212: testStringForMatching() Contains( "string" ) succeeded for:
	"this string contains 'abc' as a substring" contains: "string"
MiscTests.cpp:213: testStringForMatching() Contains( "abc" ) succeeded for:
	"this string contains 'abc' as a substring" contains: "abc"
MiscTests.cpp:215: testStringForMatching() StartsWith( "this" ) succeeded for:
	"this string contains 'abc' as a substring" starts with: "this"
MiscTests.cpp:216: testStringForMatching() EndsWith( "substring" ) succeeded for:
	"this string contains 'abc' as a substring" ends with: "substring"
[Finished: './succeeding/matchers' All tests passed (4 assertions in 1 test case)]

[Running: ./failing/matchers/Contains]
MiscTests.cpp:221: testStringForMatching() Contains( "not there" ) failed for:
	"this string contains 'abc' as a substring" contains: "not there"
[Finished: './failing/matchers/Contains' 1 test case failed (1 assertion failed)]

[Running: ./failing/matchers/StartsWith]
MiscTests.cpp:226: testStringForMatching() StartsWith( "string" ) failed for:
	"this string contains 'abc' as a substring" starts with: "string"
[Finished: './failing/matchers/StartsWith' 1 test case failed (1 assertion failed)]

[Running: ./failing/matchers/EndsWith]
MiscTests.cpp:231: testStringForMatching() EndsWith( "this" ) failed for:
	"this string contains 'abc' as a substring" ends with: "this"
[Finished: './failing/matchers/EndsWith' 1 test case failed (1 assertion failed)]

[Running: ./failing/matchers/Equals]
MiscTests.cpp:236: testStringForMatching() Equals( "something else" ) failed for:
	"this string contains 'abc' as a substring" equals: "something else"
[Finished: './failing/matchers/Equals' 1 test case failed (1 assertion failed)]

[Running: string]
MiscTests.cpp:240: "" Equals(__null) succeeded for: "" equals: ""
[Finished: 'string' All tests passed (1 assertion in 1 test case)]

[Running: ./succeeding/matchers/AllOf]
MiscTests.cpp:244: testStringForMatching() AllOf( Catch::Contains( "string" ), Catch::Contains( "abc" ) ) succeeded for:
"this string contains 'abc' as a substring" ( contains: "string" and contains: "abc" )
[Finished: './succeeding/matchers/AllOf' All tests passed (1 assertion in 1 test case)]

[Running: ./succeeding/matchers/AnyOf]
MiscTests.cpp:248: testStringForMatching() AnyOf( Catch::Contains( "string" ), Catch::Contains( "not there" ) ) succeeded for:
"this string contains 'abc' as a substring" ( contains: "string" or contains: "not there" )
MiscTests.cpp:249: testStringForMatching() AnyOf( Catch::Contains( "not there" ), Catch::Contains( "string" ) ) succeeded for:
"this string contains 'abc' as a substring" ( contains: "not there" or contains: "string" )
[Finished: './succeeding/matchers/AnyOf' All tests passed (2 assertions in 1 test case)]

[Running: ./succeeding/matchers/Equals]
MiscTests.cpp:254: 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"
[Finished: './succeeding/matchers/Equals' All tests passed (1 assertion in 1 test case)]

[Running: Factorials are computed]
MiscTests.cpp:264: Factorial(0) == 1 succeeded for: 1 == 1
MiscTests.cpp:265: Factorial(1) == 1 succeeded for: 1 == 1
MiscTests.cpp:266: Factorial(2) == 2 succeeded for: 2 == 2
MiscTests.cpp:267: Factorial(3) == 6 succeeded for: 6 == 6
MiscTests.cpp:268: Factorial(10) == 3628800 succeeded for: 0x<hex digits> == 3628800
[Finished: 'Factorials are computed' All tests passed (5 assertions in 1 test case)]

[Running: empty]

No assertions in test case, 'empty'

[Finished: 'empty' 1 test case failed (1 assertion failed)]

[Running: Nice descriptive name]
MiscTests.cpp:277: [warning: This one ran]

No assertions in test case, 'Nice descriptive name'

[Finished: 'Nice descriptive name' 1 test case failed (1 assertion failed)]

[Running: first tag]

No assertions in test case, 'first tag'

[Finished: 'first tag' 1 test case failed (1 assertion failed)]

[Running: second tag]

No assertions in test case, 'second tag'

[Finished: 'second tag' 1 test case failed (1 assertion failed)]

[Running: vectors can be sized and resized]
MiscTests.cpp:299: v.size() == 5 succeeded for: 5 == 5
MiscTests.cpp:300: v.capacity() >= 5 succeeded for: 5 >= 5
[Started section: 'resizing bigger changes size and capacity']
MiscTests.cpp:305: v.size() == 10 succeeded for: 10 == 10
MiscTests.cpp:306: v.capacity() >= 10 succeeded for: 10 >= 10
[End of section: 'resizing bigger changes size and capacity' All 2 assertions passed]

MiscTests.cpp:299: v.size() == 5 succeeded for: 5 == 5
MiscTests.cpp:300: v.capacity() >= 5 succeeded for: 5 >= 5
[Started section: 'resizing smaller changes size but not capacity']
MiscTests.cpp:311: v.size() == 0 succeeded for: 0 == 0
MiscTests.cpp:312: v.capacity() >= 5 succeeded for: 5 >= 5
[Started section: 'We can use the 'swap trick' to reset the capacity']
MiscTests.cpp:318: v.capacity() == 0 succeeded for: 0 == 0
[End of section: 'We can use the 'swap trick' to reset the capacity' 1 assertion passed]

[End of section: 'resizing smaller changes size but not capacity' All 3 assertions passed]

MiscTests.cpp:299: v.size() == 5 succeeded for: 5 == 5
MiscTests.cpp:300: v.capacity() >= 5 succeeded for: 5 >= 5
[Started section: 'resizing smaller changes size but not capacity']
MiscTests.cpp:311: v.size() == 0 succeeded for: 0 == 0
MiscTests.cpp:312: v.capacity() >= 5 succeeded for: 5 >= 5
[End of section: 'resizing smaller changes size but not capacity' All 2 assertions passed]

MiscTests.cpp:299: v.size() == 5 succeeded for: 5 == 5
MiscTests.cpp:300: v.capacity() >= 5 succeeded for: 5 >= 5
[Started section: 'reserving bigger changes capacity but not size']
MiscTests.cpp:324: v.size() == 5 succeeded for: 5 == 5
MiscTests.cpp:325: v.capacity() >= 10 succeeded for: 10 >= 10
[End of section: 'reserving bigger changes capacity but not size' All 2 assertions passed]

MiscTests.cpp:299: v.size() == 5 succeeded for: 5 == 5
MiscTests.cpp:300: v.capacity() >= 5 succeeded for: 5 >= 5
[Started section: 'reserving smaller does not change size or capacity']
MiscTests.cpp:330: v.size() == 5 succeeded for: 5 == 5
MiscTests.cpp:331: v.capacity() >= 5 succeeded for: 5 >= 5
[End of section: 'reserving smaller does not change size or capacity' All 2 assertions passed]

[Finished: 'vectors can be sized and resized' All tests passed (21 assertions in 1 test case)]

[Running: selftest/main]
[Started section: 'selftest/expected result']
[Started section: 'selftest/expected result/failing tests']
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
catch_self_test.hpp:120:  succeeded
[with message: Tests failed, as expected]
[End of section: 'selftest/expected result/failing tests' All 27 assertions passed]

[End of section: 'selftest/expected result' All 27 assertions passed]

[Started section: 'selftest/expected result']
[Started section: 'selftest/expected result/succeeding tests']
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
Message from section one
Message from section two
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
Some information
An error
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
catch_self_test.hpp:109:  succeeded
[with message: Tests passed, as expected]
[End of section: 'selftest/expected result/succeeding tests' All 46 assertions passed]

[End of section: 'selftest/expected result' All 46 assertions passed]

Message from section one
Message from section two
Some information
An error
[Started section: 'selftest/test counts']
[Started section: 'selftest/test counts/succeeding tests']
TestMain.cpp:41: totals.assertions.passed == 296 succeeded for: 296 == 296
TestMain.cpp:42: totals.assertions.failed == 0 succeeded for: 0 == 0
[End of section: 'selftest/test counts/succeeding tests' All 2 assertions passed]

[End of section: 'selftest/test counts' All 2 assertions passed]

[Started section: 'selftest/test counts']
[Started section: 'selftest/test counts/failing tests']
TestMain.cpp:48: totals.assertions.passed == 1 succeeded for: 1 == 1
TestMain.cpp:49: totals.assertions.failed == 74 succeeded for: 74 == 74
[End of section: 'selftest/test counts/failing tests' All 2 assertions passed]

[End of section: 'selftest/test counts' All 2 assertions passed]

[Finished: 'selftest/main' All tests passed (77 assertions in 1 test case)]

[Running: meta/Misc/Sections]
TestMain.cpp:58: totals.assertions.passed == 2 succeeded for: 2 == 2
TestMain.cpp:59: totals.assertions.failed == 1 succeeded for: 1 == 1
[Finished: 'meta/Misc/Sections' All tests passed (2 assertions in 1 test case)]

[Running: Process can be configured on command line]
[Started section: 'default - no arguments']
TestMain.cpp:98: parseIntoConfig( argv, config ) succeeded
TestMain.cpp:100: config.shouldDebugBreak == false succeeded for: false == false
TestMain.cpp:101: config.abortAfter == -1 succeeded for: -1 == -1
TestMain.cpp:102: config.noThrow == false succeeded for: false == false
TestMain.cpp:103: config.reporterName.empty() succeeded for: true
[End of section: 'default - no arguments' All 5 assertions passed]

[Started section: 'test lists']
[Started section: '1 test']
TestMain.cpp:109: parseIntoConfig( argv, config ) succeeded
TestMain.cpp:112: cfg.filters().size() == 1 succeeded for: 1 == 1
TestMain.cpp:113: cfg.filters()[0].shouldInclude( fakeTestCase( "notIncluded" ) ) == false succeeded for: false == false
TestMain.cpp:114: cfg.filters()[0].shouldInclude( fakeTestCase( "test1" ) ) succeeded for: true
[End of section: '1 test' All 4 assertions passed]

[End of section: 'test lists' All 4 assertions passed]

[Started section: 'test lists']
[Started section: 'Specify one test case exclusion using exclude:']
TestMain.cpp:118: parseIntoConfig( argv, config ) succeeded
TestMain.cpp:121: cfg.filters().size() == 1 succeeded for: 1 == 1
TestMain.cpp:122: cfg.filters()[0].shouldInclude( fakeTestCase( "test1" ) ) == false succeeded for: false == false
TestMain.cpp:123: cfg.filters()[0].shouldInclude( fakeTestCase( "alwaysIncluded" ) ) succeeded for: true
[End of section: 'Specify one test case exclusion using exclude:' All 4 assertions passed]

[End of section: 'test lists' All 4 assertions passed]

[Started section: 'test lists']
[Started section: 'Specify one test case exclusion using ~']
TestMain.cpp:128: parseIntoConfig( argv, config ) succeeded
TestMain.cpp:131: cfg.filters().size() == 1 succeeded for: 1 == 1
TestMain.cpp:132: cfg.filters()[0].shouldInclude( fakeTestCase( "test1" ) ) == false succeeded for: false == false
TestMain.cpp:133: cfg.filters()[0].shouldInclude( fakeTestCase( "alwaysIncluded" ) ) succeeded for: true
[End of section: 'Specify one test case exclusion using ~' All 4 assertions passed]

[End of section: 'test lists' All 4 assertions passed]

[Started section: 'test lists']
[Started section: 'Specify two test cases using -t']
TestMain.cpp:138: parseIntoConfig( argv, config ) succeeded
TestMain.cpp:141: cfg.filters().size() == 1 succeeded for: 1 == 1
TestMain.cpp:142: cfg.filters()[0].shouldInclude( fakeTestCase( "notIncluded" ) ) == false succeeded for: false == false
TestMain.cpp:143: cfg.filters()[0].shouldInclude( fakeTestCase( "test1" ) ) succeeded for: true
TestMain.cpp:144: cfg.filters()[0].shouldInclude( fakeTestCase( "test2" ) ) succeeded for: true
[End of section: 'Specify two test cases using -t' All 5 assertions passed]

[End of section: 'test lists' All 5 assertions passed]

[Started section: 'reporter']
[Started section: '-r/console']
TestMain.cpp:151: parseIntoConfig( argv, config ) succeeded
TestMain.cpp:153: config.reporterName == "console" succeeded for: "console" == "console"
[End of section: '-r/console' All 2 assertions passed]

[End of section: 'reporter' All 2 assertions passed]

[Started section: 'reporter']
[Started section: '-r/xml']
TestMain.cpp:157: parseIntoConfig( argv, config ) succeeded
TestMain.cpp:159: config.reporterName == "xml" succeeded for: "xml" == "xml"
[End of section: '-r/xml' All 2 assertions passed]

[End of section: 'reporter' All 2 assertions passed]

[Started section: 'reporter']
[Started section: '--reporter/junit']
TestMain.cpp:163: parseIntoConfig( argv, config ) succeeded
TestMain.cpp:165: config.reporterName == "junit" succeeded for: "junit" == "junit"
[End of section: '--reporter/junit' All 2 assertions passed]

[End of section: 'reporter' All 2 assertions passed]

[Started section: 'debugger']
[Started section: '-b']
TestMain.cpp:172: parseIntoConfig( argv, config ) succeeded
TestMain.cpp:174: config.shouldDebugBreak == true succeeded for: true == true
[End of section: '-b' All 2 assertions passed]

[End of section: 'debugger' All 2 assertions passed]

[Started section: 'debugger']
[Started section: '--break']
TestMain.cpp:178: parseIntoConfig( argv, config ) succeeded
TestMain.cpp:180: config.shouldDebugBreak succeeded for: true
[End of section: '--break' All 2 assertions passed]

[End of section: 'debugger' All 2 assertions passed]

[Started section: 'abort']
[Started section: '-a aborts after first failure']
TestMain.cpp:187: parseIntoConfig( argv, config ) succeeded
TestMain.cpp:189: config.abortAfter == 1 succeeded for: 1 == 1
[End of section: '-a aborts after first failure' All 2 assertions passed]

[End of section: 'abort' All 2 assertions passed]

[Started section: 'abort']
[Started section: '-x 2 aborts after two failures']
TestMain.cpp:193: parseIntoConfig( argv, config ) succeeded
TestMain.cpp:195: config.abortAfter == 2 succeeded for: 2 == 2
[End of section: '-x 2 aborts after two failures' All 2 assertions passed]

[End of section: 'abort' All 2 assertions passed]

[Started section: 'abort']
[Started section: '-x must be greater than zero']
TestMain.cpp:199: parseIntoConfigAndReturnError( argv, config ) Contains( "greater than zero" ) succeeded for:
"Value after -x or --abortAfter must be greater than zero while parsing: (-x, --abortx <number of failures>)" contains: "greater than zero"
[End of section: '-x must be greater than zero' 1 assertion passed]

[End of section: 'abort' 1 assertion passed]

[Started section: 'abort']
[Started section: '-x must be numeric']
TestMain.cpp:203: parseIntoConfigAndReturnError( argv, config ) Contains( "-x" ) succeeded for:
"Unable to convert oops to destination type while parsing: (-x, --abortx <number of failures>)" contains: "-x"
[End of section: '-x must be numeric' 1 assertion passed]

[End of section: 'abort' 1 assertion passed]

[Started section: 'nothrow']
[Started section: '-e']
TestMain.cpp:210: parseIntoConfig( argv, config ) succeeded
TestMain.cpp:212: config.noThrow == true succeeded for: true == true
[End of section: '-e' All 2 assertions passed]

[End of section: 'nothrow' All 2 assertions passed]

[Started section: 'nothrow']
[Started section: '--nothrow']
TestMain.cpp:216: parseIntoConfig( argv, config ) succeeded
TestMain.cpp:218: config.noThrow == true succeeded for: true == true
[End of section: '--nothrow' All 2 assertions passed]

[End of section: 'nothrow' All 2 assertions passed]

[Started section: 'output filename']
[Started section: '-o filename']
TestMain.cpp:225: parseIntoConfig( argv, config ) succeeded
TestMain.cpp:227: config.outputFilename == "filename.ext" succeeded for: "filename.ext" == "filename.ext"
[End of section: '-o filename' All 2 assertions passed]

[End of section: 'output filename' All 2 assertions passed]

[Started section: 'output filename']
[Started section: '--out']
TestMain.cpp:231: parseIntoConfig( argv, config ) succeeded
TestMain.cpp:233: config.outputFilename == "filename.ext" succeeded for: "filename.ext" == "filename.ext"
[End of section: '--out' All 2 assertions passed]

[End of section: 'output filename' All 2 assertions passed]

[Started section: 'combinations']
[Started section: 'Single character flags can be combined']
TestMain.cpp:240: parseIntoConfig( argv, config ) succeeded
TestMain.cpp:242: config.abortAfter == 1 succeeded for: 1 == 1
TestMain.cpp:243: config.shouldDebugBreak succeeded for: true
TestMain.cpp:244: config.noThrow == true succeeded for: true == true
[End of section: 'Single character flags can be combined' All 4 assertions passed]

[End of section: 'combinations' All 4 assertions passed]

[Finished: 'Process can be configured on command line' All tests passed (50 assertions in 1 test case)]

[Running: selftest/test filter]
TestMain.cpp:253: matchAny.shouldInclude( fakeTestCase( "any" ) ) succeeded for: true
TestMain.cpp:254: matchNone.shouldInclude( fakeTestCase( "any" ) ) == false succeeded for: false == false
TestMain.cpp:259: matchHidden.shouldInclude( fakeTestCase( "any" ) ) == false succeeded for: false == false
TestMain.cpp:260: matchNonHidden.shouldInclude( fakeTestCase( "any" ) ) succeeded for: true
TestMain.cpp:262: matchHidden.shouldInclude( fakeTestCase( "./any" ) ) succeeded for: true
TestMain.cpp:263: matchNonHidden.shouldInclude( fakeTestCase( "./any" ) ) == false succeeded for: false == false
[Finished: 'selftest/test filter' All tests passed (6 assertions in 1 test case)]

[Running: selftest/test filters]
TestMain.cpp:274: matchHidden.shouldInclude( fakeTestCase( "./something" ) ) succeeded for: true
TestMain.cpp:276: filters.shouldInclude( fakeTestCase( "any" ) ) == false succeeded for: false == false
TestMain.cpp:277: filters.shouldInclude( fakeTestCase( "./something" ) ) succeeded for: true
TestMain.cpp:278: filters.shouldInclude( fakeTestCase( "./anything" ) ) == false succeeded for: false == false
[Finished: 'selftest/test filters' All tests passed (4 assertions in 1 test case)]

[Running: selftest/filter/prefix wildcard]
TestMain.cpp:284: matchBadgers.shouldInclude( fakeTestCase( "big badger" ) ) succeeded for: true
TestMain.cpp:285: matchBadgers.shouldInclude( fakeTestCase( "little badgers" ) ) == false succeeded for: false == false
[Finished: 'selftest/filter/prefix wildcard' All tests passed (2 assertions in 1 test case)]

[Running: selftest/filter/wildcard at both ends]
TestMain.cpp:290: matchBadgers.shouldInclude( fakeTestCase( "big badger" ) ) succeeded for: true
TestMain.cpp:291: matchBadgers.shouldInclude( fakeTestCase( "little badgers" ) ) succeeded for: true
TestMain.cpp:292: matchBadgers.shouldInclude( fakeTestCase( "badgers are big" ) ) succeeded for: true
TestMain.cpp:293: matchBadgers.shouldInclude( fakeTestCase( "hedgehogs" ) ) == false succeeded for: false == false
[Finished: 'selftest/filter/wildcard at both ends' All tests passed (4 assertions in 1 test case)]

[Running: selftest/tags]
[Started section: 'one tag']
TestMain.cpp:313: oneTag.getTestCaseInfo().description == "" succeeded for: "" == ""
TestMain.cpp:314: oneTag.hasTag( "one" ) succeeded for: true
TestMain.cpp:315: oneTag.getTags().size() == 1 succeeded for: 1 == 1
TestMain.cpp:317: oneTag.matchesTags( p1 ) == true succeeded for: true == true
TestMain.cpp:318: oneTag.matchesTags( p2 ) == true succeeded for: true == true
TestMain.cpp:319: oneTag.matchesTags( p3 ) == false succeeded for: false == false
TestMain.cpp:320: oneTag.matchesTags( p4 ) == false succeeded for: false == false
TestMain.cpp:321: oneTag.matchesTags( p5 ) == false succeeded for: false == false
[End of section: 'one tag' All 8 assertions passed]

[Started section: 'two tags']
TestMain.cpp:327: twoTags.getTestCaseInfo().description == "" succeeded for: "" == ""
TestMain.cpp:328: twoTags.hasTag( "one" ) succeeded for: true
TestMain.cpp:329: twoTags.hasTag( "two" ) succeeded for: true
TestMain.cpp:330: twoTags.hasTag( "Two" ) succeeded for: true
TestMain.cpp:331: twoTags.hasTag( "three" ) == false succeeded for: false == false
TestMain.cpp:332: twoTags.getTags().size() == 2 succeeded for: 2 == 2
TestMain.cpp:334: twoTags.matchesTags( p1 ) == true succeeded for: true == true
TestMain.cpp:335: twoTags.matchesTags( p2 ) == true succeeded for: true == true
TestMain.cpp:336: twoTags.matchesTags( p3 ) == true succeeded for: true == true
TestMain.cpp:337: twoTags.matchesTags( p4 ) == true succeeded for: true == true
TestMain.cpp:338: twoTags.matchesTags( p5 ) == true succeeded for: true == true
[End of section: 'two tags' All 11 assertions passed]

[Started section: 'one tag with characters either side']
TestMain.cpp:344: oneTagWithExtras.getTestCaseInfo().description == "1234" succeeded for: "1234" == "1234"
TestMain.cpp:345: oneTagWithExtras.hasTag( "one" ) succeeded for: true
TestMain.cpp:346: oneTagWithExtras.hasTag( "two" ) == false succeeded for: false == false
TestMain.cpp:347: oneTagWithExtras.getTags().size() == 1 succeeded for: 1 == 1
[End of section: 'one tag with characters either side' All 4 assertions passed]

[Started section: 'start of a tag, but not closed']
TestMain.cpp:354: oneTagOpen.getTestCaseInfo().description == "[one" succeeded for: "[one" == "[one"
TestMain.cpp:355: oneTagOpen.hasTag( "one" ) == false succeeded for: false == false
TestMain.cpp:356: oneTagOpen.getTags().size() == 0 succeeded for: 0 == 0
[End of section: 'start of a tag, but not closed' All 3 assertions passed]

[Started section: 'hidden']
TestMain.cpp:362: oneTag.getTestCaseInfo().description == "" succeeded for: "" == ""
TestMain.cpp:363: oneTag.hasTag( "hide" ) succeeded for: true
TestMain.cpp:364: oneTag.isHidden() succeeded for: true
TestMain.cpp:366: oneTag.matchesTags( "~[hide]" ) == false succeeded for: false == false
[End of section: 'hidden' All 4 assertions passed]

[Finished: 'selftest/tags' All tests passed (30 assertions in 1 test case)]

[Running: Long strings can be wrapped]
[Started section: 'plain string']
[Started section: 'No wrapping']
TestMain.cpp:379: Text( testString, TextAttributes().setWidth( 80 ) ).toString() == testString succeeded for:
	"one two three four"
==
"one two three four"
TestMain.cpp:380: Text( testString, TextAttributes().setWidth( 18 ) ).toString() == testString succeeded for:
	"one two three four"
==
"one two three four"
[End of section: 'No wrapping' All 2 assertions passed]

[End of section: 'plain string' All 2 assertions passed]

[Started section: 'plain string']
[Started section: 'Wrapped once']
TestMain.cpp:383: Text( testString, TextAttributes().setWidth( 17 ) ).toString() == "one two three\nfour" succeeded for:
	"one two three
four"
==
"one two three
four"
TestMain.cpp:384: Text( testString, TextAttributes().setWidth( 16 ) ).toString() == "one two three\nfour" succeeded for:
	"one two three
four"
==
"one two three
four"
TestMain.cpp:385: Text( testString, TextAttributes().setWidth( 14 ) ).toString() == "one two three\nfour" succeeded for:
	"one two three
four"
==
"one two three
four"
TestMain.cpp:386: Text( testString, TextAttributes().setWidth( 13 ) ).toString() == "one two three\nfour" succeeded for:
	"one two three
four"
==
"one two three
four"
TestMain.cpp:387: Text( testString, TextAttributes().setWidth( 12 ) ).toString() == "one two\nthree four" succeeded for:
	"one two
three four"
==
"one two
three four"
[End of section: 'Wrapped once' All 5 assertions passed]

[End of section: 'plain string' All 5 assertions passed]

[Started section: 'plain string']
[Started section: 'Wrapped twice']
TestMain.cpp:390: Text( testString, TextAttributes().setWidth( 9 ) ).toString() == "one two\nthree\nfour" succeeded for:
	"one two
three
four"
==
"one two
three
four"
TestMain.cpp:391: Text( testString, TextAttributes().setWidth( 8 ) ).toString() == "one two\nthree\nfour" succeeded for:
	"one two
three
four"
==
"one two
three
four"
TestMain.cpp:392: Text( testString, TextAttributes().setWidth( 7 ) ).toString() == "one two\nthree\nfour" succeeded for:
	"one two
three
four"
==
"one two
three
four"
[End of section: 'Wrapped twice' All 3 assertions passed]

[End of section: 'plain string' All 3 assertions passed]

[Started section: 'plain string']
[Started section: 'Wrapped three times']
TestMain.cpp:395: Text( testString, TextAttributes().setWidth( 6 ) ).toString() == "one\ntwo\nthree\nfour" succeeded for:
	"one
two
three
four"
==
"one
two
three
four"
TestMain.cpp:396: Text( testString, TextAttributes().setWidth( 5 ) ).toString() == "one\ntwo\nthree\nfour" succeeded for:
	"one
two
three
four"
==
"one
two
three
four"
[End of section: 'Wrapped three times' All 2 assertions passed]

[End of section: 'plain string' All 2 assertions passed]

[Started section: 'plain string']
[Started section: 'Short wrap']
TestMain.cpp:399: Text( "abcdef", TextAttributes().setWidth( 4 ) ).toString() == "abc-\ndef" succeeded for: "abc-
def"
==
"abc-
def"
TestMain.cpp:400: Text( "abcdefg", TextAttributes().setWidth( 4 ) ).toString() == "abc-\ndefg" succeeded for: "abc-
defg"
==
"abc-
defg"
TestMain.cpp:401: Text( "abcdefgh", TextAttributes().setWidth( 4 ) ).toString() == "abc-\ndef-\ngh" succeeded for: "abc-
def-
gh"
==
"abc-
def-
gh"
TestMain.cpp:403: Text( testString, TextAttributes().setWidth( 4 ) ).toString() == "one\ntwo\nthr-\nee\nfour" succeeded for:
	"one
two
thr-
ee
four"
==
"one
two
thr-
ee
four"
TestMain.cpp:404: Text( testString, TextAttributes().setWidth( 3 ) ).toString() == "one\ntwo\nth-\nree\nfo-\nur" succeeded for:
	"one
two
th-
ree
fo-
ur"
==
"one
two
th-
ree
fo-
ur"
[End of section: 'Short wrap' All 5 assertions passed]

[End of section: 'plain string' All 5 assertions passed]

[Started section: 'plain string']
[Started section: 'As container']
TestMain.cpp:408: text.size() == 4 succeeded for: 4 == 4
TestMain.cpp:409: text[0] == "one" succeeded for: "one" == "one"
TestMain.cpp:410: text[1] == "two" succeeded for: "two" == "two"
TestMain.cpp:411: text[2] == "three" succeeded for: "three" == "three"
TestMain.cpp:412: text[3] == "four" succeeded for: "four" == "four"
[End of section: 'As container' All 5 assertions passed]

[End of section: 'plain string' All 5 assertions passed]

[Started section: 'plain string']
[Started section: 'Indent first line differently']
TestMain.cpp:419: text.toString() == " one two\n    three\n    four" succeeded for:
	" one two
    three
    four"
==
" one two
    three
    four"
[End of section: 'Indent first line differently' 1 assertion passed]

[End of section: 'plain string' 1 assertion passed]

[Started section: 'With newlines']
[Started section: 'No wrapping']
TestMain.cpp:430: Text( testString, TextAttributes().setWidth( 80 ) ).toString() == testString succeeded for:
	"one two
three four"
==
"one two
three four"
TestMain.cpp:431: Text( testString, TextAttributes().setWidth( 18 ) ).toString() == testString succeeded for:
	"one two
three four"
==
"one two
three four"
TestMain.cpp:432: Text( testString, TextAttributes().setWidth( 10 ) ).toString() == testString succeeded for:
	"one two
three four"
==
"one two
three four"
[End of section: 'No wrapping' All 3 assertions passed]

[End of section: 'With newlines' All 3 assertions passed]

[Started section: 'With newlines']
[Started section: 'Trailing newline']
TestMain.cpp:435: Text( "abcdef\n", TextAttributes().setWidth( 10 ) ).toString() == "abcdef\n" succeeded for: "abcdef
"
==
"abcdef
"
TestMain.cpp:436: Text( "abcdef", TextAttributes().setWidth( 6 ) ).toString() == "abcdef" succeeded for: "abcdef" == "abcdef"
TestMain.cpp:437: Text( "abcdef\n", TextAttributes().setWidth( 6 ) ).toString() == "abcdef\n" succeeded for: "abcdef
"
==
"abcdef
"
[End of section: 'Trailing newline' All 3 assertions passed]

[End of section: 'With newlines' All 3 assertions passed]

[Started section: 'With newlines']
[Started section: 'Wrapped once']
TestMain.cpp:440: Text( testString, TextAttributes().setWidth( 9 ) ).toString() == "one two\nthree\nfour" succeeded for:
	"one two
three
four"
==
"one two
three
four"
TestMain.cpp:441: Text( testString, TextAttributes().setWidth( 8 ) ).toString() == "one two\nthree\nfour" succeeded for:
	"one two
three
four"
==
"one two
three
four"
TestMain.cpp:442: Text( testString, TextAttributes().setWidth( 7 ) ).toString() == "one two\nthree\nfour" succeeded for:
	"one two
three
four"
==
"one two
three
four"
[End of section: 'Wrapped once' All 3 assertions passed]

[End of section: 'With newlines' All 3 assertions passed]

[Started section: 'With newlines']
[Started section: 'Wrapped twice']
TestMain.cpp:445: Text( testString, TextAttributes().setWidth( 6 ) ).toString() == "one\ntwo\nthree\nfour" succeeded for:
	"one
two
three
four"
==
"one
two
three
four"
[End of section: 'Wrapped twice' 1 assertion passed]

[End of section: 'With newlines' 1 assertion passed]

[Started section: 'With tabs']
TestMain.cpp:455: Text( testString, TextAttributes().setWidth( 15 ) ).toString() == "one two three\n        four\n        five\n        six" succeeded for:
"one two three
        four
        five
        six"
==
"one two three
        four
        five
        six"
[End of section: 'With tabs' 1 assertion passed]

[Finished: 'Long strings can be wrapped' All tests passed (34 assertions in 1 test case)]
hello
hello

[Running: Strings can be rendered with colour]

No assertions in test case, 'Strings can be rendered with colour'

[Finished: 'Strings can be rendered with colour' 1 test case failed (1 assertion failed)]

[Running: Text can be formatted using the Text class]
TestMain.cpp:555: Text( "hi there" ).toString() == "hi there" succeeded for: "hi there" == "hi there"
TestMain.cpp:560: Text( "hi there", narrow ).toString() == "hi\nthere" succeeded for: "hi
there"
==
"hi
there"
[Finished: 'Text can be formatted using the Text class' All tests passed (2 assertions in 1 test case)]

[Running: ./succeeding/Tricky/std::pair]
TrickyTests.cpp:37: (std::pair<int, int>( 1, 2 )) == aNicePair succeeded for: std::pair( 1, 2 ) == std::pair( 1, 2 )
[Finished: './succeeding/Tricky/std::pair' All tests passed (1 assertion in 1 test case)]

[Running: ./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'

[Finished: './inprogress/failing/Tricky/trailing expression' 1 test case failed (1 assertion failed)]

[Running: ./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'

[Finished: './inprogress/failing/Tricky/compound lhs' 1 test case failed (1 assertion failed)]

[Running: ./failing/Tricky/non streamable type]
TrickyTests.cpp:95: &o1 == &o2 failed for: 0x<hex digits> == 0x<hex digits>
TrickyTests.cpp:96: o1 == o2 failed for: {?} == {?}
[Finished: './failing/Tricky/non streamable type' 1 test case failed (All 2 assertions failed)]

[Running: ./failing/string literals]
TrickyTests.cpp:106: std::string( "first" ) == "second" failed for: "first" == "second"
[Finished: './failing/string literals' 1 test case failed (1 assertion failed)]

[Running: ./succeeding/side-effects]
TrickyTests.cpp:119: i++ == 7 succeeded for: 7 == 7
TrickyTests.cpp:120: i++ == 8 succeeded for: 8 == 8
[Finished: './succeeding/side-effects' All tests passed (2 assertions in 1 test case)]

[Running: ./succeeding/koenig]
TrickyTests.cpp:186: 0x<hex digits> == o succeeded for: 0x<hex digits> == {?}
[Finished: './succeeding/koenig' All tests passed (1 assertion in 1 test case)]

[Running: ./succeeding/non-const==]
TrickyTests.cpp:212: t == 1u succeeded for: {?} == 1
[Finished: './succeeding/non-const==' All tests passed (1 assertion in 1 test case)]

[Running: ./succeeding/enum/bits]
TrickyTests.cpp:224: 0x<hex digits> == bit30and31 succeeded for: 0x<hex digits> == 3221225472
[Finished: './succeeding/enum/bits' All tests passed (1 assertion in 1 test case)]

[Running: ./succeeding/boolean member]
TrickyTests.cpp:239: obj.prop != __null succeeded for: 0x<hex digits> != 0
[Finished: './succeeding/boolean member' All tests passed (1 assertion in 1 test case)]

[Running: ./succeeding/unimplemented static bool]
[Started section: 'compare to true']
TrickyTests.cpp:259: is_true<true>::value == true succeeded for: true == true
TrickyTests.cpp:260: true == is_true<true>::value succeeded for: true == true
[End of section: 'compare to true' All 2 assertions passed]

[Started section: 'compare to false']
TrickyTests.cpp:264: is_true<false>::value == false succeeded for: false == false
TrickyTests.cpp:265: false == is_true<false>::value succeeded for: false == false
[End of section: 'compare to false' All 2 assertions passed]

[Started section: 'negation']
TrickyTests.cpp:270: !is_true<false>::value succeeded for: true
[End of section: 'negation' 1 assertion passed]

[Started section: 'double negation']
TrickyTests.cpp:275: !!is_true<true>::value succeeded for: true
[End of section: 'double negation' 1 assertion passed]

[Started section: 'direct']
TrickyTests.cpp:280: is_true<true>::value succeeded for: true
TrickyTests.cpp:281: !is_true<false>::value succeeded for: !false
[End of section: 'direct' All 2 assertions passed]

[Finished: './succeeding/unimplemented static bool' All tests passed (8 assertions in 1 test case)]

[Running: ./succeeding/SafeBool]
TrickyTests.cpp:313: True succeeded for: true
TrickyTests.cpp:314: !False succeeded for: true
TrickyTests.cpp:315: !False succeeded for: !false
[Finished: './succeeding/SafeBool' All tests passed (3 assertions in 1 test case)]

[Running: Assertions then sections]
TrickyTests.cpp:323: Catch::isTrue( true ) succeeded for: true
[Started section: 'A section']
TrickyTests.cpp:327: Catch::isTrue( true ) succeeded for: true
[Started section: 'Another section']
TrickyTests.cpp:331: Catch::isTrue( true ) succeeded for: true
[End of section: 'Another section' 1 assertion passed]

[End of section: 'A section' All 2 assertions passed]

TrickyTests.cpp:323: Catch::isTrue( true ) succeeded for: true
[Started section: 'A section']
TrickyTests.cpp:327: Catch::isTrue( true ) succeeded for: true
[Started section: 'Another other section']
TrickyTests.cpp:335: Catch::isTrue( true ) succeeded for: true
[End of section: 'Another other section' 1 assertion passed]

[End of section: 'A section' All 2 assertions passed]

[Finished: 'Assertions then sections' All tests passed (6 assertions in 1 test case)]

[Running: non streamable - with conv. op]
TrickyTests.cpp:349: s == "7" succeeded for: "7" == "7"
[Finished: 'non streamable - with conv. op' All tests passed (1 assertion in 1 test case)]

[Running: Anonymous test case 1]
VariadicMacrosTests.cpp:15:  succeeded
[with message: anonymous test case]
[Finished: 'Anonymous test case 1' All tests passed (1 assertion in 1 test case)]

[Running: Test case with one argument]
VariadicMacrosTests.cpp:20:  succeeded
[with message: no assertions]
[Finished: 'Test case with one argument' All tests passed (1 assertion in 1 test case)]

[Running: Variadic macros]
[Started section: 'Section with one argument']
VariadicMacrosTests.cpp:27:  succeeded
[with message: no assertions]
[End of section: 'Section with one argument' 1 assertion passed]

[Finished: 'Variadic macros' All tests passed (1 assertion in 1 test case)]

[Running: Scenario: Do that thing with the thing]
[Started section: '   Given: This stuff exists']
[Started section: '    When: I do this']
[Started section: '    Then: it should do this']
BDDTests.cpp:21: itDoesThis() succeeded for: true
[Started section: '     And: do that']
BDDTests.cpp:23: itDoesThat() succeeded for: true
[End of section: '     And: do that' 1 assertion passed]

[End of section: '    Then: it should do this' All 2 assertions passed]

[End of section: '    When: I do this' All 2 assertions passed]

[End of section: '   Given: This stuff exists' All 2 assertions passed]

[Finished: 'Scenario: Do that thing with the thing' All tests passed (2 assertions in 1 test case)]

[Running: Scenario: Vector resizing affects size and capacity]
[Started section: '   Given: an empty vector']
BDDTests.cpp:32: v.size() == 0 succeeded for: 0 == 0
[Started section: '    When: it is made larger']
[Started section: '    Then: the size and capacity go up']
BDDTests.cpp:37: v.size() == 10 succeeded for: 10 == 10
BDDTests.cpp:38: v.capacity() >= 10 succeeded for: 10 >= 10
[Started section: 'And when: it is made smaller again']
[Started section: '    Then: the size goes down but the capacity stays the same']
BDDTests.cpp:43: v.size() == 5 succeeded for: 5 == 5
BDDTests.cpp:44: v.capacity() >= 10 succeeded for: 10 >= 10
[End of section: '    Then: the size goes down but the capacity stays the same' All 2 assertions passed]

[End of section: 'And when: it is made smaller again' All 2 assertions passed]

[End of section: '    Then: the size and capacity go up' All 4 assertions passed]

[End of section: '    When: it is made larger' All 4 assertions passed]

[End of section: '   Given: an empty vector' All 5 assertions passed]

[Started section: '   Given: an empty vector']
BDDTests.cpp:32: v.size() == 0 succeeded for: 0 == 0
[Started section: '    When: it is made larger']
[Started section: '    Then: the size and capacity go up']
BDDTests.cpp:37: v.size() == 10 succeeded for: 10 == 10
BDDTests.cpp:38: v.capacity() >= 10 succeeded for: 10 >= 10
[End of section: '    Then: the size and capacity go up' All 2 assertions passed]

[End of section: '    When: it is made larger' All 2 assertions passed]

[End of section: '   Given: an empty vector' All 3 assertions passed]

[Started section: '   Given: an empty vector']
BDDTests.cpp:32: v.size() == 0 succeeded for: 0 == 0
[Started section: '    When: it is made larger']
[Started section: '    Then: the size and capacity go up']
BDDTests.cpp:37: v.size() == 10 succeeded for: 10 == 10
BDDTests.cpp:38: v.capacity() >= 10 succeeded for: 10 >= 10
[End of section: '    Then: the size and capacity go up' All 2 assertions passed]

[End of section: '    When: it is made larger' All 2 assertions passed]

[End of section: '   Given: an empty vector' All 3 assertions passed]

[Started section: '   Given: an empty vector']
BDDTests.cpp:32: v.size() == 0 succeeded for: 0 == 0
[End of section: '   Given: an empty vector' 1 assertion passed]

[Started section: '   Given: an empty vector']
BDDTests.cpp:32: v.size() == 0 succeeded for: 0 == 0
[Started section: '    When: we reserve more space']
[Started section: '    Then: The capacity is increased but the size remains the same']
BDDTests.cpp:53: v.capacity() >= 10 succeeded for: 10 >= 10
BDDTests.cpp:54: v.size() == 0 succeeded for: 0 == 0
[End of section: '    Then: The capacity is increased but the size remains the same' All 2 assertions passed]

[End of section: '    When: we reserve more space' All 2 assertions passed]

[End of section: '   Given: an empty vector' All 3 assertions passed]

[Finished: 'Scenario: Vector resizing affects size and capacity' All tests passed (15 assertions in 1 test case)]

[Running: Scenario: This is a really long scenario name to see how the list command deals with wrapping]
[Started section: '   Given: A section name that is so long that it cannot fit in a single console width']
[Started section: '    When: The test headers are printed as part of the normal running of the scenario']
[Started section: '    Then: The, deliberately very long and overly verbose (you see what I did there?) section names must wrap, along with an indent']
BDDTests.cpp:67:  succeeded
[with message: boo!]
[End of section: '    Then: The, deliberately very long and overly verbose (you see what I did there?) section names must wrap, along with an indent' 1 assertion passed]

[End of section: '    When: The test headers are printed as part of the normal running of the scenario' 1 assertion passed]

[End of section: '   Given: A section name that is so long that it cannot fit in a single console width' 1 assertion passed]

[Finished: 'Scenario: This is a really long scenario name to see how the list command deals with wrapping' All tests passed (1 assertion in 1 test case)]

[Running: cmdline]
[Started section: 'process name']
CmdLineTests.cpp:64: config.processName == "test" succeeded for: "test" == "test"
[End of section: 'process name' 1 assertion passed]

[Started section: 'arg separated by spaces']
CmdLineTests.cpp:70: config.fileName == "filename.ext" succeeded for: "filename.ext" == "filename.ext"
[End of section: 'arg separated by spaces' 1 assertion passed]

[Started section: 'arg separated by colon']
CmdLineTests.cpp:76: config.fileName == "filename.ext" succeeded for: "filename.ext" == "filename.ext"
[End of section: 'arg separated by colon' 1 assertion passed]

[Started section: 'arg separated by =']
CmdLineTests.cpp:82: config.fileName == "filename.ext" succeeded for: "filename.ext" == "filename.ext"
[End of section: 'arg separated by =' 1 assertion passed]

[Started section: 'long opt']
CmdLineTests.cpp:88: config.fileName == "%stdout" succeeded for: "%stdout" == "%stdout"
[End of section: 'long opt' 1 assertion passed]

[Started section: 'a number']
CmdLineTests.cpp:99: config.number == 42 succeeded for: 42 == 42
[End of section: 'a number' 1 assertion passed]

[Started section: 'not a number']
CmdLineTests.cpp:103: parseInto( cli, argv, config ) succeeded
CmdLineTests.cpp:105: config.number == 0 succeeded for: 0 == 0
[End of section: 'not a number' All 2 assertions passed]

[Started section: 'two parsers']
CmdLineTests.cpp:123: config1.number == 42 succeeded for: 42 == 42
CmdLineTests.cpp:125: !unusedTokens.empty() succeeded for: !false
CmdLineTests.cpp:127: config2.description == "some text" succeeded for: "some text" == "some text"
[End of section: 'two parsers' All 3 assertions passed]

[Started section: 'methods']
[Started section: 'in range']
CmdLineTests.cpp:140: config.index == 3 succeeded for: 3 == 3
[End of section: 'in range' 1 assertion passed]

[End of section: 'methods' 1 assertion passed]

[Started section: 'methods']
[Started section: 'out of range']
CmdLineTests.cpp:145: parseInto( cli, argv, config ) succeeded
[End of section: 'out of range' 1 assertion passed]

[End of section: 'methods' 1 assertion passed]

[Started section: 'flags']
[Started section: 'set']
CmdLineTests.cpp:158: config.flag succeeded for: true
[End of section: 'set' 1 assertion passed]

[End of section: 'flags' 1 assertion passed]

[Started section: 'flags']
[Started section: 'not set']
CmdLineTests.cpp:164: config.flag == false succeeded for: false == false
[End of section: 'not set' 1 assertion passed]

[End of section: 'flags' 1 assertion passed]

[Started section: 'positional']
CmdLineTests.cpp:185: config.firstPos == "1st" succeeded for: "1st" == "1st"
CmdLineTests.cpp:186: config.secondPos == "2nd" succeeded for: "2nd" == "2nd"
CmdLineTests.cpp:187: config.unpositional == "3rd" succeeded for: "3rd" == "3rd"
[End of section: 'positional' All 3 assertions passed]

[Finished: 'cmdline' All tests passed (18 assertions in 1 test case)]
[End of group: '~dummy'. 49 of 113 test cases failed (106 of 705 assertions failed)]


[Testing completed. 49 of 113 test cases failed (106 of 705 assertions failed)]


[Testing completed. No tests ran]