Read-only mirrors. Development, issues and pull requests are on GitHub.

summaryrefslogtreecommitdiffhomepage
path: root/tests/SelfTest
diff options
context:
space:
mode:
authorMartin Hořeňovský2020-02-02 15:04:19 +0100
committerMartin Hořeňovský2020-02-02 15:04:19 +0100
commit1327946785cd33dcd0ed3142dcb6e8849ccbc893 (patch)
treee575e464ee8b4d6e17d7d79329d3e7c6123ccde6 /tests/SelfTest
parenta49ab0a162b2966b83f0787b2b76a718c8d2ffb5 (diff)
downloadcatch3-1327946785cd33dcd0ed3142dcb6e8849ccbc893.tar.gz
Add all in-repo reporters to approval tests
Diffstat (limited to 'tests/SelfTest')
-rw-r--r--tests/SelfTest/Baselines/automake.sw.approved.txt313
-rw-r--r--tests/SelfTest/Baselines/tap.sw.approved.txt3338
-rw-r--r--tests/SelfTest/Baselines/teamcity.sw.approved.txt770
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