diff options
| author | Martin Hořeňovský | 2020-02-02 15:04:19 +0100 |
|---|---|---|
| committer | Martin Hořeňovský | 2020-02-02 15:04:19 +0100 |
| commit | 1327946785cd33dcd0ed3142dcb6e8849ccbc893 (patch) | |
| tree | e575e464ee8b4d6e17d7d79329d3e7c6123ccde6 /tests | |
| parent | a49ab0a162b2966b83f0787b2b76a718c8d2ffb5 (diff) | |
| download | catch3-1327946785cd33dcd0ed3142dcb6e8849ccbc893.tar.gz | |
Add all in-repo reporters to approval tests
Diffstat (limited to 'tests')
| -rw-r--r-- | tests/SelfTest/Baselines/automake.sw.approved.txt | 313 | ||||
| -rw-r--r-- | tests/SelfTest/Baselines/tap.sw.approved.txt | 3338 | ||||
| -rw-r--r-- | tests/SelfTest/Baselines/teamcity.sw.approved.txt | 770 |
3 files changed, 4421 insertions, 0 deletions
diff --git a/tests/SelfTest/Baselines/automake.sw.approved.txt b/tests/SelfTest/Baselines/automake.sw.approved.txt new file mode 100644 index 00000000..96a0a795 --- /dev/null +++ b/tests/SelfTest/Baselines/automake.sw.approved.txt @@ -0,0 +1,313 @@ +:test-result: PASS # A test name that starts with a # +:test-result: PASS #1005: Comparing pointer to int and long (NULL can be either on various systems) +:test-result: PASS #1027 +:test-result: PASS #1027: Bitfields can be captured +:test-result: PASS #1147 +:test-result: PASS #1175 - Hidden Test +:test-result: PASS #1238 +:test-result: PASS #1245 +:test-result: PASS #1319: Sections can have description (even if it is not saved +:test-result: PASS #1403 +:test-result: FAIL #1455 - INFO and WARN can start with a linebreak +This would not be caught previously +Nor would this +:test-result: FAIL #1514: stderr/stdout is not captured in tests aborted by an exception +:test-result: PASS #1548 +:test-result: XFAIL #748 - captures with unexpected exceptions +:test-result: PASS #809 +:test-result: PASS #833 +:test-result: XFAIL #835 -- errno should not be touched by Catch +:test-result: PASS #872 +:test-result: PASS #961 -- Dynamically created sections should all be reported +:test-result: FAIL 'Not' checks that should fail +:test-result: PASS 'Not' checks that should succeed +:test-result: PASS (unimplemented) static bools can be evaluated +:test-result: PASS 3x3x3 ints +:test-result: FAIL A METHOD_AS_TEST_CASE based test run that fails +:test-result: PASS A METHOD_AS_TEST_CASE based test run that succeeds +:test-result: FAIL A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<float> +:test-result: FAIL A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int> +:test-result: FAIL A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float> +:test-result: FAIL A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int> +:test-result: PASS A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<float> +:test-result: PASS A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<int> +:test-result: PASS A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<float> +:test-result: PASS A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<int> +:test-result: FAIL A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<float, 6> +:test-result: FAIL A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2> +:test-result: FAIL A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6> +:test-result: FAIL A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2> +:test-result: PASS A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<float,6> +:test-result: PASS A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<int,2> +:test-result: PASS A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<float,6> +:test-result: PASS A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<int,2> +:test-result: FAIL A TEMPLATE_TEST_CASE_METHOD based test run that fails - double +:test-result: FAIL A TEMPLATE_TEST_CASE_METHOD based test run that fails - float +:test-result: FAIL A TEMPLATE_TEST_CASE_METHOD based test run that fails - int +:test-result: PASS A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double +:test-result: PASS A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - float +:test-result: PASS A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - int +:test-result: FAIL A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1 +:test-result: FAIL A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3 +:test-result: FAIL A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6 +:test-result: PASS A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1 +:test-result: PASS A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 3 +:test-result: PASS A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 6 +:test-result: FAIL A TEST_CASE_METHOD based test run that fails +:test-result: PASS A TEST_CASE_METHOD based test run that succeeds +:test-result: PASS A Template product test case - Foo<float> +:test-result: PASS A Template product test case - Foo<int> +:test-result: PASS A Template product test case - std::vector<float> +:test-result: PASS A Template product test case - std::vector<int> +:test-result: PASS A Template product test case with array signature - Bar<float, 42> +:test-result: PASS A Template product test case with array signature - Bar<int, 9> +:test-result: PASS A Template product test case with array signature - std::array<float, 42> +:test-result: PASS A Template product test case with array signature - std::array<int, 9> +:test-result: PASS A comparison that uses literals instead of the normal constructor +:test-result: FAIL A couple of nested sections followed by a failure +:test-result: FAIL A failing expression with a non streamable type is still captured +:test-result: PASS Absolute margin +:test-result: FAIL An empty test with no assertions +:test-result: PASS An expression with side-effects should only be evaluated once +:test-result: FAIL An unchecked exception reports the line of the last assertion +:test-result: PASS Anonymous test case 1 +:test-result: PASS Approx setters validate their arguments +:test-result: PASS Approx with exactly-representable margin +:test-result: PASS Approximate PI +:test-result: PASS Approximate comparisons with different epsilons +:test-result: PASS Approximate comparisons with floats +:test-result: PASS Approximate comparisons with ints +:test-result: PASS Approximate comparisons with mixed numeric types +:test-result: PASS Arbitrary predicate matcher +:test-result: PASS Assertions then sections +:test-result: PASS CAPTURE can deal with complex expressions +:test-result: PASS CAPTURE can deal with complex expressions involving commas +:test-result: PASS CAPTURE parses string and character constants +:test-result: PASS Capture and info messages +:test-result: PASS Character pretty printing +:test-result: PASS Commas in various macros are allowed +:test-result: PASS Comparing function pointers +:test-result: PASS Comparison ops +:test-result: PASS Comparison with explicitly convertible types +:test-result: PASS Comparisons between ints where one side is computed +:test-result: PASS Comparisons between unsigned ints and negative signed ints match c++ standard behaviour +:test-result: PASS Comparisons with int literals don't warn when mixing signed/ unsigned +:test-result: FAIL Contains string matcher +:test-result: PASS Copy and then generate a range +:test-result: FAIL Custom exceptions can be translated when testing for nothrow +:test-result: FAIL Custom exceptions can be translated when testing for throwing as something else +:test-result: FAIL Custom std-exceptions can be custom translated +:test-result: PASS Default scale is invisible to comparison +:test-result: PASS Directly creating an EnumInfo +:test-result: FAIL EndsWith string matcher +:test-result: PASS Enums can quickly have stringification enabled using REGISTER_ENUM +:test-result: PASS Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM +:test-result: PASS Epsilon only applies to Approx's value +:test-result: XFAIL Equality checks that should fail +:test-result: PASS Equality checks that should succeed +:test-result: PASS Equals +:test-result: FAIL Equals string matcher +:test-result: PASS Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified +:test-result: FAIL Exception matchers that fail +:test-result: PASS Exception matchers that succeed +:test-result: PASS Exception messages can be tested for +:test-result: PASS Exceptions matchers +:test-result: FAIL Expected exceptions that don't throw or unexpected exceptions fail the test +:test-result: FAIL FAIL aborts the test +:test-result: FAIL FAIL does not require an argument +:test-result: FAIL FAIL_CHECK does not abort the test +:test-result: PASS Factorials are computed +:test-result: PASS Floating point matchers: double +:test-result: PASS Floating point matchers: float +:test-result: PASS Generators -- adapters +:test-result: PASS Generators -- simple +:test-result: PASS Generators internals +:test-result: PASS Greater-than inequalities with different epsilons +:test-result: FAIL INFO and WARN do not abort tests +:test-result: FAIL INFO gets logged on failure +:test-result: FAIL INFO gets logged on failure, even if captured before successful assertions +:test-result: FAIL INFO is reset for each loop +:test-result: XFAIL Inequality checks that should fail +:test-result: PASS Inequality checks that should succeed +:test-result: PASS Less-than inequalities with different epsilons +:test-result: PASS ManuallyRegistered +:test-result: PASS Matchers can be (AllOf) composed with the && operator +:test-result: PASS Matchers can be (AnyOf) composed with the || operator +:test-result: PASS Matchers can be composed with both && and || +:test-result: FAIL Matchers can be composed with both && and || - failing +:test-result: PASS Matchers can be negated (Not) with the ! operator +:test-result: FAIL Matchers can be negated (Not) with the ! operator - failing +:test-result: FAIL Mismatching exception messages failing the test +:test-result: PASS Nested generators and captured variables +:test-result: FAIL Nice descriptive name +:test-result: FAIL Non-std exceptions can be translated +:test-result: PASS Objects that evaluated in boolean contexts can be checked +:test-result: PASS Optionally static assertions +:test-result: FAIL Ordering comparison checks that should fail +:test-result: PASS Ordering comparison checks that should succeed +:test-result: PASS Our PCG implementation provides expected results for known seeds +:test-result: FAIL Output from all sections is reported +:test-result: PASS Parse test names and tags +:test-result: PASS Pointers can be compared to null +:test-result: PASS Precision of floating point stringification can be set +:test-result: PASS Predicate matcher can accept const char* +:test-result: PASS Process can be configured on command line +:test-result: PASS Product with differing arities - std::tuple<int, double, float> +:test-result: PASS Product with differing arities - std::tuple<int, double> +:test-result: PASS Product with differing arities - std::tuple<int> +:test-result: FAIL Reconstruction should be based on stringification: #914 +:test-result: FAIL Regex string matcher +:test-result: PASS Regression test #1 +:test-result: PASS SUCCEED counts as a test pass +:test-result: PASS SUCCEED does not require an argument +:test-result: PASS Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods +:test-result: PASS Scenario: Do that thing with the thing +:test-result: PASS Scenario: This is a really long scenario name to see how the list command deals with wrapping +:test-result: PASS Scenario: Vector resizing affects size and capacity +A string sent directly to stdout +A string sent directly to stderr +A string sent to stderr via clog +:test-result: FAIL Sends stuff to stdout and stderr +:test-result: PASS Some simple comparisons between doubles +Message from section one +Message from section two +:test-result: FAIL Standard output from all sections is reported +:test-result: FAIL StartsWith string matcher +:test-result: PASS Static arrays are convertible to string +:test-result: PASS String matchers +:test-result: PASS StringRef +:test-result: PASS StringRef at compilation time +:test-result: PASS Stringifying std::chrono::duration helpers +:test-result: PASS Stringifying std::chrono::duration with weird ratios +:test-result: PASS Stringifying std::chrono::time_point<system_clock> +:test-result: FAIL Tabs and newlines show in output +:test-result: PASS Tag alias can be registered against tag patterns +:test-result: PASS Template test case method with test types specified inside std::tuple - MyTypes - 0 +:test-result: PASS Template test case method with test types specified inside std::tuple - MyTypes - 1 +:test-result: PASS Template test case method with test types specified inside std::tuple - MyTypes - 2 +:test-result: PASS Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 0 +:test-result: PASS Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 1 +:test-result: PASS Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 0 +:test-result: PASS Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 1 +:test-result: PASS Template test case with test types specified inside std::tuple - MyTypes - 0 +:test-result: PASS Template test case with test types specified inside std::tuple - MyTypes - 1 +:test-result: PASS Template test case with test types specified inside std::tuple - MyTypes - 2 +:test-result: PASS TemplateTest: vectors can be sized and resized - float +:test-result: PASS TemplateTest: vectors can be sized and resized - int +:test-result: PASS TemplateTest: vectors can be sized and resized - std::string +:test-result: PASS TemplateTest: vectors can be sized and resized - std::tuple<int,float> +:test-result: PASS TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6 +:test-result: PASS TemplateTestSig: vectors can be sized and resized - float,4 +:test-result: PASS TemplateTestSig: vectors can be sized and resized - int,5 +:test-result: PASS TemplateTestSig: vectors can be sized and resized - std::string,15 +:test-result: PASS Test case with one argument +:test-result: PASS Test enum bit values +:test-result: PASS Test with special, characters "in name +:test-result: FAIL The NO_FAIL macro reports a failure but does not fail the test +:test-result: FAIL This test 'should' fail but doesn't +:test-result: FAIL Thrown string literals are translated +:test-result: PASS Tracker +:test-result: PASS Trim strings +:test-result: FAIL Unexpected exceptions can be translated +:test-result: PASS Use a custom approx +:test-result: PASS Variadic macros +:test-result: PASS Vector Approx matcher +:test-result: FAIL Vector Approx matcher -- failing +:test-result: PASS Vector matchers +:test-result: FAIL Vector matchers that fail +:test-result: PASS When checked exceptions are thrown they can be expected or unexpected +:test-result: FAIL When unchecked exceptions are thrown directly they are always failures +:test-result: FAIL When unchecked exceptions are thrown during a CHECK the test should continue +:test-result: FAIL When unchecked exceptions are thrown during a REQUIRE the test should abort fail +:test-result: FAIL When unchecked exceptions are thrown from functions they are always failures +:test-result: FAIL When unchecked exceptions are thrown from sections they are always failures +:test-result: FAIL When unchecked exceptions are thrown, but caught, they do not affect the test +:test-result: FAIL Where the LHS is not a simple value +:test-result: FAIL Where there is more to the expression after the RHS +:test-result: PASS X/level/0/a +:test-result: PASS X/level/0/b +:test-result: PASS X/level/1/a +:test-result: PASS X/level/1/b +:test-result: PASS XmlEncode +:test-result: PASS array<int, N> -> toString +:test-result: PASS atomic if +:test-result: PASS boolean member +:test-result: PASS checkedElse +:test-result: FAIL checkedElse, failing +:test-result: PASS checkedIf +:test-result: FAIL checkedIf, failing +:test-result: PASS comparisons between const int variables +:test-result: PASS comparisons between int variables +:test-result: PASS even more nested SECTION tests +:test-result: FAIL first tag +loose text artifact +:test-result: FAIL has printf +:test-result: FAIL just failure +:test-result: FAIL just failure after unscoped info +:test-result: FAIL just info +:test-result: FAIL just unscoped info +:test-result: PASS long long +:test-result: FAIL looped SECTION tests +:test-result: FAIL looped tests +:test-result: FAIL mix info, unscoped info and warning +:test-result: FAIL more nested SECTION tests +:test-result: PASS nested SECTION tests +:test-result: PASS non streamable - with conv. op +:test-result: PASS non-copyable objects +:test-result: PASS not allowed +:test-result: FAIL not prints unscoped info from previous failures +:test-result: PASS null strings +:test-result: PASS null_ptr +:test-result: PASS pair<pair<int,const char *,pair<std::string,int> > -> toString +:test-result: PASS parseEnums +:test-result: PASS pointer to class +:test-result: PASS print unscoped info if passing unscoped info is printed +:test-result: FAIL prints unscoped info on failure +:test-result: FAIL prints unscoped info only for the first assertion +:test-result: PASS random SECTION tests +:test-result: PASS replaceInPlace +:test-result: FAIL second tag +:test-result: FAIL send a single char to INFO +:test-result: FAIL sends information to INFO +:test-result: PASS shortened hide tags are split apart +:test-result: PASS splitString +:test-result: FAIL stacks unscoped info in loops +:test-result: PASS std::map is convertible string +:test-result: PASS std::pair<int,const std::string> -> toString +:test-result: PASS std::pair<int,std::string> -> toString +:test-result: PASS std::set is convertible string +:test-result: PASS std::vector<std::pair<std::string,int> > -> toString +:test-result: FAIL string literals of different sizes can be compared +:test-result: PASS stringify ranges +:test-result: PASS stringify( has_maker ) +:test-result: PASS stringify( has_maker_and_operator ) +:test-result: PASS stringify( has_neither ) +:test-result: PASS stringify( has_operator ) +:test-result: PASS stringify( has_template_operator ) +:test-result: PASS stringify( vectors<has_maker> ) +:test-result: PASS stringify( vectors<has_maker_and_operator> ) +:test-result: PASS stringify( vectors<has_operator> ) +:test-result: PASS strlen3 +:test-result: PASS tables +:test-result: FAIL thrown std::strings are translated +:test-result: PASS toString on const wchar_t const pointer returns the string contents +:test-result: PASS toString on const wchar_t pointer returns the string contents +:test-result: PASS toString on wchar_t const pointer returns the string contents +:test-result: PASS toString on wchar_t returns the string contents +:test-result: PASS toString(enum class w/operator<<) +:test-result: PASS toString(enum class) +:test-result: PASS toString(enum w/operator<<) +:test-result: PASS toString(enum) +:test-result: PASS tuple<> +:test-result: PASS tuple<float,int> +:test-result: PASS tuple<int> +:test-result: PASS tuple<0,int,const char *> +:test-result: PASS tuple<string,string> +:test-result: PASS tuple<tuple<int>,tuple<>,float> +:test-result: PASS vec<vec<string,alloc>> -> toString +:test-result: PASS vector<bool> -> toString +:test-result: PASS vector<int,allocator> -> toString +:test-result: PASS vector<int> -> toString +:test-result: PASS vector<string> -> toString +:test-result: PASS vectors can be sized and resized +:test-result: PASS xmlentitycheck diff --git a/tests/SelfTest/Baselines/tap.sw.approved.txt b/tests/SelfTest/Baselines/tap.sw.approved.txt new file mode 100644 index 00000000..9560c81a --- /dev/null +++ b/tests/SelfTest/Baselines/tap.sw.approved.txt @@ -0,0 +1,3338 @@ +# # A test name that starts with a # +ok 1 - with 1 message: 'yay' +# #1005: Comparing pointer to int and long (NULL can be either on various systems) +ok 2 - fptr == 0 for: 0 == 0 +# #1005: Comparing pointer to int and long (NULL can be either on various systems) +ok 3 - fptr == 0l for: 0 == 0 +# #1027 +ok 4 - y.v == 0 for: 0 == 0 +# #1027 +ok 5 - 0 == y.v for: 0 == 0 +# #1027: Bitfields can be captured +ok 6 - y.v == 0 for: 0 == 0 +# #1027: Bitfields can be captured +ok 7 - 0 == y.v for: 0 == 0 +# #1147 +ok 8 - t1 == t2 for: {?} == {?} +# #1147 +ok 9 - t1 != t2 for: {?} != {?} +# #1147 +ok 10 - t1 < t2 for: {?} < {?} +# #1147 +ok 11 - t1 > t2 for: {?} > {?} +# #1147 +ok 12 - t1 <= t2 for: {?} <= {?} +# #1147 +ok 13 - t1 >= t2 for: {?} >= {?} +# #1175 - Hidden Test +ok 14 - +# #1238 +ok 15 - std::memcmp(uarr, "123", sizeof(uarr)) == 0 for: 0 == 0 with 2 messages: 'uarr := "123"' and 'sarr := "456"' +# #1238 +ok 16 - std::memcmp(sarr, "456", sizeof(sarr)) == 0 for: 0 == 0 with 2 messages: 'uarr := "123"' and 'sarr := "456"' +# #1245 +ok 17 - +# #1319: Sections can have description (even if it is not saved +ok 18 - +# #1403 +ok 19 - h1 == h2 for: [1403 helper] == [1403 helper] +# #1455 - INFO and WARN can start with a linebreak +warning 20 - ' +This info message starts with a linebreak' with 1 message: ' +This warning message starts with a linebreak' +This would not be caught previously +Nor would this +# #1514: stderr/stdout is not captured in tests aborted by an exception +not ok 21 - explicitly with 1 message: '1514' +# #1548 +ok 22 - std::is_same<TypeList<int>, TypeList<int>>::value for: true +# #748 - captures with unexpected exceptions +not ok 23 - unexpected exception with message: 'answer := 42' with 1 message: 'expected exception' +# #748 - captures with unexpected exceptions +not ok 24 - unexpected exception with message: 'answer := 42'; expression was: thisThrows() with 1 message: 'expected exception' +# #748 - captures with unexpected exceptions +ok 25 - thisThrows() with 1 message: 'answer := 42' +# #809 +ok 26 - 42 == f for: 42 == {?} +# #833 +ok 27 - a == t for: 3 == 3 +# #833 +ok 28 - a == t for: 3 == 3 +# #833 +ok 29 - throws_int(true) +# #833 +ok 30 - throws_int(true), int +# #833 +ok 31 - throws_int(false) +# #833 +ok 32 - "aaa", Catch::EndsWith("aaa") for: "aaa" ends with: "aaa" +# #833 +ok 33 - templated_tests<int>(3) for: true +# #835 -- errno should not be touched by Catch +not ok 34 - f() == 0 for: 1 == 0 +# #835 -- errno should not be touched by Catch +ok 35 - errno == 1 for: 1 == 1 +# #872 +ok 36 - x == 4 for: {?} == 4 with 1 message: 'dummy := 0' +# #961 -- Dynamically created sections should all be reported +ok 37 - with 1 message: 'Everything is OK' +# #961 -- Dynamically created sections should all be reported +ok 38 - with 1 message: 'Everything is OK' +# #961 -- Dynamically created sections should all be reported +ok 39 - with 1 message: 'Everything is OK' +# #961 -- Dynamically created sections should all be reported +ok 40 - with 1 message: 'Everything is OK' +# #961 -- Dynamically created sections should all be reported +ok 41 - with 1 message: 'Everything is OK' +# 'Not' checks that should fail +not ok 42 - false != false +# 'Not' checks that should fail +not ok 43 - true != true +# 'Not' checks that should fail +not ok 44 - !true for: false +# 'Not' checks that should fail +not ok 45 - !(true) for: !true +# 'Not' checks that should fail +not ok 46 - !trueValue for: false +# 'Not' checks that should fail +not ok 47 - !(trueValue) for: !true +# 'Not' checks that should fail +not ok 48 - !(1 == 1) for: false +# 'Not' checks that should fail +not ok 49 - !(1 == 1) +# 'Not' checks that should succeed +ok 50 - false == false +# 'Not' checks that should succeed +ok 51 - true == true +# 'Not' checks that should succeed +ok 52 - !false for: true +# 'Not' checks that should succeed +ok 53 - !(false) for: !false +# 'Not' checks that should succeed +ok 54 - !falseValue for: true +# 'Not' checks that should succeed +ok 55 - !(falseValue) for: !false +# 'Not' checks that should succeed +ok 56 - !(1 == 2) for: true +# 'Not' checks that should succeed +ok 57 - !(1 == 2) +# (unimplemented) static bools can be evaluated +ok 58 - is_true<true>::value == true for: true == true +# (unimplemented) static bools can be evaluated +ok 59 - true == is_true<true>::value for: true == true +# (unimplemented) static bools can be evaluated +ok 60 - is_true<false>::value == false for: false == false +# (unimplemented) static bools can be evaluated +ok 61 - false == is_true<false>::value for: false == false +# (unimplemented) static bools can be evaluated +ok 62 - !is_true<false>::value for: true +# (unimplemented) static bools can be evaluated +ok 63 - !!is_true<true>::value for: true +# (unimplemented) static bools can be evaluated +ok 64 - is_true<true>::value for: true +# (unimplemented) static bools can be evaluated +ok 65 - !(is_true<false>::value) for: !false +# 3x3x3 ints +ok 66 - x < y for: 1 < 4 +# 3x3x3 ints +ok 67 - y < z for: 4 < 7 +# 3x3x3 ints +ok 68 - x < z for: 1 < 7 +# 3x3x3 ints +ok 69 - x < y for: 1 < 4 +# 3x3x3 ints +ok 70 - y < z for: 4 < 8 +# 3x3x3 ints +ok 71 - x < z for: 1 < 8 +# 3x3x3 ints +ok 72 - x < y for: 1 < 4 +# 3x3x3 ints +ok 73 - y < z for: 4 < 9 +# 3x3x3 ints +ok 74 - x < z for: 1 < 9 +# 3x3x3 ints +ok 75 - x < y for: 1 < 5 +# 3x3x3 ints +ok 76 - y < z for: 5 < 7 +# 3x3x3 ints +ok 77 - x < z for: 1 < 7 +# 3x3x3 ints +ok 78 - x < y for: 1 < 5 +# 3x3x3 ints +ok 79 - y < z for: 5 < 8 +# 3x3x3 ints +ok 80 - x < z for: 1 < 8 +# 3x3x3 ints +ok 81 - x < y for: 1 < 5 +# 3x3x3 ints +ok 82 - y < z for: 5 < 9 +# 3x3x3 ints +ok 83 - x < z for: 1 < 9 +# 3x3x3 ints +ok 84 - x < y for: 1 < 6 +# 3x3x3 ints +ok 85 - y < z for: 6 < 7 +# 3x3x3 ints +ok 86 - x < z for: 1 < 7 +# 3x3x3 ints +ok 87 - x < y for: 1 < 6 +# 3x3x3 ints +ok 88 - y < z for: 6 < 8 +# 3x3x3 ints +ok 89 - x < z for: 1 < 8 +# 3x3x3 ints +ok 90 - x < y for: 1 < 6 +# 3x3x3 ints +ok 91 - y < z for: 6 < 9 +# 3x3x3 ints +ok 92 - x < z for: 1 < 9 +# 3x3x3 ints +ok 93 - x < y for: 2 < 4 +# 3x3x3 ints +ok 94 - y < z for: 4 < 7 +# 3x3x3 ints +ok 95 - x < z for: 2 < 7 +# 3x3x3 ints +ok 96 - x < y for: 2 < 4 +# 3x3x3 ints +ok 97 - y < z for: 4 < 8 +# 3x3x3 ints +ok 98 - x < z for: 2 < 8 +# 3x3x3 ints +ok 99 - x < y for: 2 < 4 +# 3x3x3 ints +ok 100 - y < z for: 4 < 9 +# 3x3x3 ints +ok 101 - x < z for: 2 < 9 +# 3x3x3 ints +ok 102 - x < y for: 2 < 5 +# 3x3x3 ints +ok 103 - y < z for: 5 < 7 +# 3x3x3 ints +ok 104 - x < z for: 2 < 7 +# 3x3x3 ints +ok 105 - x < y for: 2 < 5 +# 3x3x3 ints +ok 106 - y < z for: 5 < 8 +# 3x3x3 ints +ok 107 - x < z for: 2 < 8 +# 3x3x3 ints +ok 108 - x < y for: 2 < 5 +# 3x3x3 ints +ok 109 - y < z for: 5 < 9 +# 3x3x3 ints +ok 110 - x < z for: 2 < 9 +# 3x3x3 ints +ok 111 - x < y for: 2 < 6 +# 3x3x3 ints +ok 112 - y < z for: 6 < 7 +# 3x3x3 ints +ok 113 - x < z for: 2 < 7 +# 3x3x3 ints +ok 114 - x < y for: 2 < 6 +# 3x3x3 ints +ok 115 - y < z for: 6 < 8 +# 3x3x3 ints +ok 116 - x < z for: 2 < 8 +# 3x3x3 ints +ok 117 - x < y for: 2 < 6 +# 3x3x3 ints +ok 118 - y < z for: 6 < 9 +# 3x3x3 ints +ok 119 - x < z for: 2 < 9 +# 3x3x3 ints +ok 120 - x < y for: 3 < 4 +# 3x3x3 ints +ok 121 - y < z for: 4 < 7 +# 3x3x3 ints +ok 122 - x < z for: 3 < 7 +# 3x3x3 ints +ok 123 - x < y for: 3 < 4 +# 3x3x3 ints +ok 124 - y < z for: 4 < 8 +# 3x3x3 ints +ok 125 - x < z for: 3 < 8 +# 3x3x3 ints +ok 126 - x < y for: 3 < 4 +# 3x3x3 ints +ok 127 - y < z for: 4 < 9 +# 3x3x3 ints +ok 128 - x < z for: 3 < 9 +# 3x3x3 ints +ok 129 - x < y for: 3 < 5 +# 3x3x3 ints +ok 130 - y < z for: 5 < 7 +# 3x3x3 ints +ok 131 - x < z for: 3 < 7 +# 3x3x3 ints +ok 132 - x < y for: 3 < 5 +# 3x3x3 ints +ok 133 - y < z for: 5 < 8 +# 3x3x3 ints +ok 134 - x < z for: 3 < 8 +# 3x3x3 ints +ok 135 - x < y for: 3 < 5 +# 3x3x3 ints +ok 136 - y < z for: 5 < 9 +# 3x3x3 ints +ok 137 - x < z for: 3 < 9 +# 3x3x3 ints +ok 138 - x < y for: 3 < 6 +# 3x3x3 ints +ok 139 - y < z for: 6 < 7 +# 3x3x3 ints +ok 140 - x < z for: 3 < 7 +# 3x3x3 ints +ok 141 - x < y for: 3 < 6 +# 3x3x3 ints +ok 142 - y < z for: 6 < 8 +# 3x3x3 ints +ok 143 - x < z for: 3 < 8 +# 3x3x3 ints +ok 144 - x < y for: 3 < 6 +# 3x3x3 ints +ok 145 - y < z for: 6 < 9 +# 3x3x3 ints +ok 146 - x < z for: 3 < 9 +# A METHOD_AS_TEST_CASE based test run that fails +not ok 147 - s == "world" for: "hello" == "world" +# A METHOD_AS_TEST_CASE based test run that succeeds +ok 148 - s == "hello" for: "hello" == "hello" +# A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<float> +not ok 149 - Template_Fixture_2<TestType>::m_a.size() == 1 for: 0 == 1 +# A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int> +not ok 150 - Template_Fixture_2<TestType>::m_a.size() == 1 for: 0 == 1 +# A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float> +not ok 151 - Template_Fixture_2<TestType>::m_a.size() == 1 for: 0 == 1 +# A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int> +not ok 152 - Template_Fixture_2<TestType>::m_a.size() == 1 for: 0 == 1 +# A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<float> +ok 153 - Template_Fixture_2<TestType>::m_a.size() == 0 for: 0 == 0 +# A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<int> +ok 154 - Template_Fixture_2<TestType>::m_a.size() == 0 for: 0 == 0 +# A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<float> +ok 155 - Template_Fixture_2<TestType>::m_a.size() == 0 for: 0 == 0 +# A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<int> +ok 156 - Template_Fixture_2<TestType>::m_a.size() == 0 for: 0 == 0 +# A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<float, 6> +not ok 157 - Template_Fixture_2<TestType>{}.m_a.size() < 2 for: 6 < 2 +# A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2> +not ok 158 - Template_Fixture_2<TestType>{}.m_a.size() < 2 for: 2 < 2 +# A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6> +not ok 159 - Template_Fixture_2<TestType>{}.m_a.size() < 2 for: 6 < 2 +# A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2> +not ok 160 - Template_Fixture_2<TestType>{}.m_a.size() < 2 for: 2 < 2 +# A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<float,6> +ok 161 - Template_Fixture_2<TestType>{}.m_a.size() >= 2 for: 6 >= 2 +# A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<int,2> +ok 162 - Template_Fixture_2<TestType>{}.m_a.size() >= 2 for: 2 >= 2 +# A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<float,6> +ok 163 - Template_Fixture_2<TestType>{}.m_a.size() >= 2 for: 6 >= 2 +# A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<int,2> +ok 164 - Template_Fixture_2<TestType>{}.m_a.size() >= 2 for: 2 >= 2 +# A TEMPLATE_TEST_CASE_METHOD based test run that fails - double +not ok 165 - Template_Fixture<TestType>::m_a == 2 for: 1.0 == 2 +# A TEMPLATE_TEST_CASE_METHOD based test run that fails - float +not ok 166 - Template_Fixture<TestType>::m_a == 2 for: 1.0f == 2 +# A TEMPLATE_TEST_CASE_METHOD based test run that fails - int +not ok 167 - Template_Fixture<TestType>::m_a == 2 for: 1 == 2 +# A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double +ok 168 - Template_Fixture<TestType>::m_a == 1 for: 1.0 == 1 +# A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - float +ok 169 - Template_Fixture<TestType>::m_a == 1 for: 1.0f == 1 +# A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - int +ok 170 - Template_Fixture<TestType>::m_a == 1 for: 1 == 1 +# A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1 +not ok 171 - Nttp_Fixture<V>::value == 0 for: 1 == 0 +# A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3 +not ok 172 - Nttp_Fixture<V>::value == 0 for: 3 == 0 +# A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6 +not ok 173 - Nttp_Fixture<V>::value == 0 for: 6 == 0 +# A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1 +ok 174 - Nttp_Fixture<V>::value > 0 for: 1 > 0 +# A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 3 +ok 175 - Nttp_Fixture<V>::value > 0 for: 3 > 0 +# A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 6 +ok 176 - Nttp_Fixture<V>::value > 0 for: 6 > 0 +# A TEST_CASE_METHOD based test run that fails +not ok 177 - m_a == 2 for: 1 == 2 +# A TEST_CASE_METHOD based test run that succeeds +ok 178 - m_a == 1 for: 1 == 1 +# A Template product test case - Foo<float> +ok 179 - x.size() == 0 for: 0 == 0 +# A Template product test case - Foo<int> +ok 180 - x.size() == 0 for: 0 == 0 +# A Template product test case - std::vector<float> +ok 181 - x.size() == 0 for: 0 == 0 +# A Template product test case - std::vector<int> +ok 182 - x.size() == 0 for: 0 == 0 +# A Template product test case with array signature - Bar<float, 42> +ok 183 - x.size() > 0 for: 42 > 0 +# A Template product test case with array signature - Bar<int, 9> +ok 184 - x.size() > 0 for: 9 > 0 +# A Template product test case with array signature - std::array<float, 42> +ok 185 - x.size() > 0 for: 42 > 0 +# A Template product test case with array signature - std::array<int, 9> +ok 186 - x.size() > 0 for: 9 > 0 +# A comparison that uses literals instead of the normal constructor +ok 187 - d == 1.23_a for: 1.23 == Approx( 1.23 ) +# A comparison that uses literals instead of the normal constructor +ok 188 - d != 1.22_a for: 1.23 != Approx( 1.22 ) +# A comparison that uses literals instead of the normal constructor +ok 189 - -d == -1.23_a for: -1.23 == Approx( -1.23 ) +# A comparison that uses literals instead of the normal constructor +ok 190 - d == 1.2_a .epsilon(.1) for: 1.23 == Approx( 1.2 ) +# A comparison that uses literals instead of the normal constructor +ok 191 - d != 1.2_a .epsilon(.001) for: 1.23 != Approx( 1.2 ) +# A comparison that uses literals instead of the normal constructor +ok 192 - d == 1_a .epsilon(.3) for: 1.23 == Approx( 1.0 ) +# A couple of nested sections followed by a failure +ok 193 - with 1 message: 'that's not flying - that's failing in style' +# A couple of nested sections followed by a failure +not ok 194 - explicitly with 1 message: 'to infinity and beyond' +# A failing expression with a non streamable type is still captured +not ok 195 - &o1 == &o2 for: 0x<hex digits> == 0x<hex digits> +# A failing expression with a non streamable type is still captured +not ok 196 - o1 == o2 for: {?} == {?} +# Absolute margin +ok 197 - 104.0 != Approx(100.0) for: 104.0 != Approx( 100.0 ) +# Absolute margin +ok 198 - 104.0 == Approx(100.0).margin(5) for: 104.0 == Approx( 100.0 ) +# Absolute margin +ok 199 - 104.0 == Approx(100.0).margin(4) for: 104.0 == Approx( 100.0 ) +# Absolute margin +ok 200 - 104.0 != Approx(100.0).margin(3) for: 104.0 != Approx( 100.0 ) +# Absolute margin +ok 201 - 100.3 != Approx(100.0) for: 100.3 != Approx( 100.0 ) +# Absolute margin +ok 202 - 100.3 == Approx(100.0).margin(0.5) for: 100.3 == Approx( 100.0 ) +# An expression with side-effects should only be evaluated once +ok 203 - i++ == 7 for: 7 == 7 +# An expression with side-effects should only be evaluated once +ok 204 - i++ == 8 for: 8 == 8 +# An unchecked exception reports the line of the last assertion +ok 205 - 1 == 1 +# An unchecked exception reports the line of the last assertion +not ok 206 - unexpected exception with message: 'unexpected exception'; expression was: {Unknown expression after the reported line} +# Anonymous test case 1 +ok 207 - with 1 message: 'anonymous test case' +# Approx setters validate their arguments +ok 208 - Approx(0).margin(0) +# Approx setters validate their arguments +ok 209 - Approx(0).margin(1234656) +# Approx setters validate their arguments +ok 210 - Approx(0).margin(-2), std::domain_error +# Approx setters validate their |