~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ is a host application. Run with -? for options ------------------------------------------------------------------------------- # A test name that starts with a # ------------------------------------------------------------------------------- MiscTests.cpp: ............................................................................... MiscTests.cpp:: PASSED: with message: yay ------------------------------------------------------------------------------- #1005: Comparing pointer to int and long (NULL can be either on various systems) ------------------------------------------------------------------------------- DecompositionTests.cpp: ............................................................................... DecompositionTests.cpp:: PASSED: REQUIRE( fptr == 0 ) with expansion: 0 == 0 DecompositionTests.cpp:: PASSED: REQUIRE( fptr == 0l ) with expansion: 0 == 0 ------------------------------------------------------------------------------- #748 - captures with unexpected exceptions outside assertions ------------------------------------------------------------------------------- ExceptionTests.cpp: ............................................................................... ExceptionTests.cpp:: FAILED: due to unexpected exception with messages: answer := 42 expected exception ------------------------------------------------------------------------------- #748 - captures with unexpected exceptions inside REQUIRE_NOTHROW ------------------------------------------------------------------------------- ExceptionTests.cpp: ............................................................................... ExceptionTests.cpp:: FAILED: REQUIRE_NOTHROW( thisThrows() ) due to unexpected exception with messages: answer := 42 expected exception ------------------------------------------------------------------------------- #748 - captures with unexpected exceptions inside REQUIRE_THROWS ------------------------------------------------------------------------------- ExceptionTests.cpp: ............................................................................... ExceptionTests.cpp:: PASSED: REQUIRE_THROWS( thisThrows() ) with message: answer := 42 ------------------------------------------------------------------------------- #809 ------------------------------------------------------------------------------- CompilationTests.cpp: ............................................................................... CompilationTests.cpp:: PASSED: REQUIRE( 42 == f ) with expansion: 42 == {?} ------------------------------------------------------------------------------- #833 ------------------------------------------------------------------------------- CompilationTests.cpp: ............................................................................... CompilationTests.cpp:: PASSED: REQUIRE( a == t ) with expansion: 3 == 3 CompilationTests.cpp:: PASSED: CHECK( a == t ) with expansion: 3 == 3 CompilationTests.cpp:: PASSED: REQUIRE_THROWS( throws_int(true) ) CompilationTests.cpp:: PASSED: CHECK_THROWS_AS( throws_int(true), int ) CompilationTests.cpp:: PASSED: REQUIRE_NOTHROW( throws_int(false) ) CompilationTests.cpp:: PASSED: REQUIRE_THAT( "aaa", Catch::EndsWith("aaa") ) with expansion: "aaa" ends with: "aaa" CompilationTests.cpp:: PASSED: REQUIRE( templated_tests(3) ) with expansion: true ------------------------------------------------------------------------------- #835 -- errno should not be touched by Catch ------------------------------------------------------------------------------- MiscTests.cpp: ............................................................................... MiscTests.cpp:: FAILED: CHECK( f() == 0 ) with expansion: 1 == 0 MiscTests.cpp:: PASSED: REQUIRE( errno == 1 ) with expansion: 1 == 1 ------------------------------------------------------------------------------- #872 ------------------------------------------------------------------------------- CompilationTests.cpp: ............................................................................... CompilationTests.cpp:: PASSED: REQUIRE( x == 4 ) with expansion: {?} == 4 with message: dummy := 0 ------------------------------------------------------------------------------- #961 -- Dynamically created sections should all be reported Looped section 0 ------------------------------------------------------------------------------- MiscTests.cpp: ............................................................................... MiscTests.cpp:: PASSED: with message: Everything is OK ------------------------------------------------------------------------------- #961 -- Dynamically created sections should all be reported Looped section 1 ------------------------------------------------------------------------------- MiscTests.cpp: ............................................................................... MiscTests.cpp:: PASSED: with message: Everything is OK ------------------------------------------------------------------------------- #961 -- Dynamically created sections should all be reported Looped section 2 ------------------------------------------------------------------------------- MiscTests.cpp: ............................................................................... MiscTests.cpp:: PASSED: with message: Everything is OK ------------------------------------------------------------------------------- #961 -- Dynamically created sections should all be reported Looped section 3 ------------------------------------------------------------------------------- MiscTests.cpp: ............................................................................... MiscTests.cpp:: PASSED: with message: Everything is OK ------------------------------------------------------------------------------- #961 -- Dynamically created sections should all be reported Looped section 4 ------------------------------------------------------------------------------- MiscTests.cpp: ............................................................................... MiscTests.cpp:: PASSED: with message: Everything is OK ------------------------------------------------------------------------------- 'Not' checks that should fail ------------------------------------------------------------------------------- ConditionTests.cpp: ............................................................................... ConditionTests.cpp:: FAILED: CHECK( false != false ) ConditionTests.cpp:: FAILED: CHECK( true != true ) ConditionTests.cpp:: FAILED: CHECK( !true ) with expansion: false ConditionTests.cpp:: FAILED: CHECK_FALSE( true ) ConditionTests.cpp:: FAILED: CHECK( !trueValue ) with expansion: false ConditionTests.cpp:: FAILED: CHECK_FALSE( trueValue ) with expansion: !true ConditionTests.cpp:: FAILED: CHECK( !(1 == 1) ) with expansion: false ConditionTests.cpp:: FAILED: CHECK_FALSE( 1 == 1 ) with expansion: !(1 == 1) ------------------------------------------------------------------------------- 'Not' checks that should succeed ------------------------------------------------------------------------------- ConditionTests.cpp: ............................................................................... ConditionTests.cpp:: PASSED: REQUIRE( false == false ) ConditionTests.cpp:: PASSED: REQUIRE( true == true ) ConditionTests.cpp:: PASSED: REQUIRE( !false ) with expansion: true ConditionTests.cpp:: PASSED: REQUIRE_FALSE( false ) ConditionTests.cpp:: PASSED: REQUIRE( !falseValue ) with expansion: true ConditionTests.cpp:: PASSED: REQUIRE_FALSE( falseValue ) with expansion: !false ConditionTests.cpp:: PASSED: REQUIRE( !(1 == 2) ) with expansion: true ConditionTests.cpp:: PASSED: REQUIRE_FALSE( 1 == 2 ) with expansion: !(1 == 2) ------------------------------------------------------------------------------- (unimplemented) static bools can be evaluated compare to true ------------------------------------------------------------------------------- TrickyTests.cpp: ............................................................................... TrickyTests.cpp:: PASSED: REQUIRE( is_true::value == true ) with expansion: true == true TrickyTests.cpp:: PASSED: REQUIRE( true == is_true::value ) with expansion: true == true ------------------------------------------------------------------------------- (unimplemented) static bools can be evaluated compare to false ------------------------------------------------------------------------------- TrickyTests.cpp: ............................................................................... TrickyTests.cpp:: PASSED: REQUIRE( is_true::value == false ) with expansion: false == false TrickyTests.cpp:: PASSED: REQUIRE( false == is_true::value ) with expansion: false == false ------------------------------------------------------------------------------- (unimplemented) static bools can be evaluated negation ------------------------------------------------------------------------------- TrickyTests.cpp: ............................................................................... TrickyTests.cpp:: PASSED: REQUIRE( !is_true::value ) with expansion: true ------------------------------------------------------------------------------- (unimplemented) static bools can be evaluated double negation ------------------------------------------------------------------------------- TrickyTests.cpp: ............................................................................... TrickyTests.cpp:: PASSED: REQUIRE( !!is_true::value ) with expansion: true ------------------------------------------------------------------------------- (unimplemented) static bools can be evaluated direct ------------------------------------------------------------------------------- TrickyTests.cpp: ............................................................................... TrickyTests.cpp:: PASSED: REQUIRE( is_true::value ) with expansion: true TrickyTests.cpp:: PASSED: REQUIRE_FALSE( is_true::value ) with expansion: !false ------------------------------------------------------------------------------- A METHOD_AS_TEST_CASE based test run that fails ------------------------------------------------------------------------------- ClassTests.cpp: ............................................................................... ClassTests.cpp:: FAILED: REQUIRE( s == "world" ) with expansion: "hello" == "world" ------------------------------------------------------------------------------- A METHOD_AS_TEST_CASE based test run that succeeds ------------------------------------------------------------------------------- ClassTests.cpp: ............................................................................... ClassTests.cpp:: PASSED: REQUIRE( s == "hello" ) with expansion: "hello" == "hello" ------------------------------------------------------------------------------- A TEST_CASE_METHOD based test run that fails ------------------------------------------------------------------------------- ClassTests.cpp: ............................................................................... ClassTests.cpp:: FAILED: REQUIRE( m_a == 2 ) with expansion: 1 == 2 ------------------------------------------------------------------------------- A TEST_CASE_METHOD based test run that succeeds ------------------------------------------------------------------------------- ClassTests.cpp: ............................................................................... ClassTests.cpp:: PASSED: REQUIRE( m_a == 1 ) with expansion: 1 == 1 ------------------------------------------------------------------------------- A couple of nested sections followed by a failure Outer Inner ------------------------------------------------------------------------------- MiscTests.cpp: ............................................................................... MiscTests.cpp:: PASSED: with message: that's not flying - that's failing in style ------------------------------------------------------------------------------- A couple of nested sections followed by a failure ------------------------------------------------------------------------------- MiscTests.cpp: ............................................................................... MiscTests.cpp:: FAILED: explicitly with message: to infinity and beyond ------------------------------------------------------------------------------- A failing expression with a non streamable type is still captured ------------------------------------------------------------------------------- TrickyTests.cpp: ............................................................................... TrickyTests.cpp:: FAILED: CHECK( &o1 == &o2 ) with expansion: 0x == 0x TrickyTests.cpp:: FAILED: CHECK( o1 == o2 ) with expansion: {?} == {?} ------------------------------------------------------------------------------- Absolute margin ------------------------------------------------------------------------------- ApproxTests.cpp: ............................................................................... ApproxTests.cpp:: PASSED: REQUIRE( 104.0 != Approx(100.0) ) with expansion: 104.0 != Approx( 100.0 ) ApproxTests.cpp:: PASSED: REQUIRE( 104.0 == Approx(100.0).margin(5) ) with expansion: 104.0 == Approx( 100.0 ) ApproxTests.cpp:: PASSED: REQUIRE( 104.0 != Approx(100.0).margin(3) ) with expansion: 104.0 != Approx( 100.0 ) ApproxTests.cpp:: PASSED: REQUIRE( 100.3 != Approx(100.0) ) with expansion: 100.3 != Approx( 100.0 ) ApproxTests.cpp:: PASSED: REQUIRE( 100.3 == Approx(100.0).margin(0.5) ) with expansion: 100.3 == Approx( 100.0 ) ------------------------------------------------------------------------------- An expression with side-effects should only be evaluated once ------------------------------------------------------------------------------- TrickyTests.cpp: ............................................................................... TrickyTests.cpp:: PASSED: REQUIRE( i++ == 7 ) with expansion: 7 == 7 TrickyTests.cpp:: PASSED: REQUIRE( i++ == 8 ) with expansion: 8 == 8 ------------------------------------------------------------------------------- An unchecked exception reports the line of the last assertion ------------------------------------------------------------------------------- ExceptionTests.cpp: ............................................................................... ExceptionTests.cpp:: PASSED: CHECK( 1 == 1 ) ExceptionTests.cpp:: FAILED: {Unknown expression after the reported line} due to unexpected exception with message: unexpected exception ------------------------------------------------------------------------------- Anonymous test case 1 ------------------------------------------------------------------------------- VariadicMacrosTests.cpp: ............................................................................... VariadicMacrosTests.cpp:: PASSED: with message: anonymous test case ------------------------------------------------------------------------------- Approximate PI ------------------------------------------------------------------------------- ApproxTests.cpp: ............................................................................... ApproxTests.cpp:: PASSED: REQUIRE( divide( 22, 7 ) == Approx( 3.141 ).epsilon( 0.001 ) ) with expansion: 3.1428571429 == Approx( 3.141 ) ApproxTests.cpp:: PASSED: REQUIRE( divide( 22, 7 ) != Approx( 3.141 ).epsilon( 0.0001 ) ) with expansion: 3.1428571429 != Approx( 3.141 ) ------------------------------------------------------------------------------- Approximate comparisons with different epsilons ------------------------------------------------------------------------------- ApproxTests.cpp: ............................................................................... ApproxTests.cpp:: PASSED: REQUIRE( d != Approx( 1.231 ) ) with expansion: 1.23 != Approx( 1.231 ) ApproxTests.cpp:: PASSED: REQUIRE( d == Approx( 1.231 ).epsilon( 0.1 ) ) with expansion: 1.23 == Approx( 1.231 ) ------------------------------------------------------------------------------- Approximate comparisons with floats ------------------------------------------------------------------------------- ApproxTests.cpp: ............................................................................... ApproxTests.cpp:: PASSED: REQUIRE( 1.23f == Approx( 1.23f ) ) with expansion: 1.23f == Approx( 1.2300000191 ) ApproxTests.cpp:: PASSED: REQUIRE( 0.0f == Approx( 0.0f ) ) with expansion: 0.0f == Approx( 0.0 ) ------------------------------------------------------------------------------- Approximate comparisons with ints ------------------------------------------------------------------------------- ApproxTests.cpp: ............................................................................... ApproxTests.cpp:: PASSED: REQUIRE( 1 == Approx( 1 ) ) with expansion: 1 == Approx( 1.0 ) ApproxTests.cpp:: PASSED: REQUIRE( 0 == Approx( 0 ) ) with expansion: 0 == Approx( 0.0 ) ------------------------------------------------------------------------------- Approximate comparisons with mixed numeric types ------------------------------------------------------------------------------- ApproxTests.cpp: ............................................................................... ApproxTests.cpp:: PASSED: REQUIRE( 1.0f == Approx( 1 ) ) with expansion: 1.0f == Approx( 1.0 ) ApproxTests.cpp:: PASSED: REQUIRE( 0 == Approx( dZero) ) with expansion: 0 == Approx( 0.0 ) ApproxTests.cpp:: PASSED: REQUIRE( 0 == Approx( dSmall ).epsilon( 0.001 ) ) with expansion: 0 == Approx( 0.00001 ) ApproxTests.cpp:: PASSED: REQUIRE( 1.234f == Approx( dMedium ) ) with expansion: 1.234f == Approx( 1.234 ) ApproxTests.cpp:: PASSED: REQUIRE( dMedium == Approx( 1.234f ) ) with expansion: 1.234 == Approx( 1.2339999676 ) ------------------------------------------------------------------------------- Assertions then sections ------------------------------------------------------------------------------- TrickyTests.cpp: ............................................................................... TrickyTests.cpp:: PASSED: REQUIRE( Catch::alwaysTrue() ) with expansion: true ------------------------------------------------------------------------------- Assertions then sections A section ------------------------------------------------------------------------------- TrickyTests.cpp: ............................................................................... TrickyTests.cpp:: PASSED: REQUIRE( Catch::alwaysTrue() ) with expansion: true ------------------------------------------------------------------------------- Assertions then sections A section Another section ------------------------------------------------------------------------------- TrickyTests.cpp: ............................................................................... TrickyTests.cpp:: PASSED: REQUIRE( Catch::alwaysTrue() ) with expansion: true ------------------------------------------------------------------------------- Assertions then sections ------------------------------------------------------------------------------- TrickyTests.cpp: ............................................................................... TrickyTests.cpp:: PASSED: REQUIRE( Catch::alwaysTrue() ) with expansion: true ------------------------------------------------------------------------------- Assertions then sections A section ------------------------------------------------------------------------------- TrickyTests.cpp: ............................................................................... TrickyTests.cpp:: PASSED: REQUIRE( Catch::alwaysTrue() ) with expansion: true ------------------------------------------------------------------------------- Assertions then sections A section Another other section ------------------------------------------------------------------------------- TrickyTests.cpp: ............................................................................... TrickyTests.cpp:: PASSED: REQUIRE( Catch::alwaysTrue() ) with expansion: true ------------------------------------------------------------------------------- Capture and info messages Capture should stringify like assertions ------------------------------------------------------------------------------- ToStringGeneralTests.cpp: ............................................................................... ToStringGeneralTests.cpp:: PASSED: REQUIRE( true ) with message: i := 2 ------------------------------------------------------------------------------- Capture and info messages Info should NOT stringify the way assertions do ------------------------------------------------------------------------------- ToStringGeneralTests.cpp: ............................................................................... ToStringGeneralTests.cpp:: PASSED: REQUIRE( true ) with message: 3 ------------------------------------------------------------------------------- Character pretty printing Specifically escaped ------------------------------------------------------------------------------- ToStringGeneralTests.cpp: ............................................................................... ToStringGeneralTests.cpp:: PASSED: CHECK( tab == '\t' ) with expansion: '\t' == '\t' ToStringGeneralTests.cpp:: PASSED: CHECK( newline == '\n' ) with expansion: '\n' == '\n' ToStringGeneralTests.cpp:: PASSED: CHECK( carr_return == '\r' ) with expansion: '\r' == '\r' ToStringGeneralTests.cpp:: PASSED: CHECK( form_feed == '\f' ) with expansion: '\f' == '\f' ------------------------------------------------------------------------------- Character pretty printing General chars ------------------------------------------------------------------------------- ToStringGeneralTests.cpp: ............................................................................... ToStringGeneralTests.cpp:: PASSED: CHECK( space == ' ' ) with expansion: ' ' == ' ' ToStringGeneralTests.cpp:: PASSED: REQUIRE( c == chars[i] ) with expansion: 'a' == 'a' ToStringGeneralTests.cpp:: PASSED: REQUIRE( c == chars[i] ) with expansion: 'z' == 'z' ToStringGeneralTests.cpp:: PASSED: REQUIRE( c == chars[i] ) with expansion: 'A' == 'A' ToStringGeneralTests.cpp:: PASSED: REQUIRE( c == chars[i] ) with expansion: 'Z' == 'Z' ------------------------------------------------------------------------------- Character pretty printing Low ASCII ------------------------------------------------------------------------------- ToStringGeneralTests.cpp: ............................................................................... ToStringGeneralTests.cpp:: PASSED: CHECK( null_terminator == '\0' ) with expansion: 0 == 0 ToStringGeneralTests.cpp:: PASSED: REQUIRE( c == i ) with expansion: 2 == 2 ToStringGeneralTests.cpp:: PASSED: REQUIRE( c == i ) with expansion: 3 == 3 ToStringGeneralTests.cpp:: PASSED: REQUIRE( c == i ) with expansion: 4 == 4 ToStringGeneralTests.cpp:: PASSED: REQUIRE( c == i ) with expansion: 5 == 5 ------------------------------------------------------------------------------- Commas in various macros are allowed ------------------------------------------------------------------------------- TrickyTests.cpp: ............................................................................... TrickyTests.cpp:: PASSED: REQUIRE_THROWS( std::vector{constructor_throws{}, constructor_throws{}} ) TrickyTests.cpp:: PASSED: CHECK_THROWS( std::vector{constructor_throws{}, constructor_throws{}} ) TrickyTests.cpp:: PASSED: REQUIRE_NOTHROW( std::vector{1, 2, 3} == std::vector{1, 2, 3} ) TrickyTests.cpp:: PASSED: CHECK_NOTHROW( std::vector{1, 2, 3} == std::vector{1, 2, 3} ) TrickyTests.cpp:: PASSED: REQUIRE( std::vector{1, 2} == std::vector{1, 2} ) with expansion: { 1, 2 } == { 1, 2 } TrickyTests.cpp:: PASSED: CHECK( std::vector{1, 2} == std::vector{1, 2} ) with expansion: { 1, 2 } == { 1, 2 } TrickyTests.cpp:: PASSED: REQUIRE_FALSE( std::vector{1, 2} == std::vector{1, 2, 3} ) with expansion: !({ 1, 2 } == { 1, 2, 3 }) TrickyTests.cpp:: PASSED: CHECK_FALSE( std::vector{1, 2} == std::vector{1, 2, 3} ) with expansion: !({ 1, 2 } == { 1, 2, 3 }) TrickyTests.cpp:: PASSED: CHECK_NOFAIL( std::vector{1, 2} == std::vector{1, 2} ) with expansion: { 1, 2 } == { 1, 2 } TrickyTests.cpp:: PASSED: CHECKED_IF( std::vector{1, 2} == std::vector{1, 2} ) with expansion: { 1, 2 } == { 1, 2 } TrickyTests.cpp:: PASSED: REQUIRE( true ) TrickyTests.cpp:: PASSED: CHECKED_ELSE( std::vector{1, 2} == std::vector{1, 2} ) with expansion: { 1, 2 } == { 1, 2 } ------------------------------------------------------------------------------- Comparing function pointers ------------------------------------------------------------------------------- TrickyTests.cpp: ............................................................................... TrickyTests.cpp:: PASSED: REQUIRE( a ) with expansion: 0x TrickyTests.cpp:: PASSED: REQUIRE( a == &foo ) with expansion: 0x == 0x ------------------------------------------------------------------------------- Comparing member function pointers ------------------------------------------------------------------------------- TrickyTests.cpp: ............................................................................... TrickyTests.cpp:: PASSED: CHECK( m == &S::f ) with expansion: 0x == 0x ------------------------------------------------------------------------------- Comparison with explicitly convertible types ------------------------------------------------------------------------------- ApproxTests.cpp: ............................................................................... ApproxTests.cpp:: PASSED: REQUIRE( td == Approx(10.0) ) with expansion: StrongDoubleTypedef(10) == Approx( 10.0 ) ApproxTests.cpp:: PASSED: REQUIRE( Approx(10.0) == td ) with expansion: Approx( 10.0 ) == StrongDoubleTypedef(10) ApproxTests.cpp:: PASSED: REQUIRE( td != Approx(11.0) ) with expansion: StrongDoubleTypedef(10) != Approx( 11.0 ) ApproxTests.cpp:: PASSED: REQUIRE( Approx(11.0) != td ) with expansion: Approx( 11.0 ) != StrongDoubleTypedef(10) ApproxTests.cpp:: PASSED: REQUIRE( td <= Approx(10.0) ) with expansion: StrongDoubleTypedef(10) <= Approx( 10.0 ) ApproxTests.cpp:: PASSED: REQUIRE( td <= Approx(11.0) ) with expansion: StrongDoubleTypedef(10) <= Approx( 11.0 ) ApproxTests.cpp:: PASSED: REQUIRE( Approx(10.0) <= td ) with expansion: Approx( 10.0 ) <= StrongDoubleTypedef(10) ApproxTests.cpp:: PASSED: REQUIRE( Approx(9.0) <= td ) with expansion: Approx( 9.0 ) <= StrongDoubleTypedef(10) ApproxTests.cpp:: PASSED: REQUIRE( td >= Approx(9.0) ) with expansion: StrongDoubleTypedef(10) >= Approx( 9.0 ) ApproxTests.cpp:: PASSED: REQUIRE( td >= Approx(10.0) ) with expansion: StrongDoubleTypedef(10) >= Approx( 10.0 ) ApproxTests.cpp:: PASSED: REQUIRE( Approx(10.0) >= td ) with expansion: Approx( 10.0 ) >= StrongDoubleTypedef(10) ApproxTests.cpp:: PASSED: REQUIRE( Approx(11.0) >= td ) with expansion: Approx( 11.0 ) >= StrongDoubleTypedef(10) ------------------------------------------------------------------------------- Comparisons between ints where one side is computed ------------------------------------------------------------------------------- ConditionTests.cpp: ............................................................................... ConditionTests.cpp:: PASSED: CHECK( 54 == 6*9 ) with expansion: 54 == 54 ------------------------------------------------------------------------------- Comparisons between unsigned ints and negative signed ints match c++ standard behaviour ------------------------------------------------------------------------------- ConditionTests.cpp: ............................................................................... ConditionTests.cpp:: PASSED: CHECK( ( -1 > 2u ) ) with expansion: true ConditionTests.cpp:: PASSED: CHECK( -1 > 2u ) with expansion: -1 > 2 ConditionTests.cpp:: PASSED: CHECK( ( 2u < -1 ) ) with expansion: true ConditionTests.cpp:: PASSED: CHECK( 2u < -1 ) with expansion: 2 < -1 ConditionTests.cpp:: PASSED: CHECK( ( minInt > 2u ) ) with expansion: true ConditionTests.cpp:: PASSED: CHECK( minInt > 2u ) with expansion: -2147483648 > 2 ------------------------------------------------------------------------------- Comparisons with int literals don't warn when mixing signed/ unsigned ------------------------------------------------------------------------------- ConditionTests.cpp: ............................................................................... ConditionTests.cpp:: PASSED: REQUIRE( i == 1 ) with expansion: 1 == 1 ConditionTests.cpp:: PASSED: REQUIRE( ui == 2 ) with expansion: 2 == 2 ConditionTests.cpp:: PASSED: REQUIRE( l == 3 ) with expansion: 3 == 3 ConditionTests.cpp:: PASSED: REQUIRE( ul == 4 ) with expansion: 4 == 4 ConditionTests.cpp:: PASSED: REQUIRE( c == 5 ) with expansion: 5 == 5 ConditionTests.cpp:: PASSED: REQUIRE( uc == 6 ) with expansion: 6 == 6 ConditionTests.cpp:: PASSED: REQUIRE( 1 == i ) with expansion: 1 == 1 ConditionTests.cpp:: PASSED: REQUIRE( 2 == ui ) with expansion: 2 == 2 ConditionTests.cpp:: PASSED: REQUIRE( 3 == l ) with expansion: 3 == 3 ConditionTests.cpp:: PASSED: REQUIRE( 4 == ul ) with expansion: 4 == 4 ConditionTests.cpp:: PASSED: REQUIRE( 5 == c ) with expansion: 5 == 5 ConditionTests.cpp:: PASSED: REQUIRE( 6 == uc ) with expansion: 6 == 6 ConditionTests.cpp:: PASSED: REQUIRE( (std::numeric_limits::max)() > ul ) with expansion: 18446744073709551615 (0x) > 4 ------------------------------------------------------------------------------- Contains string matcher ------------------------------------------------------------------------------- MatchersTests.cpp: ............................................................................... MatchersTests.cpp:: FAILED: CHECK_THAT( testStringForMatching(), Contains( "not there" ) ) with expansion: "this string contains 'abc' as a substring" contains: "not there" ------------------------------------------------------------------------------- Custom exceptions can be translated when testing for nothrow ------------------------------------------------------------------------------- ExceptionTests.cpp: ............................................................................... ExceptionTests.cpp:: FAILED: REQUIRE_NOTHROW( throwCustom() ) due to unexpected exception with message: custom exception - not std ------------------------------------------------------------------------------- Custom exceptions can be translated when testing for throwing as something else ------------------------------------------------------------------------------- ExceptionTests.cpp: ............................................................................... ExceptionTests.cpp:: FAILED: REQUIRE_THROWS_AS( throwCustom(), std::exception ) due to unexpected exception with message: custom exception - not std ------------------------------------------------------------------------------- Custom std-exceptions can be custom translated ------------------------------------------------------------------------------- ExceptionTests.cpp: ............................................................................... ExceptionTests.cpp:: FAILED: due to unexpected exception with message: custom std exception ------------------------------------------------------------------------------- Demonstrate that a non-const == is not used ------------------------------------------------------------------------------- TrickyTests.cpp: ............................................................................... TrickyTests.cpp:: PASSED: REQUIRE( t == 1u ) with expansion: {?} == 1 ------------------------------------------------------------------------------- EndsWith string matcher ------------------------------------------------------------------------------- MatchersTests.cpp: ............................................................................... MatchersTests.cpp:: FAILED: CHECK_THAT( testStringForMatching(), EndsWith( "this" ) ) with expansion: "this string contains 'abc' as a substring" ends with: "this" ------------------------------------------------------------------------------- Equality checks that should fail ------------------------------------------------------------------------------- ConditionTests.cpp: ............................................................................... ConditionTests.cpp:: FAILED: CHECK( data.int_seven == 6 ) with expansion: 7 == 6 ConditionTests.cpp:: FAILED: CHECK( data.int_seven == 8 ) with expansion: 7 == 8 ConditionTests.cpp:: FAILED: CHECK( data.int_seven == 0 ) with expansion: 7 == 0 ConditionTests.cpp:: FAILED: CHECK( data.float_nine_point_one == Approx( 9.11f ) ) with expansion: 9.1f == Approx( 9.1099996567 ) ConditionTests.cpp:: FAILED: CHECK( data.float_nine_point_one == Approx( 9.0f ) ) with expansion: 9.1f == Approx( 9.0 ) ConditionTests.cpp:: FAILED: CHECK( data.float_nine_point_one == Approx( 1 ) ) with expansion: 9.1f == Approx( 1.0 ) ConditionTests.cpp:: FAILED: CHECK( data.float_nine_point_one == Approx( 0 ) ) with expansion: 9.1f == Approx( 0.0 ) ConditionTests.cpp:: FAILED: CHECK( data.double_pi == Approx( 3.1415 ) ) with expansion: 3.1415926535 == Approx( 3.1415 ) ConditionTests.cpp:: FAILED: CHECK( data.str_hello == "goodbye" ) with expansion: "hello" == "goodbye" ConditionTests.cpp:: FAILED: CHECK( data.str_hello == "hell" ) with expansion: "hello" == "hell" ConditionTests.cpp:: FAILED: CHECK( data.str_hello == "hello1" ) with expansion: "hello" == "hello1" ConditionTests.cpp:: FAILED: CHECK( data.str_hello.size() == 6 ) with expansion: 5 == 6 ConditionTests.cpp:: FAILED: CHECK( x == Approx( 1.301 ) ) with expansion: 1.3 == Approx( 1.301 ) ------------------------------------------------------------------------------- Equality checks that should succeed ------------------------------------------------------------------------------- ConditionTests.cpp: ............................................................................... ConditionTests.cpp:: PASSED: REQUIRE( data.int_seven == 7 ) with expansion: 7 == 7 ConditionTests.cpp:: PASSED: REQUIRE( data.float_nine_point_one == Approx( 9.1f ) ) with expansion: 9.1f == Approx( 9.1000003815 ) ConditionTests.cpp:: PASSED: REQUIRE( data.double_pi == Approx( 3.1415926535 ) ) with expansion: 3.1415926535 == Approx( 3.1415926535 ) ConditionTests.cpp:: PASSED: REQUIRE( data.str_hello == "hello" ) with expansion: "hello" == "hello" ConditionTests.cpp:: PASSED: REQUIRE( "hello" == data.str_hello ) with expansion: "hello" == "hello" ConditionTests.cpp:: PASSED: REQUIRE( data.str_hello.size() == 5 ) with expansion: 5 == 5 ConditionTests.cpp:: PASSED: REQUIRE( x == Approx( 1.3 ) ) with expansion: 1.3 == Approx( 1.3 ) ------------------------------------------------------------------------------- Equals ------------------------------------------------------------------------------- MatchersTests.cpp: ............................................................................... MatchersTests.cpp:: 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" ------------------------------------------------------------------------------- Equals string matcher ------------------------------------------------------------------------------- MatchersTests.cpp: ............................................................................... MatchersTests.cpp:: FAILED: CHECK_THAT( testStringForMatching(), Equals( "something else" ) ) with expansion: "this string contains 'abc' as a substring" equals: "something else" ------------------------------------------------------------------------------- Exception matchers that fail No exception ------------------------------------------------------------------------------- MatchersTests.cpp: ............................................................................... MatchersTests.cpp:: FAILED: CHECK_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } ) because no exception was thrown where one was expected: MatchersTests.cpp:: FAILED: REQUIRE_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } ) because no exception was thrown where one was expected: ------------------------------------------------------------------------------- Exception matchers that fail Type mismatch ------------------------------------------------------------------------------- MatchersTests.cpp: ............................................................................... MatchersTests.cpp:: FAILED: CHECK_THROWS_MATCHES( throwsAsInt(1), SpecialException, ExceptionMatcher{ 1 } ) due to unexpected exception with message: Unknown exception MatchersTests.cpp:: FAILED: REQUIRE_THROWS_MATCHES( throwsAsInt(1), SpecialException, ExceptionMatcher{ 1 } ) due to unexpected exception with message: Unknown exception ------------------------------------------------------------------------------- Exception matchers that fail Contents are wrong ------------------------------------------------------------------------------- MatchersTests.cpp: ............................................................................... MatchersTests.cpp:: FAILED: CHECK_THROWS_MATCHES( throws(3), SpecialException, ExceptionMatcher{ 1 } ) with expansion: {?} special exception has value of 1 MatchersTests.cpp:: FAILED: REQUIRE_THROWS_MATCHES( throws(4), SpecialException, ExceptionMatcher{ 1 } ) with expansion: {?} special exception has value of 1 ------------------------------------------------------------------------------- Exception matchers that succeed ------------------------------------------------------------------------------- MatchersTests.cpp: ............................................................................... MatchersTests.cpp:: PASSED: CHECK_THROWS_MATCHES( throws(1), SpecialException, ExceptionMatcher{ 1 } ) with expansion: {?} special exception has value of 1 MatchersTests.cpp:: PASSED: REQUIRE_THROWS_MATCHES( throws(2), SpecialException, ExceptionMatcher{ 2 } ) with expansion: {?} special exception has value of 2 ------------------------------------------------------------------------------- Exception messages can be tested for exact match ------------------------------------------------------------------------------- ExceptionTests.cpp: ............................................................................... ExceptionTests.cpp:: PASSED: REQUIRE_THROWS_WITH( thisThrows(), "expected exception" ) with expansion: "expected exception" equals: "expected exception" ------------------------------------------------------------------------------- Exception messages can be tested for different case ------------------------------------------------------------------------------- ExceptionTests.cpp: ............................................................................... ExceptionTests.cpp:: PASSED: REQUIRE_THROWS_WITH( thisThrows(), Equals( "expecteD Exception", Catch::CaseSensitive::No ) ) with expansion: "expected exception" equals: "expected exception" (case insensitive) ------------------------------------------------------------------------------- Exception messages can be tested for wildcarded ------------------------------------------------------------------------------- ExceptionTests.cpp: ............................................................................... ExceptionTests.cpp:: PASSED: REQUIRE_THROWS_WITH( thisThrows(), StartsWith( "expected" ) ) with expansion: "expected exception" starts with: "expected" ExceptionTests.cpp:: PASSED: REQUIRE_THROWS_WITH( thisThrows(), EndsWith( "exception" ) ) with expansion: "expected exception" ends with: "exception" ExceptionTests.cpp:: PASSED: REQUIRE_THROWS_WITH( thisThrows(), Contains( "except" ) ) with expansion: "expected exception" contains: "except" ExceptionTests.cpp:: PASSED: REQUIRE_THROWS_WITH( thisThrows(), Contains( "exCept", Catch::CaseSensitive::No ) ) with expansion: "expected exception" contains: "except" (case insensitive) ------------------------------------------------------------------------------- Expected exceptions that don't throw or unexpected exceptions fail the test ------------------------------------------------------------------------------- ExceptionTests.cpp: ............................................................................... ExceptionTests.cpp:: FAILED: CHECK_THROWS_AS( thisThrows(), std::string ) due to unexpected exception with message: expected exception ExceptionTests.cpp:: FAILED: CHECK_THROWS_AS( thisDoesntThrow(), std::domain_error ) because no exception was thrown where one was expected: ExceptionTests.cpp:: FAILED: CHECK_NOTHROW( thisThrows() ) due to unexpected exception with message: expected exception ------------------------------------------------------------------------------- FAIL aborts the test ------------------------------------------------------------------------------- MessageTests.cpp: ............................................................................... MessageTests.cpp:: FAILED: explicitly with message: This is a failure ------------------------------------------------------------------------------- FAIL does not require an argument ------------------------------------------------------------------------------- MessageTests.cpp: ............................................................................... MessageTests.cpp:: FAILED: ------------------------------------------------------------------------------- FAIL_CHECK does not abort the test ------------------------------------------------------------------------------- MessageTests.cpp: ............................................................................... MessageTests.cpp:: FAILED: explicitly with message: This is a failure MessageTests.cpp:: warning: This message appears in the output ------------------------------------------------------------------------------- Factorials are computed ------------------------------------------------------------------------------- MiscTests.cpp: ............................................................................... MiscTests.cpp:: PASSED: REQUIRE( Factorial(0) == 1 ) with expansion: 1 == 1 MiscTests.cpp:: PASSED: REQUIRE( Factorial(1) == 1 ) with expansion: 1 == 1 MiscTests.cpp:: PASSED: REQUIRE( Factorial(2) == 2 ) with expansion: 2 == 2 MiscTests.cpp:: PASSED: REQUIRE( Factorial(3) == 6 ) with expansion: 6 == 6 MiscTests.cpp:: PASSED: REQUIRE( Factorial(10) == 3628800 ) with expansion: 3628800 (0x) == 3628800 (0x) ------------------------------------------------------------------------------- Greater-than inequalities with different epsilons ------------------------------------------------------------------------------- ApproxTests.cpp: ............................................................................... ApproxTests.cpp:: PASSED: REQUIRE( d >= Approx( 1.22 ) ) with expansion: 1.23 >= Approx( 1.22 ) ApproxTests.cpp:: PASSED: REQUIRE( d >= Approx( 1.23 ) ) with expansion: 1.23 >= Approx( 1.23 ) ApproxTests.cpp:: PASSED: REQUIRE_FALSE( d >= Approx( 1.24 ) ) with expansion: !(1.23 >= Approx( 1.24 )) ApproxTests.cpp:: PASSED: REQUIRE( d >= Approx( 1.24 ).epsilon(0.1) ) with expansion: 1.23 >= Approx( 1.24 ) ------------------------------------------------------------------------------- INFO and WARN do not abort tests ------------------------------------------------------------------------------- MessageTests.cpp: ............................................................................... MessageTests.cpp:: warning: this is a message this is a warning ------------------------------------------------------------------------------- INFO gets logged on failure ------------------------------------------------------------------------------- MessageTests.cpp: ............................................................................... MessageTests.cpp:: FAILED: REQUIRE( a == 1 ) with expansion: 2 == 1 with messages: this message should be logged so should this ------------------------------------------------------------------------------- INFO gets logged on failure, even if captured before successful assertions ------------------------------------------------------------------------------- MessageTests.cpp: ............................................................................... MessageTests.cpp:: PASSED: CHECK( a == 2 ) with expansion: 2 == 2 with message: this message may be logged later MessageTests.cpp:: FAILED: CHECK( a == 1 ) with expansion: 2 == 1 with messages: this message may be logged later this message should be logged MessageTests.cpp:: FAILED: CHECK( a == 0 ) with expansion: 2 == 0 with messages: this message may be logged later this message should be logged and this, but later MessageTests.cpp:: PASSED: CHECK( a == 2 ) with expansion: 2 == 2 with messages: this message may be logged later this message should be logged and this, but later but not this ------------------------------------------------------------------------------- INFO is reset for each loop ------------------------------------------------------------------------------- MessageTests.cpp: ............................................................................... MessageTests.cpp:: PASSED: REQUIRE( i < 10 ) with expansion: 0 < 10 with messages: current counter 0 i := 0 MessageTests.cpp:: PASSED: REQUIRE( i < 10 ) with expansion: 1 < 10 with messages: current counter 1 i := 1 MessageTests.cpp:: PASSED: REQUIRE( i < 10 ) with expansion: 2 < 10 with messages: current counter 2 i := 2 MessageTests.cpp:: PASSED: REQUIRE( i < 10 ) with expansion: 3 < 10 with messages: current counter 3 i := 3 MessageTests.cpp:: PASSED: REQUIRE( i < 10 ) with expansion: 4 < 10 with messages: current counter 4 i := 4 MessageTests.cpp:: PASSED: REQUIRE( i < 10 ) with expansion: 5 < 10 with messages: current counter 5 i := 5 MessageTests.cpp:: PASSED: REQUIRE( i < 10 ) with expansion: 6 < 10 with messages: current counter 6 i := 6 MessageTests.cpp:: PASSED: REQUIRE( i < 10 ) with expansion: 7 < 10 with messages: current counter 7 i := 7 MessageTests.cpp:: PASSED: REQUIRE( i < 10 ) with expansion: 8 < 10 with messages: current counter 8 i := 8 MessageTests.cpp:: PASSED: REQUIRE( i < 10 ) with expansion: 9 < 10 with messages: current counter 9 i := 9 MessageTests.cpp:: FAILED: REQUIRE( i < 10 ) with expansion: 10 < 10 with messages: current counter 10 i := 10 ------------------------------------------------------------------------------- Inequality checks that should fail ------------------------------------------------------------------------------- ConditionTests.cpp: ............................................................................... ConditionTests.cpp:: FAILED: CHECK( data.int_seven != 7 ) with expansion: 7 != 7 ConditionTests.cpp:: FAILED: CHECK( data.float_nine_point_one != Approx( 9.1f ) ) with expansion: 9.1f != Approx( 9.1000003815 ) ConditionTests.cpp:: FAILED: CHECK( data.double_pi != Approx( 3.1415926535 ) ) with expansion: 3.1415926535 != Approx( 3.1415926535 ) ConditionTests.cpp:: FAILED: CHECK( data.str_hello != "hello" ) with expansion: "hello" != "hello" ConditionTests.cpp:: FAILED: CHECK( data.str_hello.size() != 5 ) with expansion: 5 != 5 ------------------------------------------------------------------------------- Inequality checks that should succeed ------------------------------------------------------------------------------- ConditionTests.cpp: ............................................................................... ConditionTests.cpp:: PASSED: REQUIRE( data.int_seven != 6 ) with expansion: 7 != 6 ConditionTests.cpp:: PASSED: REQUIRE( data.int_seven != 8 ) with expansion: 7 != 8 ConditionTests.cpp:: PASSED: REQUIRE( data.float_nine_point_one != Approx( 9.11f ) ) with expansion: 9.1f != Approx( 9.1099996567 ) ConditionTests.cpp:: PASSED: REQUIRE( data.float_nine_point_one != Approx( 9.0f ) ) with expansion: 9.1f != Approx( 9.0 ) ConditionTests.cpp:: PASSED: REQUIRE( data.float_nine_point_one != Approx( 1 ) ) with expansion: 9.1f != Approx( 1.0 ) ConditionTests.cpp:: PASSED: REQUIRE( data.float_nine_point_one != Approx( 0 ) ) with expansion: 9.1f != Approx( 0.0 ) ConditionTests.cpp:: PASSED: REQUIRE( data.double_pi != Approx( 3.1415 ) ) with expansion: 3.1415926535 != Approx( 3.1415 ) ConditionTests.cpp:: PASSED: REQUIRE( data.str_hello != "goodbye" ) with expansion: "hello" != "goodbye" ConditionTests.cpp:: PASSED: REQUIRE( data.str_hello != "hell" ) with expansion: "hello" != "hell" ConditionTests.cpp:: PASSED: REQUIRE( data.str_hello != "hello1" ) with expansion: "hello" != "hello1" ConditionTests.cpp:: PASSED: REQUIRE( data.str_hello.size() != 6 ) with expansion: 5 != 6 ------------------------------------------------------------------------------- Less-than inequalities with different epsilons ------------------------------------------------------------------------------- ApproxTests.cpp: ............................................................................... ApproxTests.cpp:: PASSED: REQUIRE( d <= Approx( 1.24 ) ) with expansion: 1.23 <= Approx( 1.24 ) ApproxTests.cpp:: PASSED: REQUIRE( d <= Approx( 1.23 ) ) with expansion: 1.23 <= Approx( 1.23 ) ApproxTests.cpp:: PASSED: REQUIRE_FALSE( d <= Approx( 1.22 ) ) with expansion: !(1.23 <= Approx( 1.22 )) ApproxTests.cpp:: PASSED: REQUIRE( d <= Approx( 1.22 ).epsilon(0.1) ) with expansion: 1.23 <= Approx( 1.22 ) ------------------------------------------------------------------------------- ManuallyRegistered ------------------------------------------------------------------------------- TestMain.cpp: ............................................................................... TestMain.cpp:: PASSED: with message: was called ------------------------------------------------------------------------------- Matchers can be (AllOf) composed with the && operator ------------------------------------------------------------------------------- MatchersTests.cpp: ............................................................................... MatchersTests.cpp:: PASSED: CHECK_THAT( testStringForMatching(), Contains( "string" ) && Contains( "abc" ) && Contains( "substring" ) && Contains( "contains" ) ) with expansion: "this string contains 'abc' as a substring" ( contains: "string" and contains: "abc" and contains: "substring" and contains: "contains" ) ------------------------------------------------------------------------------- Matchers can be (AnyOf) composed with the || operator ------------------------------------------------------------------------------- MatchersTests.cpp: ............................................................................... MatchersTests.cpp:: PASSED: CHECK_THAT( testStringForMatching(), Contains( "string" ) || Contains( "different" ) || Contains( "random" ) ) with expansion: "this string contains 'abc' as a substring" ( contains: "string" or contains: "different" or contains: "random" ) MatchersTests.cpp:: PASSED: CHECK_THAT( testStringForMatching2(), Contains( "string" ) || Contains( "different" ) || Contains( "random" ) ) with expansion: "some completely different text that contains one common word" ( contains: "string" or contains: "different" or contains: "random" ) ------------------------------------------------------------------------------- Matchers can be composed with both && and || ------------------------------------------------------------------------------- MatchersTests.cpp: ............................................................................... MatchersTests.cpp:: PASSED: CHECK_THAT( testStringForMatching(), ( Contains( "string" ) || Contains( "different" ) ) && Contains( "substring" ) ) with expansion: "this string contains 'abc' as a substring" ( ( contains: "string" or contains: "different" ) and contains: "substring" ) ------------------------------------------------------------------------------- Matchers can be composed with both && and || - failing ------------------------------------------------------------------------------- MatchersTests.cpp: ............................................................................... MatchersTests.cpp:: FAILED: CHECK_THAT( testStringForMatching(), ( Contains( "string" ) || Contains( "different" ) ) && Contains( "random" ) ) with expansion: "this string contains 'abc' as a substring" ( ( contains: "string" or contains: "different" ) and contains: "random" ) ------------------------------------------------------------------------------- Matchers can be negated (Not) with the ! operator ------------------------------------------------------------------------------- MatchersTests.cpp: ............................................................................... MatchersTests.cpp:: PASSED: CHECK_THAT( testStringForMatching(), !Contains( "different" ) ) with expansion: "this string contains 'abc' as a substring" not contains: "different" ------------------------------------------------------------------------------- Matchers can be negated (Not) with the ! operator - failing ------------------------------------------------------------------------------- MatchersTests.cpp: ............................................................................... MatchersTests.cpp:: FAILED: CHECK_THAT( testStringForMatching(), !Contains( "substring" ) ) with expansion: "this string contains 'abc' as a substring" not contains: "substring" ------------------------------------------------------------------------------- Mismatching exception messages failing the test ------------------------------------------------------------------------------- ExceptionTests.cpp: ............................................................................... ExceptionTests.cpp:: PASSED: REQUIRE_THROWS_WITH( thisThrows(), "expected exception" ) with expansion: "expected exception" equals: "expected exception" ExceptionTests.cpp:: FAILED: REQUIRE_THROWS_WITH( thisThrows(), "should fail" ) with expansion: "expected exception" equals: "should fail" ------------------------------------------------------------------------------- Nice descriptive name ------------------------------------------------------------------------------- MiscTests.cpp: ............................................................................... MiscTests.cpp:: warning: This one ran ------------------------------------------------------------------------------- Non-std exceptions can be translated ------------------------------------------------------------------------------- ExceptionTests.cpp: ............................................................................... ExceptionTests.cpp:: FAILED: due to unexpected exception with message: custom exception ------------------------------------------------------------------------------- Objects that evaluated in boolean contexts can be checked ------------------------------------------------------------------------------- TrickyTests.cpp: ............................................................................... TrickyTests.cpp:: PASSED: CHECK( True ) with expansion: {?} TrickyTests.cpp:: PASSED: CHECK( !False ) with expansion: true TrickyTests.cpp:: PASSED: CHECK_FALSE( False ) with expansion: !{?} ------------------------------------------------------------------------------- Operators at different namespace levels not hijacked by Koenig lookup ------------------------------------------------------------------------------- TrickyTests.cpp: ............................................................................... TrickyTests.cpp:: PASSED: REQUIRE( 0x == o ) with expansion: 3221225472 (0x) == {?} ------------------------------------------------------------------------------- Ordering comparison checks that should fail ------------------------------------------------------------------------------- ConditionTests.cpp: ............................................................................... ConditionTests.cpp:: FAILED: CHECK( data.int_seven > 7 ) with expansion: 7 > 7 ConditionTests.cpp: