First Commit
This commit is contained in:
168
externals/catch2/tests/SelfTest/Baselines/automake.std.approved.txt
vendored
Normal file
168
externals/catch2/tests/SelfTest/Baselines/automake.std.approved.txt
vendored
Normal file
@@ -0,0 +1,168 @@
|
||||
:test-result: PASS # A test name that starts with a #
|
||||
:test-result: PASS #542
|
||||
:test-result: PASS #809
|
||||
: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: 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 TEST_CASE_METHOD based test run that fails
|
||||
:test-result: PASS A TEST_CASE_METHOD based test run that succeeds
|
||||
: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 AllOf matcher
|
||||
:test-result: PASS 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 AnyOf matcher
|
||||
: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 Assertions then sections
|
||||
:test-result: PASS Character pretty printing
|
||||
:test-result: PASS Comparing function pointers
|
||||
:test-result: PASS Comparing member function pointers
|
||||
: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: 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 Demonstrate that a non-const == is not used
|
||||
:test-result: FAIL EndsWith string matcher
|
||||
: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 messages can be tested for
|
||||
: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: PASS Factorials are computed
|
||||
:test-result: PASS Generator over a range of pairs
|
||||
:test-result: PASS Generators over two ranges
|
||||
:test-result: PASS Greater-than inequalities with different epsilons
|
||||
:test-result: PASS 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: 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 Long strings can be wrapped
|
||||
:test-result: PASS Long text is truncated
|
||||
: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 Nice descriptive name
|
||||
:test-result: FAIL Non-std exceptions can be translated
|
||||
:test-result: PASS NotImplemented exception
|
||||
:test-result: PASS Objects that evaluated in boolean contexts can be checked
|
||||
:test-result: PASS Operators at different namespace levels not hijacked by Koenig lookup
|
||||
:test-result: FAIL Ordering comparison checks that should fail
|
||||
:test-result: PASS Ordering comparison checks that should succeed
|
||||
:test-result: FAIL Output from all sections is reported
|
||||
:test-result: PASS Parse test names and tags
|
||||
:test-result: PASS Parsing a std::pair
|
||||
:test-result: PASS Pointers can be compared to null
|
||||
:test-result: PASS Pointers can be converted to strings
|
||||
:test-result: PASS Process can be configured on command line
|
||||
:test-result: FAIL SCOPED_INFO is reset for each loop
|
||||
:test-result: PASS SUCCEED counts as a test pass
|
||||
:test-result: PASS SUCCESS 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
|
||||
:test-result: PASS Sends stuff to stdout and stderr
|
||||
:test-result: PASS Some simple comparisons between doubles
|
||||
Message from section one
|
||||
Message from section two
|
||||
:test-result: PASS Standard output from all sections is reported
|
||||
:test-result: FAIL StartsWith string matcher
|
||||
:test-result: PASS String matchers
|
||||
hello
|
||||
hello
|
||||
:test-result: PASS Strings can be rendered with colour
|
||||
:test-result: FAIL Tabs and newlines show in output
|
||||
:test-result: PASS Tag alias can be registered against tag patterns
|
||||
:test-result: PASS Test case with one argument
|
||||
:test-result: PASS Test enum bit values
|
||||
:test-result: PASS Text can be formatted using the Text class
|
||||
:test-result: PASS 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: PASS Tracker
|
||||
:test-result: FAIL Unexpected exceptions can be translated
|
||||
:test-result: PASS Use a custom approx
|
||||
:test-result: PASS Variadic macros
|
||||
: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: PASS When unchecked exceptions are thrown, but caught, they do not affect the test
|
||||
:test-result: PASS Where the LHS is not a simple value
|
||||
:test-result: PASS 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 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: PASS first tag
|
||||
spanner:test-result: PASS has printf
|
||||
:test-result: FAIL just failure
|
||||
:test-result: PASS just info
|
||||
:test-result: FAIL looped SECTION tests
|
||||
:test-result: FAIL looped tests
|
||||
:test-result: FAIL more nested SECTION tests
|
||||
:test-result: PASS nested SECTION tests
|
||||
:test-result: PASS non streamable - with conv. op
|
||||
:test-result: PASS not allowed
|
||||
:test-result: PASS null strings
|
||||
:test-result: PASS pair<pair<int,const char *,pair<std::string,int> > -> toString
|
||||
:test-result: PASS pointer to class
|
||||
:test-result: PASS random SECTION tests
|
||||
:test-result: PASS replaceInPlace
|
||||
:test-result: PASS second tag
|
||||
:test-result: FAIL send a single char to INFO
|
||||
:test-result: FAIL sends information to INFO
|
||||
:test-result: PASS std::pair<int,const std::string> -> toString
|
||||
:test-result: PASS std::pair<int,std::string> -> toString
|
||||
: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 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( has_maker )
|
||||
:test-result: PASS toString( has_maker_and_toString )
|
||||
:test-result: PASS toString( has_toString )
|
||||
:test-result: PASS toString( vectors<has_maker )
|
||||
:test-result: SKIP toString( vectors<has_maker_and_toString )
|
||||
:test-result: SKIP toString( vectors<has_toString )
|
||||
:test-result: PASS toString(enum w/operator<<)
|
||||
:test-result: PASS toString(enum)
|
||||
: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
|
||||
420
externals/catch2/tests/SelfTest/Baselines/automake.sw.approved.txt
vendored
Normal file
420
externals/catch2/tests/SelfTest/Baselines/automake.sw.approved.txt
vendored
Normal file
@@ -0,0 +1,420 @@
|
||||
:test-result: PASS # A test name that starts with a #
|
||||
: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: PASS #1905 -- test spec parser properly clears internal state between compound tests
|
||||
:test-result: PASS #1912 -- test spec parser handles escaping
|
||||
:test-result: PASS #1913 - GENERATE inside a for loop should not keep recreating the generator
|
||||
:test-result: PASS #1913 - GENERATEs can share a line
|
||||
:test-result: PASS #1938 - GENERATE after a section
|
||||
:test-result: PASS #1938 - Section followed by flat generate
|
||||
:test-result: PASS #1938 - flat generate
|
||||
:test-result: PASS #1938 - mixed sections and generates
|
||||
:test-result: PASS #1938 - nested generate
|
||||
:test-result: PASS #1954 - 7 arg template test case sig compiles - 1, 1, 1, 1, 1, 0, 0
|
||||
:test-result: PASS #1954 - 7 arg template test case sig compiles - 5, 1, 1, 1, 1, 0, 0
|
||||
:test-result: PASS #1954 - 7 arg template test case sig compiles - 5, 3, 1, 1, 1, 0, 0
|
||||
:test-result: PASS #2152 - ULP checks between differently signed values were wrong - double
|
||||
:test-result: PASS #2152 - ULP checks between differently signed values were wrong - float
|
||||
:test-result: XFAIL #2615 - Throwing in constructor generator fails test case but does not abort
|
||||
: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 Catch2
|
||||
: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 Assertion macros support bit operators and bool conversions
|
||||
:test-result: PASS Assertions then sections
|
||||
:test-result: PASS Basic use of the Contains range matcher
|
||||
:test-result: PASS Basic use of the Empty range matcher
|
||||
: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 CaseInsensitiveEqualsTo is case insensitive
|
||||
:test-result: PASS CaseInsensitiveLess is case insensitive
|
||||
:test-result: PASS Character pretty printing
|
||||
:test-result: PASS Clara::Arg supports single-arg parse the way Opt does
|
||||
:test-result: PASS Clara::Opt supports accept-many lambdas
|
||||
:test-result: PASS ColourGuard behaviour
|
||||
:test-result: PASS Combining MatchAllOfGeneric does not nest
|
||||
:test-result: PASS Combining MatchAnyOfGeneric does not nest
|
||||
:test-result: PASS Combining MatchNotOfGeneric does not nest
|
||||
:test-result: PASS Combining concrete matchers does not use templated matchers
|
||||
:test-result: PASS Combining only templated matchers
|
||||
:test-result: PASS Combining templated and concrete matchers
|
||||
:test-result: PASS Combining templated matchers
|
||||
: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: PASS Composed generic matchers shortcircuit
|
||||
:test-result: PASS Composed matchers shortcircuit
|
||||
:test-result: FAIL Contains string matcher
|
||||
:test-result: PASS Copy and then generate a range
|
||||
:test-result: PASS Cout stream properly declares it writes to stdout
|
||||
: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: PASS Empty stream name opens cout stream
|
||||
:test-result: PASS Empty tag is not allowed
|
||||
: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 message can be matched
|
||||
: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 Filter generator throws exception for empty generator
|
||||
: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: PASS Hashers with different seed produce different hash with same test case
|
||||
:test-result: PASS Hashers with same seed produce same hash
|
||||
:test-result: PASS Hashing different test cases produces different result
|
||||
:test-result: PASS Hashing test case produces same hash across multiple calls
|
||||
: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 Lambdas in assertions
|
||||
: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: XFAIL Mayfail test case with nested sections
|
||||
:test-result: FAIL Mismatching exception messages failing the test
|
||||
:test-result: PASS Multireporter calls reporters and listeners in correct order
|
||||
:test-result: PASS Multireporter updates ReporterPreferences properly
|
||||
: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 Overloaded comma or address-of operators are not used
|
||||
:test-result: PASS Parse uints
|
||||
:test-result: PASS Parsed tags are matched case insensitive
|
||||
:test-result: PASS Parsing sharding-related cli flags
|
||||
:test-result: PASS Parsing tags with non-alphabetical characters is pass-through
|
||||
:test-result: PASS Parsing warnings
|
||||
: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: PASS Random seed generation accepts known methods
|
||||
:test-result: PASS Random seed generation reports unknown methods
|
||||
:test-result: PASS Range type with sentinel
|
||||
:test-result: FAIL Reconstruction should be based on stringification: #914
|
||||
:test-result: FAIL Regex string matcher
|
||||
:test-result: PASS Registering reporter with '::' in name fails
|
||||
:test-result: PASS Regression test #1
|
||||
:test-result: PASS Reporter's write listings to provided stream
|
||||
:test-result: PASS Reproducer for #2309 - a very long description past 80 chars (default console width) with a late colon : blablabla
|
||||
: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 char arrays with statically known sizes - char
|
||||
:test-result: PASS Stringifying char arrays with statically known sizes - signed char
|
||||
:test-result: PASS Stringifying char arrays with statically known sizes - unsigned char
|
||||
: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 Tags with spaces and non-alphanumerical characters are accepted
|
||||
: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 identical tags keeps just one
|
||||
: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: PASS Testing checked-if
|
||||
:test-result: XFAIL Testing checked-if 2
|
||||
:test-result: XFAIL Testing checked-if 3
|
||||
:test-result: FAIL The NO_FAIL macro reports a failure but does not fail the test
|
||||
:test-result: PASS The default listing implementation write to provided stream
|
||||
: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: PASS Type conversions of RangeEquals and similar
|
||||
:test-result: FAIL Unexpected exceptions can be translated
|
||||
:test-result: PASS Upcasting special member functions
|
||||
:test-result: PASS Usage of AllMatch range matcher
|
||||
:test-result: PASS Usage of AllTrue range matcher
|
||||
:test-result: PASS Usage of AnyMatch range matcher
|
||||
:test-result: PASS Usage of AnyTrue range matcher
|
||||
:test-result: PASS Usage of NoneMatch range matcher
|
||||
:test-result: PASS Usage of NoneTrue range matcher
|
||||
:test-result: PASS Usage of RangeEquals range matcher
|
||||
:test-result: PASS Usage of UnorderedRangeEquals range matcher
|
||||
:test-result: PASS Usage of the SizeIs range matcher
|
||||
: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: 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 XmlWriter writes boolean attributes as true/false
|
||||
:test-result: SKIP a succeeding test can still be skipped
|
||||
:test-result: PASS analyse no analysis
|
||||
:test-result: PASS array<int, N> -> toString
|
||||
:test-result: PASS benchmark function call
|
||||
: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 classify_outliers
|
||||
:test-result: PASS comparisons between const int variables
|
||||
:test-result: PASS comparisons between int variables
|
||||
:test-result: PASS convertToBits
|
||||
:test-result: SKIP dynamic skipping works with generators
|
||||
:test-result: PASS empty tags are not allowed
|
||||
:test-result: PASS erfc_inv
|
||||
:test-result: PASS estimate_clock_resolution
|
||||
:test-result: PASS even more nested SECTION tests
|
||||
:test-result: XFAIL failed assertions before SKIP cause test case to fail
|
||||
:test-result: XFAIL failing for some generator values causes entire test case to fail
|
||||
:test-result: XFAIL failing in some unskipped sections causes entire test case to fail
|
||||
:test-result: FAIL first tag
|
||||
loose text artifact
|
||||
:test-result: FAIL has printf
|
||||
:test-result: PASS is_unary_function
|
||||
: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: PASS makeStream recognizes %debug stream name
|
||||
:test-result: PASS make_unique reimplementation
|
||||
:test-result: PASS mean
|
||||
:test-result: PASS measure
|
||||
:test-result: FAIL mix info, unscoped info and warning
|
||||
:test-result: FAIL more nested SECTION tests
|
||||
:test-result: PASS nested SECTION tests
|
||||
a!
|
||||
b1!
|
||||
!
|
||||
:test-result: FAIL nested sections can be skipped dynamically at runtime
|
||||
:test-result: PASS non streamable - with conv. op
|
||||
:test-result: PASS non-copyable objects
|
||||
:test-result: PASS normal_cdf
|
||||
:test-result: PASS normal_quantile
|
||||
: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: PASS request an unknown %-starting stream fails
|
||||
:test-result: PASS resolution
|
||||
:test-result: PASS run_for_at_least, chronometer
|
||||
:test-result: PASS run_for_at_least, int
|
||||
:test-result: FAIL second tag
|
||||
:test-result: SKIP sections can be skipped dynamically at runtime
|
||||
: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: SKIP skipped tests can optionally provide a reason
|
||||
:test-result: PASS splitString
|
||||
:test-result: FAIL stacks unscoped info in loops
|
||||
:test-result: PASS startsWith
|
||||
: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: PASS stdout and stderr streams have %-starting name
|
||||
: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: PASS tags with dots in later positions are not parsed as hidden
|
||||
:test-result: SKIP tests can be skipped dynamically at runtime
|
||||
: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<string,string>
|
||||
:test-result: PASS tuple<tuple<int>,tuple<>,float>
|
||||
:test-result: PASS uniform samples
|
||||
:test-result: PASS unique_ptr reimplementation: basic functionality
|
||||
: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 warmup
|
||||
:test-result: PASS weighted_average_quantile
|
||||
:test-result: PASS xmlentitycheck
|
||||
409
externals/catch2/tests/SelfTest/Baselines/automake.sw.multi.approved.txt
vendored
Normal file
409
externals/catch2/tests/SelfTest/Baselines/automake.sw.multi.approved.txt
vendored
Normal file
@@ -0,0 +1,409 @@
|
||||
:test-result: PASS # A test name that starts with a #
|
||||
: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
|
||||
:test-result: FAIL #1514: stderr/stdout is not captured in tests aborted by an exception
|
||||
:test-result: PASS #1548
|
||||
:test-result: PASS #1905 -- test spec parser properly clears internal state between compound tests
|
||||
:test-result: PASS #1912 -- test spec parser handles escaping
|
||||
:test-result: PASS #1913 - GENERATE inside a for loop should not keep recreating the generator
|
||||
:test-result: PASS #1913 - GENERATEs can share a line
|
||||
:test-result: PASS #1938 - GENERATE after a section
|
||||
:test-result: PASS #1938 - Section followed by flat generate
|
||||
:test-result: PASS #1938 - flat generate
|
||||
:test-result: PASS #1938 - mixed sections and generates
|
||||
:test-result: PASS #1938 - nested generate
|
||||
:test-result: PASS #1954 - 7 arg template test case sig compiles - 1, 1, 1, 1, 1, 0, 0
|
||||
:test-result: PASS #1954 - 7 arg template test case sig compiles - 5, 1, 1, 1, 1, 0, 0
|
||||
:test-result: PASS #1954 - 7 arg template test case sig compiles - 5, 3, 1, 1, 1, 0, 0
|
||||
:test-result: PASS #2152 - ULP checks between differently signed values were wrong - double
|
||||
:test-result: PASS #2152 - ULP checks between differently signed values were wrong - float
|
||||
:test-result: XFAIL #2615 - Throwing in constructor generator fails test case but does not abort
|
||||
: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 Catch2
|
||||
: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 Assertion macros support bit operators and bool conversions
|
||||
:test-result: PASS Assertions then sections
|
||||
:test-result: PASS Basic use of the Contains range matcher
|
||||
:test-result: PASS Basic use of the Empty range matcher
|
||||
: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 CaseInsensitiveEqualsTo is case insensitive
|
||||
:test-result: PASS CaseInsensitiveLess is case insensitive
|
||||
:test-result: PASS Character pretty printing
|
||||
:test-result: PASS Clara::Arg supports single-arg parse the way Opt does
|
||||
:test-result: PASS Clara::Opt supports accept-many lambdas
|
||||
:test-result: PASS ColourGuard behaviour
|
||||
:test-result: PASS Combining MatchAllOfGeneric does not nest
|
||||
:test-result: PASS Combining MatchAnyOfGeneric does not nest
|
||||
:test-result: PASS Combining MatchNotOfGeneric does not nest
|
||||
:test-result: PASS Combining concrete matchers does not use templated matchers
|
||||
:test-result: PASS Combining only templated matchers
|
||||
:test-result: PASS Combining templated and concrete matchers
|
||||
:test-result: PASS Combining templated matchers
|
||||
: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: PASS Composed generic matchers shortcircuit
|
||||
:test-result: PASS Composed matchers shortcircuit
|
||||
:test-result: FAIL Contains string matcher
|
||||
:test-result: PASS Copy and then generate a range
|
||||
:test-result: PASS Cout stream properly declares it writes to stdout
|
||||
: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: PASS Empty stream name opens cout stream
|
||||
:test-result: PASS Empty tag is not allowed
|
||||
: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 message can be matched
|
||||
: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 Filter generator throws exception for empty generator
|
||||
: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: PASS Hashers with different seed produce different hash with same test case
|
||||
:test-result: PASS Hashers with same seed produce same hash
|
||||
:test-result: PASS Hashing different test cases produces different result
|
||||
:test-result: PASS Hashing test case produces same hash across multiple calls
|
||||
: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 Lambdas in assertions
|
||||
: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: XFAIL Mayfail test case with nested sections
|
||||
:test-result: FAIL Mismatching exception messages failing the test
|
||||
:test-result: PASS Multireporter calls reporters and listeners in correct order
|
||||
:test-result: PASS Multireporter updates ReporterPreferences properly
|
||||
: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 Overloaded comma or address-of operators are not used
|
||||
:test-result: PASS Parse uints
|
||||
:test-result: PASS Parsed tags are matched case insensitive
|
||||
:test-result: PASS Parsing sharding-related cli flags
|
||||
:test-result: PASS Parsing tags with non-alphabetical characters is pass-through
|
||||
:test-result: PASS Parsing warnings
|
||||
: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: PASS Random seed generation accepts known methods
|
||||
:test-result: PASS Random seed generation reports unknown methods
|
||||
:test-result: PASS Range type with sentinel
|
||||
:test-result: FAIL Reconstruction should be based on stringification: #914
|
||||
:test-result: FAIL Regex string matcher
|
||||
:test-result: PASS Registering reporter with '::' in name fails
|
||||
:test-result: PASS Regression test #1
|
||||
:test-result: PASS Reporter's write listings to provided stream
|
||||
:test-result: PASS Reproducer for #2309 - a very long description past 80 chars (default console width) with a late colon : blablabla
|
||||
: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
|
||||
:test-result: FAIL Sends stuff to stdout and stderr
|
||||
:test-result: PASS Some simple comparisons between doubles
|
||||
: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 char arrays with statically known sizes - char
|
||||
:test-result: PASS Stringifying char arrays with statically known sizes - signed char
|
||||
:test-result: PASS Stringifying char arrays with statically known sizes - unsigned char
|
||||
: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 Tags with spaces and non-alphanumerical characters are accepted
|
||||
: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 identical tags keeps just one
|
||||
: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: PASS Testing checked-if
|
||||
:test-result: XFAIL Testing checked-if 2
|
||||
:test-result: XFAIL Testing checked-if 3
|
||||
:test-result: FAIL The NO_FAIL macro reports a failure but does not fail the test
|
||||
:test-result: PASS The default listing implementation write to provided stream
|
||||
: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: PASS Type conversions of RangeEquals and similar
|
||||
:test-result: FAIL Unexpected exceptions can be translated
|
||||
:test-result: PASS Upcasting special member functions
|
||||
:test-result: PASS Usage of AllMatch range matcher
|
||||
:test-result: PASS Usage of AllTrue range matcher
|
||||
:test-result: PASS Usage of AnyMatch range matcher
|
||||
:test-result: PASS Usage of AnyTrue range matcher
|
||||
:test-result: PASS Usage of NoneMatch range matcher
|
||||
:test-result: PASS Usage of NoneTrue range matcher
|
||||
:test-result: PASS Usage of RangeEquals range matcher
|
||||
:test-result: PASS Usage of UnorderedRangeEquals range matcher
|
||||
:test-result: PASS Usage of the SizeIs range matcher
|
||||
: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: 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 XmlWriter writes boolean attributes as true/false
|
||||
:test-result: SKIP a succeeding test can still be skipped
|
||||
:test-result: PASS analyse no analysis
|
||||
:test-result: PASS array<int, N> -> toString
|
||||
:test-result: PASS benchmark function call
|
||||
: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 classify_outliers
|
||||
:test-result: PASS comparisons between const int variables
|
||||
:test-result: PASS comparisons between int variables
|
||||
:test-result: PASS convertToBits
|
||||
:test-result: SKIP dynamic skipping works with generators
|
||||
:test-result: PASS empty tags are not allowed
|
||||
:test-result: PASS erfc_inv
|
||||
:test-result: PASS estimate_clock_resolution
|
||||
:test-result: PASS even more nested SECTION tests
|
||||
:test-result: XFAIL failed assertions before SKIP cause test case to fail
|
||||
:test-result: XFAIL failing for some generator values causes entire test case to fail
|
||||
:test-result: XFAIL failing in some unskipped sections causes entire test case to fail
|
||||
:test-result: FAIL first tag
|
||||
:test-result: FAIL has printf
|
||||
:test-result: PASS is_unary_function
|
||||
: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: PASS makeStream recognizes %debug stream name
|
||||
:test-result: PASS make_unique reimplementation
|
||||
:test-result: PASS mean
|
||||
:test-result: PASS measure
|
||||
:test-result: FAIL mix info, unscoped info and warning
|
||||
:test-result: FAIL more nested SECTION tests
|
||||
:test-result: PASS nested SECTION tests
|
||||
:test-result: FAIL nested sections can be skipped dynamically at runtime
|
||||
:test-result: PASS non streamable - with conv. op
|
||||
:test-result: PASS non-copyable objects
|
||||
:test-result: PASS normal_cdf
|
||||
:test-result: PASS normal_quantile
|
||||
: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: PASS request an unknown %-starting stream fails
|
||||
:test-result: PASS resolution
|
||||
:test-result: PASS run_for_at_least, chronometer
|
||||
:test-result: PASS run_for_at_least, int
|
||||
:test-result: FAIL second tag
|
||||
:test-result: SKIP sections can be skipped dynamically at runtime
|
||||
: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: SKIP skipped tests can optionally provide a reason
|
||||
:test-result: PASS splitString
|
||||
:test-result: FAIL stacks unscoped info in loops
|
||||
:test-result: PASS startsWith
|
||||
: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: PASS stdout and stderr streams have %-starting name
|
||||
: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: PASS tags with dots in later positions are not parsed as hidden
|
||||
:test-result: SKIP tests can be skipped dynamically at runtime
|
||||
: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<string,string>
|
||||
:test-result: PASS tuple<tuple<int>,tuple<>,float>
|
||||
:test-result: PASS uniform samples
|
||||
:test-result: PASS unique_ptr reimplementation: basic functionality
|
||||
: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 warmup
|
||||
:test-result: PASS weighted_average_quantile
|
||||
:test-result: PASS xmlentitycheck
|
||||
2544
externals/catch2/tests/SelfTest/Baselines/compact.sw.approved.txt
vendored
Normal file
2544
externals/catch2/tests/SelfTest/Baselines/compact.sw.approved.txt
vendored
Normal file
File diff suppressed because it is too large
Load Diff
2533
externals/catch2/tests/SelfTest/Baselines/compact.sw.multi.approved.txt
vendored
Normal file
2533
externals/catch2/tests/SelfTest/Baselines/compact.sw.multi.approved.txt
vendored
Normal file
File diff suppressed because it is too large
Load Diff
1538
externals/catch2/tests/SelfTest/Baselines/console.std.approved.txt
vendored
Normal file
1538
externals/catch2/tests/SelfTest/Baselines/console.std.approved.txt
vendored
Normal file
File diff suppressed because it is too large
Load Diff
18236
externals/catch2/tests/SelfTest/Baselines/console.sw.approved.txt
vendored
Normal file
18236
externals/catch2/tests/SelfTest/Baselines/console.sw.approved.txt
vendored
Normal file
File diff suppressed because it is too large
Load Diff
18225
externals/catch2/tests/SelfTest/Baselines/console.sw.multi.approved.txt
vendored
Normal file
18225
externals/catch2/tests/SelfTest/Baselines/console.sw.multi.approved.txt
vendored
Normal file
File diff suppressed because it is too large
Load Diff
956
externals/catch2/tests/SelfTest/Baselines/console.swa4.approved.txt
vendored
Normal file
956
externals/catch2/tests/SelfTest/Baselines/console.swa4.approved.txt
vendored
Normal file
@@ -0,0 +1,956 @@
|
||||
Filters: "*" ~[!nonportable] ~[!benchmark] ~[approvals]
|
||||
Randomness seeded to: 1
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
<exe-name> is a Catch2 v<version> host application.
|
||||
Run with -? for options
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
# A test name that starts with a #
|
||||
-------------------------------------------------------------------------------
|
||||
Misc.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Misc.tests.cpp:<line number>: PASSED:
|
||||
with message:
|
||||
yay
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1027: Bitfields can be captured
|
||||
-------------------------------------------------------------------------------
|
||||
Compilation.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( y.v == 0 )
|
||||
with expansion:
|
||||
0 == 0
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( 0 == y.v )
|
||||
with expansion:
|
||||
0 == 0
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1147
|
||||
-------------------------------------------------------------------------------
|
||||
Compilation.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( t1 == t2 )
|
||||
with expansion:
|
||||
{?} == {?}
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( t1 != t2 )
|
||||
with expansion:
|
||||
{?} != {?}
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( t1 < t2 )
|
||||
with expansion:
|
||||
{?} < {?}
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( t1 > t2 )
|
||||
with expansion:
|
||||
{?} > {?}
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( t1 <= t2 )
|
||||
with expansion:
|
||||
{?} <= {?}
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( t1 >= t2 )
|
||||
with expansion:
|
||||
{?} >= {?}
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1175 - Hidden Test
|
||||
-------------------------------------------------------------------------------
|
||||
Misc.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Misc.tests.cpp:<line number>: PASSED:
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1238
|
||||
-------------------------------------------------------------------------------
|
||||
Compilation.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( std::memcmp(uarr, "123", sizeof(uarr)) == 0 )
|
||||
with expansion:
|
||||
0 == 0
|
||||
with messages:
|
||||
uarr := "123"
|
||||
sarr := "456"
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( std::memcmp(sarr, "456", sizeof(sarr)) == 0 )
|
||||
with expansion:
|
||||
0 == 0
|
||||
with messages:
|
||||
uarr := "123"
|
||||
sarr := "456"
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1245
|
||||
-------------------------------------------------------------------------------
|
||||
Compilation.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1319: Sections can have description (even if it is not saved
|
||||
SectionName
|
||||
-------------------------------------------------------------------------------
|
||||
Compilation.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1403
|
||||
-------------------------------------------------------------------------------
|
||||
Compilation.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( h1 == h2 )
|
||||
with expansion:
|
||||
[1403 helper] == [1403 helper]
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1455 - INFO and WARN can start with a linebreak
|
||||
-------------------------------------------------------------------------------
|
||||
Message.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Message.tests.cpp:<line number>: warning:
|
||||
|
||||
This info message starts with a linebreak
|
||||
|
||||
This warning message starts with a linebreak
|
||||
|
||||
|
||||
No assertions in test case '#1455 - INFO and WARN can start with a linebreak'
|
||||
|
||||
This would not be caught previously
|
||||
Nor would this
|
||||
-------------------------------------------------------------------------------
|
||||
#1514: stderr/stdout is not captured in tests aborted by an exception
|
||||
-------------------------------------------------------------------------------
|
||||
Tricky.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Tricky.tests.cpp:<line number>: FAILED:
|
||||
explicitly with message:
|
||||
1514
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1548
|
||||
-------------------------------------------------------------------------------
|
||||
Compilation.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( std::is_same<TypeList<int>, TypeList<int>>::value )
|
||||
with expansion:
|
||||
true
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1905 -- test spec parser properly clears internal state between compound tests
|
||||
-------------------------------------------------------------------------------
|
||||
TestSpec.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
TestSpec.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( spec.matches(*fakeTestCase("spec . char")) )
|
||||
with expansion:
|
||||
true
|
||||
|
||||
TestSpec.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( spec.matches(*fakeTestCase("spec , char")) )
|
||||
with expansion:
|
||||
true
|
||||
|
||||
TestSpec.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE_FALSE( spec.matches(*fakeTestCase(R"(spec \, char)")) )
|
||||
with expansion:
|
||||
!false
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1912 -- test spec parser handles escaping
|
||||
Various parentheses
|
||||
-------------------------------------------------------------------------------
|
||||
TestSpec.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
TestSpec.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( spec.matches(*fakeTestCase(R"(spec {a} char)")) )
|
||||
with expansion:
|
||||
true
|
||||
|
||||
TestSpec.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( spec.matches(*fakeTestCase(R"(spec [a] char)")) )
|
||||
with expansion:
|
||||
true
|
||||
|
||||
TestSpec.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE_FALSE( spec.matches(*fakeTestCase("differs but has similar tag", "[a]")) )
|
||||
with expansion:
|
||||
!false
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1912 -- test spec parser handles escaping
|
||||
backslash in test name
|
||||
-------------------------------------------------------------------------------
|
||||
TestSpec.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
TestSpec.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( spec.matches(*fakeTestCase(R"(spec \ char)")) )
|
||||
with expansion:
|
||||
true
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1913 - GENERATE inside a for loop should not keep recreating the generator
|
||||
-------------------------------------------------------------------------------
|
||||
Generators.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Generators.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( counter < 7 )
|
||||
with expansion:
|
||||
3 < 7
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1913 - GENERATE inside a for loop should not keep recreating the generator
|
||||
-------------------------------------------------------------------------------
|
||||
Generators.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Generators.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( counter < 7 )
|
||||
with expansion:
|
||||
6 < 7
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1913 - GENERATEs can share a line
|
||||
-------------------------------------------------------------------------------
|
||||
Generators.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Generators.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( i != j )
|
||||
with expansion:
|
||||
1 != 3
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1913 - GENERATEs can share a line
|
||||
-------------------------------------------------------------------------------
|
||||
Generators.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Generators.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( i != j )
|
||||
with expansion:
|
||||
1 != 4
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1913 - GENERATEs can share a line
|
||||
-------------------------------------------------------------------------------
|
||||
Generators.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Generators.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( i != j )
|
||||
with expansion:
|
||||
2 != 3
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1913 - GENERATEs can share a line
|
||||
-------------------------------------------------------------------------------
|
||||
Generators.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Generators.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( i != j )
|
||||
with expansion:
|
||||
2 != 4
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - GENERATE after a section
|
||||
A
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
with message:
|
||||
A
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - GENERATE after a section
|
||||
B
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( m )
|
||||
with expansion:
|
||||
1
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - GENERATE after a section
|
||||
B
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( m )
|
||||
with expansion:
|
||||
2
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - GENERATE after a section
|
||||
B
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( m )
|
||||
with expansion:
|
||||
3
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - Section followed by flat generate
|
||||
A
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( 1 )
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - Section followed by flat generate
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( m )
|
||||
with expansion:
|
||||
2
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - Section followed by flat generate
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( m )
|
||||
with expansion:
|
||||
3
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - flat generate
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( m )
|
||||
with expansion:
|
||||
1
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - flat generate
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( m )
|
||||
with expansion:
|
||||
2
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - flat generate
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( m )
|
||||
with expansion:
|
||||
3
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - mixed sections and generates
|
||||
A
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
with message:
|
||||
A
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - mixed sections and generates
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
with messages:
|
||||
i := 1
|
||||
j := 3
|
||||
k := 5
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - mixed sections and generates
|
||||
B
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
with message:
|
||||
B
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - mixed sections and generates
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
with messages:
|
||||
i := 1
|
||||
j := 3
|
||||
k := 6
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - mixed sections and generates
|
||||
B
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
with message:
|
||||
B
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - mixed sections and generates
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
with messages:
|
||||
i := 1
|
||||
j := 4
|
||||
k := 5
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - mixed sections and generates
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
with messages:
|
||||
i := 1
|
||||
j := 4
|
||||
k := 6
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - mixed sections and generates
|
||||
A
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
with message:
|
||||
A
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - mixed sections and generates
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
with messages:
|
||||
i := 2
|
||||
j := 3
|
||||
k := 5
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - mixed sections and generates
|
||||
B
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
with message:
|
||||
B
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - mixed sections and generates
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
with messages:
|
||||
i := 2
|
||||
j := 3
|
||||
k := 6
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - mixed sections and generates
|
||||
B
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
with message:
|
||||
B
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - mixed sections and generates
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
with messages:
|
||||
i := 2
|
||||
j := 4
|
||||
k := 5
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - mixed sections and generates
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
with messages:
|
||||
i := 2
|
||||
j := 4
|
||||
k := 6
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - nested generate
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( m )
|
||||
with expansion:
|
||||
1
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( n )
|
||||
with expansion:
|
||||
1
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - nested generate
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( m )
|
||||
with expansion:
|
||||
1
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( n )
|
||||
with expansion:
|
||||
2
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - nested generate
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( m )
|
||||
with expansion:
|
||||
1
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( n )
|
||||
with expansion:
|
||||
3
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - nested generate
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( m )
|
||||
with expansion:
|
||||
2
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( n )
|
||||
with expansion:
|
||||
1
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - nested generate
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( m )
|
||||
with expansion:
|
||||
2
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( n )
|
||||
with expansion:
|
||||
2
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - nested generate
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( m )
|
||||
with expansion:
|
||||
2
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( n )
|
||||
with expansion:
|
||||
3
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - nested generate
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( m )
|
||||
with expansion:
|
||||
3
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( n )
|
||||
with expansion:
|
||||
1
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - nested generate
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( m )
|
||||
with expansion:
|
||||
3
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( n )
|
||||
with expansion:
|
||||
2
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1938 - nested generate
|
||||
-------------------------------------------------------------------------------
|
||||
PartTracker.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( m )
|
||||
with expansion:
|
||||
3
|
||||
|
||||
PartTracker.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( n )
|
||||
with expansion:
|
||||
3
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1954 - 7 arg template test case sig compiles - 1, 1, 1, 1, 1, 0, 0
|
||||
-------------------------------------------------------------------------------
|
||||
Misc.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Misc.tests.cpp:<line number>: PASSED:
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1954 - 7 arg template test case sig compiles - 5, 1, 1, 1, 1, 0, 0
|
||||
-------------------------------------------------------------------------------
|
||||
Misc.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Misc.tests.cpp:<line number>: PASSED:
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#1954 - 7 arg template test case sig compiles - 5, 3, 1, 1, 1, 0, 0
|
||||
-------------------------------------------------------------------------------
|
||||
Misc.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Misc.tests.cpp:<line number>: PASSED:
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#2152 - ULP checks between differently signed values were wrong - double
|
||||
-------------------------------------------------------------------------------
|
||||
Matchers.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Matchers.tests.cpp:<line number>: PASSED:
|
||||
CHECK_THAT( smallest_non_zero, WithinULP( -smallest_non_zero, 2 ) )
|
||||
with expansion:
|
||||
0.0 is within 2 ULPs of -4.9406564584124654e-324 ([-1.4821969375237396e-323,
|
||||
4.9406564584124654e-324])
|
||||
|
||||
Matchers.tests.cpp:<line number>: PASSED:
|
||||
CHECK_THAT( smallest_non_zero, !WithinULP( -smallest_non_zero, 1 ) )
|
||||
with expansion:
|
||||
0.0 not is within 1 ULPs of -4.9406564584124654e-324 ([-9.8813129168249309e-
|
||||
324, -0.0000000000000000e+00])
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#2152 - ULP checks between differently signed values were wrong - float
|
||||
-------------------------------------------------------------------------------
|
||||
Matchers.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Matchers.tests.cpp:<line number>: PASSED:
|
||||
CHECK_THAT( smallest_non_zero, WithinULP( -smallest_non_zero, 2 ) )
|
||||
with expansion:
|
||||
0.0f is within 2 ULPs of -1.40129846e-45f ([-4.20389539e-45, 1.40129846e-45])
|
||||
|
||||
Matchers.tests.cpp:<line number>: PASSED:
|
||||
CHECK_THAT( smallest_non_zero, !WithinULP( -smallest_non_zero, 1 ) )
|
||||
with expansion:
|
||||
0.0f not is within 1 ULPs of -1.40129846e-45f ([-2.80259693e-45, -0.
|
||||
00000000e+00])
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#2615 - Throwing in constructor generator fails test case but does not abort
|
||||
-------------------------------------------------------------------------------
|
||||
Generators.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Generators.tests.cpp:<line number>: FAILED:
|
||||
due to unexpected exception with message:
|
||||
failure to init
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#748 - captures with unexpected exceptions
|
||||
outside assertions
|
||||
-------------------------------------------------------------------------------
|
||||
Exception.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Exception.tests.cpp:<line number>: FAILED:
|
||||
due to unexpected exception with messages:
|
||||
answer := 42
|
||||
expected exception
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#748 - captures with unexpected exceptions
|
||||
inside REQUIRE_NOTHROW
|
||||
-------------------------------------------------------------------------------
|
||||
Exception.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Exception.tests.cpp:<line number>: FAILED:
|
||||
REQUIRE_NOTHROW( thisThrows() )
|
||||
due to unexpected exception with messages:
|
||||
answer := 42
|
||||
expected exception
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#748 - captures with unexpected exceptions
|
||||
inside REQUIRE_THROWS
|
||||
-------------------------------------------------------------------------------
|
||||
Exception.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Exception.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE_THROWS( thisThrows() )
|
||||
with message:
|
||||
answer := 42
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#809
|
||||
-------------------------------------------------------------------------------
|
||||
Compilation.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( 42 == f )
|
||||
with expansion:
|
||||
42 == {?}
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#833
|
||||
-------------------------------------------------------------------------------
|
||||
Compilation.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( a == t )
|
||||
with expansion:
|
||||
3 == 3
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
CHECK( a == t )
|
||||
with expansion:
|
||||
3 == 3
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE_THROWS( throws_int(true) )
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
CHECK_THROWS_AS( throws_int(true), int )
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE_NOTHROW( throws_int(false) )
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE_THAT( "aaa", Catch::Matchers::EndsWith("aaa") )
|
||||
with expansion:
|
||||
"aaa" ends with: "aaa"
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( templated_tests<int>(3) )
|
||||
with expansion:
|
||||
true
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#835 -- errno should not be touched by Catch2
|
||||
-------------------------------------------------------------------------------
|
||||
Misc.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Misc.tests.cpp:<line number>: FAILED:
|
||||
CHECK( f() == 0 )
|
||||
with expansion:
|
||||
1 == 0
|
||||
|
||||
Misc.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( errno_after == 1 )
|
||||
with expansion:
|
||||
1 == 1
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#872
|
||||
-------------------------------------------------------------------------------
|
||||
Compilation.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Compilation.tests.cpp:<line number>: PASSED:
|
||||
REQUIRE( x == 4 )
|
||||
with expansion:
|
||||
{?} == 4
|
||||
with message:
|
||||
dummy := 0
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#961 -- Dynamically created sections should all be reported
|
||||
Looped section 0
|
||||
-------------------------------------------------------------------------------
|
||||
Misc.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Misc.tests.cpp:<line number>: PASSED:
|
||||
with message:
|
||||
Everything is OK
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#961 -- Dynamically created sections should all be reported
|
||||
Looped section 1
|
||||
-------------------------------------------------------------------------------
|
||||
Misc.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Misc.tests.cpp:<line number>: PASSED:
|
||||
with message:
|
||||
Everything is OK
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#961 -- Dynamically created sections should all be reported
|
||||
Looped section 2
|
||||
-------------------------------------------------------------------------------
|
||||
Misc.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Misc.tests.cpp:<line number>: PASSED:
|
||||
with message:
|
||||
Everything is OK
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#961 -- Dynamically created sections should all be reported
|
||||
Looped section 3
|
||||
-------------------------------------------------------------------------------
|
||||
Misc.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Misc.tests.cpp:<line number>: PASSED:
|
||||
with message:
|
||||
Everything is OK
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
#961 -- Dynamically created sections should all be reported
|
||||
Looped section 4
|
||||
-------------------------------------------------------------------------------
|
||||
Misc.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Misc.tests.cpp:<line number>: PASSED:
|
||||
with message:
|
||||
Everything is OK
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
'Not' checks that should fail
|
||||
-------------------------------------------------------------------------------
|
||||
Condition.tests.cpp:<line number>
|
||||
...............................................................................
|
||||
|
||||
Condition.tests.cpp:<line number>: FAILED:
|
||||
CHECK( false != false )
|
||||
|
||||
Condition.tests.cpp:<line number>: FAILED:
|
||||
CHECK( true != true )
|
||||
|
||||
===============================================================================
|
||||
test cases: 33 | 27 passed | 3 failed | 3 failed as expected
|
||||
assertions: 102 | 94 passed | 4 failed | 4 failed as expected
|
||||
|
||||
11
externals/catch2/tests/SelfTest/Baselines/default.sw.multi.approved.txt
vendored
Normal file
11
externals/catch2/tests/SelfTest/Baselines/default.sw.multi.approved.txt
vendored
Normal file
@@ -0,0 +1,11 @@
|
||||
This would not be caught previously
|
||||
Nor would this
|
||||
A string sent directly to stdout
|
||||
A string sent directly to stderr
|
||||
A string sent to stderr via clog
|
||||
Message from section one
|
||||
Message from section two
|
||||
loose text artifact
|
||||
a!
|
||||
b1!
|
||||
!
|
||||
2052
externals/catch2/tests/SelfTest/Baselines/junit.sw.approved.txt
vendored
Normal file
2052
externals/catch2/tests/SelfTest/Baselines/junit.sw.approved.txt
vendored
Normal file
File diff suppressed because it is too large
Load Diff
2051
externals/catch2/tests/SelfTest/Baselines/junit.sw.multi.approved.txt
vendored
Normal file
2051
externals/catch2/tests/SelfTest/Baselines/junit.sw.multi.approved.txt
vendored
Normal file
File diff suppressed because it is too large
Load Diff
2071
externals/catch2/tests/SelfTest/Baselines/sonarqube.sw.approved.txt
vendored
Normal file
2071
externals/catch2/tests/SelfTest/Baselines/sonarqube.sw.approved.txt
vendored
Normal file
File diff suppressed because it is too large
Load Diff
2070
externals/catch2/tests/SelfTest/Baselines/sonarqube.sw.multi.approved.txt
vendored
Normal file
2070
externals/catch2/tests/SelfTest/Baselines/sonarqube.sw.multi.approved.txt
vendored
Normal file
File diff suppressed because it is too large
Load Diff
4481
externals/catch2/tests/SelfTest/Baselines/tap.sw.approved.txt
vendored
Normal file
4481
externals/catch2/tests/SelfTest/Baselines/tap.sw.approved.txt
vendored
Normal file
File diff suppressed because it is too large
Load Diff
4470
externals/catch2/tests/SelfTest/Baselines/tap.sw.multi.approved.txt
vendored
Normal file
4470
externals/catch2/tests/SelfTest/Baselines/tap.sw.multi.approved.txt
vendored
Normal file
File diff suppressed because it is too large
Load Diff
998
externals/catch2/tests/SelfTest/Baselines/teamcity.sw.approved.txt
vendored
Normal file
998
externals/catch2/tests/SelfTest/Baselines/teamcity.sw.approved.txt
vendored
Normal file
@@ -0,0 +1,998 @@
|
||||
##teamcity[testSuiteStarted name='<exe-name>']
|
||||
##teamcity[testStarted name='# A test name that starts with a #']
|
||||
##teamcity[testFinished name='# A test name that starts with a #' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1027: Bitfields can be captured']
|
||||
##teamcity[testFinished name='#1027: Bitfields can be captured' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1147']
|
||||
##teamcity[testFinished name='#1147' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1175 - Hidden Test']
|
||||
##teamcity[testFinished name='#1175 - Hidden Test' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1238']
|
||||
##teamcity[testFinished name='#1238' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1245']
|
||||
##teamcity[testFinished name='#1245' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1319: Sections can have description (even if it is not saved']
|
||||
##teamcity[testFinished name='#1319: Sections can have description (even if it is not saved' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1403']
|
||||
##teamcity[testFinished name='#1403' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1455 - INFO and WARN can start with a linebreak']
|
||||
##teamcity[testFinished name='#1455 - INFO and WARN can start with a linebreak' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1514: stderr/stdout is not captured in tests aborted by an exception']
|
||||
##teamcity[testFailed name='#1514: stderr/stdout is not captured in tests aborted by an exception' message='Tricky.tests.cpp:<line number>|n...............................................................................|n|nTricky.tests.cpp:<line number>|nexplicit failure with message:|n "1514"']
|
||||
##teamcity[testStdOut name='#1514: stderr/stdout is not captured in tests aborted by an exception' out='This would not be caught previously|n']
|
||||
##teamcity[testStdErr name='#1514: stderr/stdout is not captured in tests aborted by an exception' out='Nor would this|n']
|
||||
##teamcity[testFinished name='#1514: stderr/stdout is not captured in tests aborted by an exception' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1548']
|
||||
##teamcity[testFinished name='#1548' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1905 -- test spec parser properly clears internal state between compound tests']
|
||||
##teamcity[testFinished name='#1905 -- test spec parser properly clears internal state between compound tests' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1912 -- test spec parser handles escaping']
|
||||
##teamcity[testFinished name='#1912 -- test spec parser handles escaping' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1913 - GENERATE inside a for loop should not keep recreating the generator']
|
||||
##teamcity[testFinished name='#1913 - GENERATE inside a for loop should not keep recreating the generator' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1913 - GENERATEs can share a line']
|
||||
##teamcity[testFinished name='#1913 - GENERATEs can share a line' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1938 - GENERATE after a section']
|
||||
##teamcity[testFinished name='#1938 - GENERATE after a section' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1938 - Section followed by flat generate']
|
||||
##teamcity[testFinished name='#1938 - Section followed by flat generate' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1938 - flat generate']
|
||||
##teamcity[testFinished name='#1938 - flat generate' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1938 - mixed sections and generates']
|
||||
##teamcity[testFinished name='#1938 - mixed sections and generates' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1938 - nested generate']
|
||||
##teamcity[testFinished name='#1938 - nested generate' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1954 - 7 arg template test case sig compiles - 1, 1, 1, 1, 1, 0, 0']
|
||||
##teamcity[testFinished name='#1954 - 7 arg template test case sig compiles - 1, 1, 1, 1, 1, 0, 0' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1954 - 7 arg template test case sig compiles - 5, 1, 1, 1, 1, 0, 0']
|
||||
##teamcity[testFinished name='#1954 - 7 arg template test case sig compiles - 5, 1, 1, 1, 1, 0, 0' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1954 - 7 arg template test case sig compiles - 5, 3, 1, 1, 1, 0, 0']
|
||||
##teamcity[testFinished name='#1954 - 7 arg template test case sig compiles - 5, 3, 1, 1, 1, 0, 0' duration="{duration}"]
|
||||
##teamcity[testStarted name='#2152 - ULP checks between differently signed values were wrong - double']
|
||||
##teamcity[testFinished name='#2152 - ULP checks between differently signed values were wrong - double' duration="{duration}"]
|
||||
##teamcity[testStarted name='#2152 - ULP checks between differently signed values were wrong - float']
|
||||
##teamcity[testFinished name='#2152 - ULP checks between differently signed values were wrong - float' duration="{duration}"]
|
||||
##teamcity[testStarted name='#2615 - Throwing in constructor generator fails test case but does not abort']
|
||||
##teamcity[testIgnored name='#2615 - Throwing in constructor generator fails test case but does not abort' message='Generators.tests.cpp:<line number>|n...............................................................................|n|nGenerators.tests.cpp:<line number>|nunexpected exception with message:|n "failure to init"- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testFinished name='#2615 - Throwing in constructor generator fails test case but does not abort' duration="{duration}"]
|
||||
##teamcity[testStarted name='#748 - captures with unexpected exceptions']
|
||||
##teamcity[testIgnored name='#748 - captures with unexpected exceptions' message='-------------------------------------------------------------------------------|noutside assertions|n-------------------------------------------------------------------------------|nException.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with messages:|n "answer := 42"|n "expected exception"- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='#748 - captures with unexpected exceptions' message='-------------------------------------------------------------------------------|ninside REQUIRE_NOTHROW|n-------------------------------------------------------------------------------|nException.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with messages:|n "answer := 42"|n "expected exception"|n REQUIRE_NOTHROW( thisThrows() )|nwith expansion:|n thisThrows()|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testFinished name='#748 - captures with unexpected exceptions' duration="{duration}"]
|
||||
##teamcity[testStarted name='#809']
|
||||
##teamcity[testFinished name='#809' duration="{duration}"]
|
||||
##teamcity[testStarted name='#833']
|
||||
##teamcity[testFinished name='#833' duration="{duration}"]
|
||||
##teamcity[testStarted name='#835 -- errno should not be touched by Catch2']
|
||||
##teamcity[testIgnored name='#835 -- errno should not be touched by Catch2' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n CHECK( f() == 0 )|nwith expansion:|n 1 == 0|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testFinished name='#835 -- errno should not be touched by Catch2' duration="{duration}"]
|
||||
##teamcity[testStarted name='#872']
|
||||
##teamcity[testFinished name='#872' duration="{duration}"]
|
||||
##teamcity[testStarted name='#961 -- Dynamically created sections should all be reported']
|
||||
##teamcity[testFinished name='#961 -- Dynamically created sections should all be reported' duration="{duration}"]
|
||||
##teamcity[testStarted name='|'Not|' checks that should fail']
|
||||
##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexpression failed|n CHECK( false != false )|nwith expansion:|n false != false|n']
|
||||
##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( true != true )|nwith expansion:|n true != true|n']
|
||||
##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( !true )|nwith expansion:|n false|n']
|
||||
##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK_FALSE( true )|nwith expansion:|n !true|n']
|
||||
##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( !trueValue )|nwith expansion:|n false|n']
|
||||
##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK_FALSE( trueValue )|nwith expansion:|n !true|n']
|
||||
##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( !(1 == 1) )|nwith expansion:|n false|n']
|
||||
##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK_FALSE( 1 == 1 )|nwith expansion:|n !(1 == 1)|n']
|
||||
##teamcity[testFinished name='|'Not|' checks that should fail' duration="{duration}"]
|
||||
##teamcity[testStarted name='|'Not|' checks that should succeed']
|
||||
##teamcity[testFinished name='|'Not|' checks that should succeed' duration="{duration}"]
|
||||
##teamcity[testStarted name='(unimplemented) static bools can be evaluated']
|
||||
##teamcity[testFinished name='(unimplemented) static bools can be evaluated' duration="{duration}"]
|
||||
##teamcity[testStarted name='3x3x3 ints']
|
||||
##teamcity[testFinished name='3x3x3 ints' duration="{duration}"]
|
||||
##teamcity[testStarted name='A METHOD_AS_TEST_CASE based test run that fails']
|
||||
##teamcity[testFailed name='A METHOD_AS_TEST_CASE based test run that fails' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( s == "world" )|nwith expansion:|n "hello" == "world"|n']
|
||||
##teamcity[testFinished name='A METHOD_AS_TEST_CASE based test run that fails' duration="{duration}"]
|
||||
##teamcity[testStarted name='A METHOD_AS_TEST_CASE based test run that succeeds']
|
||||
##teamcity[testFinished name='A METHOD_AS_TEST_CASE based test run that succeeds' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<float>']
|
||||
##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<float>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<float>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>']
|
||||
##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>']
|
||||
##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>']
|
||||
##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<float>']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<float>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<int>']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<int>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<float>']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<float>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<int>']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<int>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<float, 6>']
|
||||
##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<float, 6>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 6 < 2|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<float, 6>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>']
|
||||
##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 2 < 2|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>']
|
||||
##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 6 < 2|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>']
|
||||
##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 2 < 2|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<float,6>']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<float,6>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<int,2>']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<int,2>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<float,6>']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<float,6>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<int,2>']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<int,2>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - double']
|
||||
##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - double' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n 1.0 == 2|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - double' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - float']
|
||||
##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - float' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n 1.0f == 2|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - float' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - int']
|
||||
##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - int' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n 1 == 2|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - int' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - float']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - float' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - int']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - int' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1']
|
||||
##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n 1 == 0|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3']
|
||||
##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n 3 == 0|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6']
|
||||
##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n 6 == 0|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 3']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 3' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 6']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 6' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEST_CASE_METHOD based test run that fails']
|
||||
##teamcity[testFailed name='A TEST_CASE_METHOD based test run that fails' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( m_a == 2 )|nwith expansion:|n 1 == 2|n']
|
||||
##teamcity[testFinished name='A TEST_CASE_METHOD based test run that fails' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEST_CASE_METHOD based test run that succeeds']
|
||||
##teamcity[testFinished name='A TEST_CASE_METHOD based test run that succeeds' duration="{duration}"]
|
||||
##teamcity[testStarted name='A Template product test case - Foo<float>']
|
||||
##teamcity[testFinished name='A Template product test case - Foo<float>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A Template product test case - Foo<int>']
|
||||
##teamcity[testFinished name='A Template product test case - Foo<int>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A Template product test case - std::vector<float>']
|
||||
##teamcity[testFinished name='A Template product test case - std::vector<float>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A Template product test case - std::vector<int>']
|
||||
##teamcity[testFinished name='A Template product test case - std::vector<int>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A Template product test case with array signature - Bar<float, 42>']
|
||||
##teamcity[testFinished name='A Template product test case with array signature - Bar<float, 42>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A Template product test case with array signature - Bar<int, 9>']
|
||||
##teamcity[testFinished name='A Template product test case with array signature - Bar<int, 9>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A Template product test case with array signature - std::array<float, 42>']
|
||||
##teamcity[testFinished name='A Template product test case with array signature - std::array<float, 42>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A Template product test case with array signature - std::array<int, 9>']
|
||||
##teamcity[testFinished name='A Template product test case with array signature - std::array<int, 9>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A comparison that uses literals instead of the normal constructor']
|
||||
##teamcity[testFinished name='A comparison that uses literals instead of the normal constructor' duration="{duration}"]
|
||||
##teamcity[testStarted name='A couple of nested sections followed by a failure']
|
||||
##teamcity[testFailed name='A couple of nested sections followed by a failure' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexplicit failure with message:|n "to infinity and beyond"']
|
||||
##teamcity[testFinished name='A couple of nested sections followed by a failure' duration="{duration}"]
|
||||
##teamcity[testStarted name='A failing expression with a non streamable type is still captured']
|
||||
##teamcity[testFailed name='A failing expression with a non streamable type is still captured' message='Tricky.tests.cpp:<line number>|n...............................................................................|n|nTricky.tests.cpp:<line number>|nexpression failed|n CHECK( &o1 == &o2 )|nwith expansion:|n 0x<hex digits> == 0x<hex digits>|n']
|
||||
##teamcity[testFailed name='A failing expression with a non streamable type is still captured' message='Tricky.tests.cpp:<line number>|nexpression failed|n CHECK( o1 == o2 )|nwith expansion:|n {?} == {?}|n']
|
||||
##teamcity[testFinished name='A failing expression with a non streamable type is still captured' duration="{duration}"]
|
||||
##teamcity[testStarted name='Absolute margin']
|
||||
##teamcity[testFinished name='Absolute margin' duration="{duration}"]
|
||||
##teamcity[testStarted name='An empty test with no assertions']
|
||||
##teamcity[testFinished name='An empty test with no assertions' duration="{duration}"]
|
||||
##teamcity[testStarted name='An expression with side-effects should only be evaluated once']
|
||||
##teamcity[testFinished name='An expression with side-effects should only be evaluated once' duration="{duration}"]
|
||||
##teamcity[testStarted name='An unchecked exception reports the line of the last assertion']
|
||||
##teamcity[testFailed name='An unchecked exception reports the line of the last assertion' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "unexpected exception"|n {Unknown expression after the reported line}|nwith expansion:|n {Unknown expression after the reported line}|n']
|
||||
##teamcity[testFinished name='An unchecked exception reports the line of the last assertion' duration="{duration}"]
|
||||
##teamcity[testStarted name='Anonymous test case 1']
|
||||
##teamcity[testFinished name='Anonymous test case 1' duration="{duration}"]
|
||||
##teamcity[testStarted name='Approx setters validate their arguments']
|
||||
##teamcity[testFinished name='Approx setters validate their arguments' duration="{duration}"]
|
||||
##teamcity[testStarted name='Approx with exactly-representable margin']
|
||||
##teamcity[testFinished name='Approx with exactly-representable margin' duration="{duration}"]
|
||||
##teamcity[testStarted name='Approximate PI']
|
||||
##teamcity[testFinished name='Approximate PI' duration="{duration}"]
|
||||
##teamcity[testStarted name='Approximate comparisons with different epsilons']
|
||||
##teamcity[testFinished name='Approximate comparisons with different epsilons' duration="{duration}"]
|
||||
##teamcity[testStarted name='Approximate comparisons with floats']
|
||||
##teamcity[testFinished name='Approximate comparisons with floats' duration="{duration}"]
|
||||
##teamcity[testStarted name='Approximate comparisons with ints']
|
||||
##teamcity[testFinished name='Approximate comparisons with ints' duration="{duration}"]
|
||||
##teamcity[testStarted name='Approximate comparisons with mixed numeric types']
|
||||
##teamcity[testFinished name='Approximate comparisons with mixed numeric types' duration="{duration}"]
|
||||
##teamcity[testStarted name='Arbitrary predicate matcher']
|
||||
##teamcity[testFinished name='Arbitrary predicate matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Assertion macros support bit operators and bool conversions']
|
||||
##teamcity[testFinished name='Assertion macros support bit operators and bool conversions' duration="{duration}"]
|
||||
##teamcity[testStarted name='Assertions then sections']
|
||||
##teamcity[testFinished name='Assertions then sections' duration="{duration}"]
|
||||
##teamcity[testStarted name='Basic use of the Contains range matcher']
|
||||
##teamcity[testFinished name='Basic use of the Contains range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Basic use of the Empty range matcher']
|
||||
##teamcity[testFinished name='Basic use of the Empty range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='CAPTURE can deal with complex expressions']
|
||||
##teamcity[testFinished name='CAPTURE can deal with complex expressions' duration="{duration}"]
|
||||
##teamcity[testStarted name='CAPTURE can deal with complex expressions involving commas']
|
||||
##teamcity[testFinished name='CAPTURE can deal with complex expressions involving commas' duration="{duration}"]
|
||||
##teamcity[testStarted name='CAPTURE parses string and character constants']
|
||||
##teamcity[testFinished name='CAPTURE parses string and character constants' duration="{duration}"]
|
||||
##teamcity[testStarted name='Capture and info messages']
|
||||
##teamcity[testFinished name='Capture and info messages' duration="{duration}"]
|
||||
##teamcity[testStarted name='CaseInsensitiveEqualsTo is case insensitive']
|
||||
##teamcity[testFinished name='CaseInsensitiveEqualsTo is case insensitive' duration="{duration}"]
|
||||
##teamcity[testStarted name='CaseInsensitiveLess is case insensitive']
|
||||
##teamcity[testFinished name='CaseInsensitiveLess is case insensitive' duration="{duration}"]
|
||||
##teamcity[testStarted name='Character pretty printing']
|
||||
##teamcity[testFinished name='Character pretty printing' duration="{duration}"]
|
||||
##teamcity[testStarted name='Clara::Arg supports single-arg parse the way Opt does']
|
||||
##teamcity[testFinished name='Clara::Arg supports single-arg parse the way Opt does' duration="{duration}"]
|
||||
##teamcity[testStarted name='Clara::Opt supports accept-many lambdas']
|
||||
##teamcity[testFinished name='Clara::Opt supports accept-many lambdas' duration="{duration}"]
|
||||
##teamcity[testStarted name='ColourGuard behaviour']
|
||||
##teamcity[testFinished name='ColourGuard behaviour' duration="{duration}"]
|
||||
##teamcity[testStarted name='Combining MatchAllOfGeneric does not nest']
|
||||
##teamcity[testFinished name='Combining MatchAllOfGeneric does not nest' duration="{duration}"]
|
||||
##teamcity[testStarted name='Combining MatchAnyOfGeneric does not nest']
|
||||
##teamcity[testFinished name='Combining MatchAnyOfGeneric does not nest' duration="{duration}"]
|
||||
##teamcity[testStarted name='Combining MatchNotOfGeneric does not nest']
|
||||
##teamcity[testFinished name='Combining MatchNotOfGeneric does not nest' duration="{duration}"]
|
||||
##teamcity[testStarted name='Combining concrete matchers does not use templated matchers']
|
||||
##teamcity[testFinished name='Combining concrete matchers does not use templated matchers' duration="{duration}"]
|
||||
##teamcity[testStarted name='Combining only templated matchers']
|
||||
##teamcity[testFinished name='Combining only templated matchers' duration="{duration}"]
|
||||
##teamcity[testStarted name='Combining templated and concrete matchers']
|
||||
##teamcity[testFinished name='Combining templated and concrete matchers' duration="{duration}"]
|
||||
##teamcity[testStarted name='Combining templated matchers']
|
||||
##teamcity[testFinished name='Combining templated matchers' duration="{duration}"]
|
||||
##teamcity[testStarted name='Commas in various macros are allowed']
|
||||
##teamcity[testFinished name='Commas in various macros are allowed' duration="{duration}"]
|
||||
##teamcity[testStarted name='Comparing function pointers']
|
||||
##teamcity[testFinished name='Comparing function pointers' duration="{duration}"]
|
||||
##teamcity[testStarted name='Comparison ops']
|
||||
##teamcity[testFinished name='Comparison ops' duration="{duration}"]
|
||||
##teamcity[testStarted name='Comparison with explicitly convertible types']
|
||||
##teamcity[testFinished name='Comparison with explicitly convertible types' duration="{duration}"]
|
||||
##teamcity[testStarted name='Comparisons between ints where one side is computed']
|
||||
##teamcity[testFinished name='Comparisons between ints where one side is computed' duration="{duration}"]
|
||||
##teamcity[testStarted name='Comparisons between unsigned ints and negative signed ints match c++ standard behaviour']
|
||||
##teamcity[testFinished name='Comparisons between unsigned ints and negative signed ints match c++ standard behaviour' duration="{duration}"]
|
||||
##teamcity[testStarted name='Comparisons with int literals don|'t warn when mixing signed/ unsigned']
|
||||
##teamcity[testFinished name='Comparisons with int literals don|'t warn when mixing signed/ unsigned' duration="{duration}"]
|
||||
##teamcity[testStarted name='Composed generic matchers shortcircuit']
|
||||
##teamcity[testFinished name='Composed generic matchers shortcircuit' duration="{duration}"]
|
||||
##teamcity[testStarted name='Composed matchers shortcircuit']
|
||||
##teamcity[testFinished name='Composed matchers shortcircuit' duration="{duration}"]
|
||||
##teamcity[testStarted name='Contains string matcher']
|
||||
##teamcity[testFailed name='Contains string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), ContainsSubstring( "not there", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" contains: "not there" (case insensitive)|n']
|
||||
##teamcity[testFailed name='Contains string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), ContainsSubstring( "STRING" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" contains: "STRING"|n']
|
||||
##teamcity[testFinished name='Contains string matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Copy and then generate a range']
|
||||
##teamcity[testFinished name='Copy and then generate a range' duration="{duration}"]
|
||||
##teamcity[testStarted name='Cout stream properly declares it writes to stdout']
|
||||
##teamcity[testFinished name='Cout stream properly declares it writes to stdout' duration="{duration}"]
|
||||
##teamcity[testStarted name='Custom exceptions can be translated when testing for nothrow']
|
||||
##teamcity[testFailed name='Custom exceptions can be translated when testing for nothrow' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "custom exception - not std"|n REQUIRE_NOTHROW( throwCustom() )|nwith expansion:|n throwCustom()|n']
|
||||
##teamcity[testFinished name='Custom exceptions can be translated when testing for nothrow' duration="{duration}"]
|
||||
##teamcity[testStarted name='Custom exceptions can be translated when testing for throwing as something else']
|
||||
##teamcity[testFailed name='Custom exceptions can be translated when testing for throwing as something else' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "custom exception - not std"|n REQUIRE_THROWS_AS( throwCustom(), std::exception )|nwith expansion:|n throwCustom(), std::exception|n']
|
||||
##teamcity[testFinished name='Custom exceptions can be translated when testing for throwing as something else' duration="{duration}"]
|
||||
##teamcity[testStarted name='Custom std-exceptions can be custom translated']
|
||||
##teamcity[testFailed name='Custom std-exceptions can be custom translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "custom std exception"']
|
||||
##teamcity[testFinished name='Custom std-exceptions can be custom translated' duration="{duration}"]
|
||||
##teamcity[testStarted name='Default scale is invisible to comparison']
|
||||
##teamcity[testFinished name='Default scale is invisible to comparison' duration="{duration}"]
|
||||
##teamcity[testStarted name='Directly creating an EnumInfo']
|
||||
##teamcity[testFinished name='Directly creating an EnumInfo' duration="{duration}"]
|
||||
##teamcity[testStarted name='Empty stream name opens cout stream']
|
||||
##teamcity[testFinished name='Empty stream name opens cout stream' duration="{duration}"]
|
||||
##teamcity[testStarted name='Empty tag is not allowed']
|
||||
##teamcity[testFinished name='Empty tag is not allowed' duration="{duration}"]
|
||||
##teamcity[testStarted name='EndsWith string matcher']
|
||||
##teamcity[testFailed name='EndsWith string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), EndsWith( "Substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" ends with: "Substring"|n']
|
||||
##teamcity[testFailed name='EndsWith string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" ends with: "this" (case insensitive)|n']
|
||||
##teamcity[testFinished name='EndsWith string matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Enums can quickly have stringification enabled using REGISTER_ENUM']
|
||||
##teamcity[testFinished name='Enums can quickly have stringification enabled using REGISTER_ENUM' duration="{duration}"]
|
||||
##teamcity[testStarted name='Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM']
|
||||
##teamcity[testFinished name='Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM' duration="{duration}"]
|
||||
##teamcity[testStarted name='Epsilon only applies to Approx|'s value']
|
||||
##teamcity[testFinished name='Epsilon only applies to Approx|'s value' duration="{duration}"]
|
||||
##teamcity[testStarted name='Equality checks that should fail']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven == 6 )|nwith expansion:|n 7 == 6|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven == 8 )|nwith expansion:|n 7 == 8|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven == 0 )|nwith expansion:|n 7 == 0|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 9.11f ) )|nwith expansion:|n 9.1f == Approx( 9.1099996567 )|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 9.0f ) )|nwith expansion:|n 9.1f == Approx( 9.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 1 ) )|nwith expansion:|n 9.1f == Approx( 1.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 0 ) )|nwith expansion:|n 9.1f == Approx( 0.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.double_pi == Approx( 3.1415 ) )|nwith expansion:|n 3.1415926535 == Approx( 3.1415 )|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello == "goodbye" )|nwith expansion:|n "hello" == "goodbye"|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello == "hell" )|nwith expansion:|n "hello" == "hell"|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello == "hello1" )|nwith expansion:|n "hello" == "hello1"|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello.size() == 6 )|nwith expansion:|n 5 == 6|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( x == Approx( 1.301 ) )|nwith expansion:|n 1.3 == Approx( 1.301 )|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testFinished name='Equality checks that should fail' duration="{duration}"]
|
||||
##teamcity[testStarted name='Equality checks that should succeed']
|
||||
##teamcity[testFinished name='Equality checks that should succeed' duration="{duration}"]
|
||||
##teamcity[testStarted name='Equals']
|
||||
##teamcity[testFinished name='Equals' duration="{duration}"]
|
||||
##teamcity[testStarted name='Equals string matcher']
|
||||
##teamcity[testFailed name='Equals string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Equals( "this string contains |'ABC|' as a substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" equals: "this string contains |'ABC|' as a substring"|n']
|
||||
##teamcity[testFailed name='Equals string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Equals( "something else", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" equals: "something else" (case insensitive)|n']
|
||||
##teamcity[testFinished name='Equals string matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified']
|
||||
##teamcity[testFinished name='Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified' duration="{duration}"]
|
||||
##teamcity[testStarted name='Exception matchers that fail']
|
||||
##teamcity[testFailed name='Exception matchers that fail' message='-------------------------------------------------------------------------------|nNo exception|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nno exception was thrown where one was expected|n CHECK_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n doesNotThrow(), SpecialException, ExceptionMatcher{ 1 }|n']
|
||||
##teamcity[testFailed name='Exception matchers that fail' message='Matchers.tests.cpp:<line number>|nno exception was thrown where one was expected|n REQUIRE_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n doesNotThrow(), SpecialException, ExceptionMatcher{ 1 }|n']
|
||||
##teamcity[testFailed name='Exception matchers that fail' message='-------------------------------------------------------------------------------|nType mismatch|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nunexpected exception with message:|n "Unknown exception"|n CHECK_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 }|n']
|
||||
##teamcity[testFailed name='Exception matchers that fail' message='Matchers.tests.cpp:<line number>|nunexpected exception with message:|n "Unknown exception"|n REQUIRE_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 }|n']
|
||||
##teamcity[testFailed name='Exception matchers that fail' message='-------------------------------------------------------------------------------|nContents are wrong|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THROWS_MATCHES( throwsSpecialException( 3 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n SpecialException::what special exception has value of 1|n']
|
||||
##teamcity[testFailed name='Exception matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n REQUIRE_THROWS_MATCHES( throwsSpecialException( 4 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n SpecialException::what special exception has value of 1|n']
|
||||
##teamcity[testFinished name='Exception matchers that fail' duration="{duration}"]
|
||||
##teamcity[testStarted name='Exception matchers that succeed']
|
||||
##teamcity[testFinished name='Exception matchers that succeed' duration="{duration}"]
|
||||
##teamcity[testStarted name='Exception message can be matched']
|
||||
##teamcity[testFinished name='Exception message can be matched' duration="{duration}"]
|
||||
##teamcity[testStarted name='Exception messages can be tested for']
|
||||
##teamcity[testFinished name='Exception messages can be tested for' duration="{duration}"]
|
||||
##teamcity[testStarted name='Exceptions matchers']
|
||||
##teamcity[testFinished name='Exceptions matchers' duration="{duration}"]
|
||||
##teamcity[testStarted name='Expected exceptions that don|'t throw or unexpected exceptions fail the test']
|
||||
##teamcity[testFailed name='Expected exceptions that don|'t throw or unexpected exceptions fail the test' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK_THROWS_AS( thisThrows(), std::string )|nwith expansion:|n thisThrows(), std::string|n']
|
||||
##teamcity[testFailed name='Expected exceptions that don|'t throw or unexpected exceptions fail the test' message='Exception.tests.cpp:<line number>|nno exception was thrown where one was expected|n CHECK_THROWS_AS( thisDoesntThrow(), std::domain_error )|nwith expansion:|n thisDoesntThrow(), std::domain_error|n']
|
||||
##teamcity[testFailed name='Expected exceptions that don|'t throw or unexpected exceptions fail the test' message='Exception.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK_NOTHROW( thisThrows() )|nwith expansion:|n thisThrows()|n']
|
||||
##teamcity[testFinished name='Expected exceptions that don|'t throw or unexpected exceptions fail the test' duration="{duration}"]
|
||||
##teamcity[testStarted name='FAIL aborts the test']
|
||||
##teamcity[testFailed name='FAIL aborts the test' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "This is a failure"']
|
||||
##teamcity[testFinished name='FAIL aborts the test' duration="{duration}"]
|
||||
##teamcity[testStarted name='FAIL does not require an argument']
|
||||
##teamcity[testFailed name='FAIL does not require an argument' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure']
|
||||
##teamcity[testFinished name='FAIL does not require an argument' duration="{duration}"]
|
||||
##teamcity[testStarted name='FAIL_CHECK does not abort the test']
|
||||
##teamcity[testFailed name='FAIL_CHECK does not abort the test' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "This is a failure"']
|
||||
##teamcity[testFinished name='FAIL_CHECK does not abort the test' duration="{duration}"]
|
||||
##teamcity[testStarted name='Factorials are computed']
|
||||
##teamcity[testFinished name='Factorials are computed' duration="{duration}"]
|
||||
##teamcity[testStarted name='Filter generator throws exception for empty generator']
|
||||
##teamcity[testFinished name='Filter generator throws exception for empty generator' duration="{duration}"]
|
||||
##teamcity[testStarted name='Floating point matchers: double']
|
||||
##teamcity[testFinished name='Floating point matchers: double' duration="{duration}"]
|
||||
##teamcity[testStarted name='Floating point matchers: float']
|
||||
##teamcity[testFinished name='Floating point matchers: float' duration="{duration}"]
|
||||
##teamcity[testStarted name='Generators -- adapters']
|
||||
##teamcity[testFinished name='Generators -- adapters' duration="{duration}"]
|
||||
##teamcity[testStarted name='Generators -- simple']
|
||||
##teamcity[testFinished name='Generators -- simple' duration="{duration}"]
|
||||
##teamcity[testStarted name='Generators internals']
|
||||
##teamcity[testFinished name='Generators internals' duration="{duration}"]
|
||||
##teamcity[testStarted name='Greater-than inequalities with different epsilons']
|
||||
##teamcity[testFinished name='Greater-than inequalities with different epsilons' duration="{duration}"]
|
||||
##teamcity[testStarted name='Hashers with different seed produce different hash with same test case']
|
||||
##teamcity[testFinished name='Hashers with different seed produce different hash with same test case' duration="{duration}"]
|
||||
##teamcity[testStarted name='Hashers with same seed produce same hash']
|
||||
##teamcity[testFinished name='Hashers with same seed produce same hash' duration="{duration}"]
|
||||
##teamcity[testStarted name='Hashing different test cases produces different result']
|
||||
##teamcity[testFinished name='Hashing different test cases produces different result' duration="{duration}"]
|
||||
##teamcity[testStarted name='Hashing test case produces same hash across multiple calls']
|
||||
##teamcity[testFinished name='Hashing test case produces same hash across multiple calls' duration="{duration}"]
|
||||
##teamcity[testStarted name='INFO and WARN do not abort tests']
|
||||
##teamcity[testFinished name='INFO and WARN do not abort tests' duration="{duration}"]
|
||||
##teamcity[testStarted name='INFO gets logged on failure']
|
||||
##teamcity[testFailed name='INFO gets logged on failure' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "this message should be logged"|n "so should this"|n REQUIRE( a == 1 )|nwith expansion:|n 2 == 1|n']
|
||||
##teamcity[testFinished name='INFO gets logged on failure' duration="{duration}"]
|
||||
##teamcity[testStarted name='INFO gets logged on failure, even if captured before successful assertions']
|
||||
##teamcity[testFailed name='INFO gets logged on failure, even if captured before successful assertions' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "this message may be logged later"|n "this message should be logged"|n CHECK( a == 1 )|nwith expansion:|n 2 == 1|n']
|
||||
##teamcity[testFailed name='INFO gets logged on failure, even if captured before successful assertions' message='Message.tests.cpp:<line number>|nexpression failed with messages:|n "this message may be logged later"|n "this message should be logged"|n "and this, but later"|n CHECK( a == 0 )|nwith expansion:|n 2 == 0|n']
|
||||
##teamcity[testFinished name='INFO gets logged on failure, even if captured before successful assertions' duration="{duration}"]
|
||||
##teamcity[testStarted name='INFO is reset for each loop']
|
||||
##teamcity[testFailed name='INFO is reset for each loop' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "current counter 10"|n "i := 10"|n REQUIRE( i < 10 )|nwith expansion:|n 10 < 10|n']
|
||||
##teamcity[testFinished name='INFO is reset for each loop' duration="{duration}"]
|
||||
##teamcity[testStarted name='Inequality checks that should fail']
|
||||
##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven != 7 )|nwith expansion:|n 7 != 7|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one != Approx( 9.1f ) )|nwith expansion:|n 9.1f != Approx( 9.1000003815 )|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.double_pi != Approx( 3.1415926535 ) )|nwith expansion:|n 3.1415926535 != Approx( 3.1415926535 )|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello != "hello" )|nwith expansion:|n "hello" != "hello"|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello.size() != 5 )|nwith expansion:|n 5 != 5|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testFinished name='Inequality checks that should fail' duration="{duration}"]
|
||||
##teamcity[testStarted name='Inequality checks that should succeed']
|
||||
##teamcity[testFinished name='Inequality checks that should succeed' duration="{duration}"]
|
||||
##teamcity[testStarted name='Lambdas in assertions']
|
||||
##teamcity[testFinished name='Lambdas in assertions' duration="{duration}"]
|
||||
##teamcity[testStarted name='Less-than inequalities with different epsilons']
|
||||
##teamcity[testFinished name='Less-than inequalities with different epsilons' duration="{duration}"]
|
||||
##teamcity[testStarted name='ManuallyRegistered']
|
||||
##teamcity[testFinished name='ManuallyRegistered' duration="{duration}"]
|
||||
##teamcity[testStarted name='Matchers can be (AllOf) composed with the && operator']
|
||||
##teamcity[testFinished name='Matchers can be (AllOf) composed with the && operator' duration="{duration}"]
|
||||
##teamcity[testStarted name='Matchers can be (AnyOf) composed with the |||| operator']
|
||||
##teamcity[testFinished name='Matchers can be (AnyOf) composed with the |||| operator' duration="{duration}"]
|
||||
##teamcity[testStarted name='Matchers can be composed with both && and ||||']
|
||||
##teamcity[testFinished name='Matchers can be composed with both && and ||||' duration="{duration}"]
|
||||
##teamcity[testStarted name='Matchers can be composed with both && and |||| - failing']
|
||||
##teamcity[testFailed name='Matchers can be composed with both && and |||| - failing' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), ( ContainsSubstring( "string" ) |||| ContainsSubstring( "different" ) ) && ContainsSubstring( "random" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" ( ( contains: "string" or contains: "different" ) and contains: "random" )|n']
|
||||
##teamcity[testFinished name='Matchers can be composed with both && and |||| - failing' duration="{duration}"]
|
||||
##teamcity[testStarted name='Matchers can be negated (Not) with the ! operator']
|
||||
##teamcity[testFinished name='Matchers can be negated (Not) with the ! operator' duration="{duration}"]
|
||||
##teamcity[testStarted name='Matchers can be negated (Not) with the ! operator - failing']
|
||||
##teamcity[testFailed name='Matchers can be negated (Not) with the ! operator - failing' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), !ContainsSubstring( "substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" not contains: "substring"|n']
|
||||
##teamcity[testFinished name='Matchers can be negated (Not) with the ! operator - failing' duration="{duration}"]
|
||||
##teamcity[testStarted name='Mayfail test case with nested sections']
|
||||
##teamcity[testIgnored name='Mayfail test case with nested sections' message='-------------------------------------------------------------------------------|nA|n1|n-------------------------------------------------------------------------------|nCondition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Mayfail test case with nested sections' message='-------------------------------------------------------------------------------|nA|n2|n-------------------------------------------------------------------------------|nCondition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Mayfail test case with nested sections' message='-------------------------------------------------------------------------------|nB|n1|n-------------------------------------------------------------------------------|nCondition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Mayfail test case with nested sections' message='-------------------------------------------------------------------------------|nB|n2|n-------------------------------------------------------------------------------|nCondition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testFinished name='Mayfail test case with nested sections' duration="{duration}"]
|
||||
##teamcity[testStarted name='Mismatching exception messages failing the test']
|
||||
##teamcity[testFailed name='Mismatching exception messages failing the test' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nexpression failed|n REQUIRE_THROWS_WITH( thisThrows(), "should fail" )|nwith expansion:|n "expected exception" equals: "should fail"|n']
|
||||
##teamcity[testFinished name='Mismatching exception messages failing the test' duration="{duration}"]
|
||||
##teamcity[testStarted name='Multireporter calls reporters and listeners in correct order']
|
||||
##teamcity[testFinished name='Multireporter calls reporters and listeners in correct order' duration="{duration}"]
|
||||
##teamcity[testStarted name='Multireporter updates ReporterPreferences properly']
|
||||
##teamcity[testFinished name='Multireporter updates ReporterPreferences properly' duration="{duration}"]
|
||||
##teamcity[testStarted name='Nested generators and captured variables']
|
||||
##teamcity[testFinished name='Nested generators and captured variables' duration="{duration}"]
|
||||
##teamcity[testStarted name='Nice descriptive name']
|
||||
##teamcity[testFinished name='Nice descriptive name' duration="{duration}"]
|
||||
##teamcity[testStarted name='Non-std exceptions can be translated']
|
||||
##teamcity[testFailed name='Non-std exceptions can be translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "custom exception"']
|
||||
##teamcity[testFinished name='Non-std exceptions can be translated' duration="{duration}"]
|
||||
##teamcity[testStarted name='Objects that evaluated in boolean contexts can be checked']
|
||||
##teamcity[testFinished name='Objects that evaluated in boolean contexts can be checked' duration="{duration}"]
|
||||
##teamcity[testStarted name='Optionally static assertions']
|
||||
##teamcity[testFinished name='Optionally static assertions' duration="{duration}"]
|
||||
##teamcity[testStarted name='Ordering comparison checks that should fail']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven > 7 )|nwith expansion:|n 7 > 7|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < 7 )|nwith expansion:|n 7 < 7|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven > 8 )|nwith expansion:|n 7 > 8|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < 6 )|nwith expansion:|n 7 < 6|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < 0 )|nwith expansion:|n 7 < 0|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < -1 )|nwith expansion:|n 7 < -1|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven >= 8 )|nwith expansion:|n 7 >= 8|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven <= 6 )|nwith expansion:|n 7 <= 6|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one < 9 )|nwith expansion:|n 9.1f < 9|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one > 10 )|nwith expansion:|n 9.1f > 10|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one > 9.2 )|nwith expansion:|n 9.1f > 9.2|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello > "hello" )|nwith expansion:|n "hello" > "hello"|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello < "hello" )|nwith expansion:|n "hello" < "hello"|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello > "hellp" )|nwith expansion:|n "hello" > "hellp"|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello > "z" )|nwith expansion:|n "hello" > "z"|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello < "hellm" )|nwith expansion:|n "hello" < "hellm"|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello < "a" )|nwith expansion:|n "hello" < "a"|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello >= "z" )|nwith expansion:|n "hello" >= "z"|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello <= "a" )|nwith expansion:|n "hello" <= "a"|n']
|
||||
##teamcity[testFinished name='Ordering comparison checks that should fail' duration="{duration}"]
|
||||
##teamcity[testStarted name='Ordering comparison checks that should succeed']
|
||||
##teamcity[testFinished name='Ordering comparison checks that should succeed' duration="{duration}"]
|
||||
##teamcity[testStarted name='Our PCG implementation provides expected results for known seeds']
|
||||
##teamcity[testFinished name='Our PCG implementation provides expected results for known seeds' duration="{duration}"]
|
||||
##teamcity[testStarted name='Output from all sections is reported']
|
||||
##teamcity[testFailed name='Output from all sections is reported' message='-------------------------------------------------------------------------------|none|n-------------------------------------------------------------------------------|nMessage.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "Message from section one"']
|
||||
##teamcity[testFailed name='Output from all sections is reported' message='-------------------------------------------------------------------------------|ntwo|n-------------------------------------------------------------------------------|nMessage.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "Message from section two"']
|
||||
##teamcity[testFinished name='Output from all sections is reported' duration="{duration}"]
|
||||
##teamcity[testStarted name='Overloaded comma or address-of operators are not used']
|
||||
##teamcity[testFinished name='Overloaded comma or address-of operators are not used' duration="{duration}"]
|
||||
##teamcity[testStarted name='Parse uints']
|
||||
##teamcity[testFinished name='Parse uints' duration="{duration}"]
|
||||
##teamcity[testStarted name='Parsed tags are matched case insensitive']
|
||||
##teamcity[testFinished name='Parsed tags are matched case insensitive' duration="{duration}"]
|
||||
##teamcity[testStarted name='Parsing sharding-related cli flags']
|
||||
##teamcity[testFinished name='Parsing sharding-related cli flags' duration="{duration}"]
|
||||
##teamcity[testStarted name='Parsing tags with non-alphabetical characters is pass-through']
|
||||
##teamcity[testFinished name='Parsing tags with non-alphabetical characters is pass-through' duration="{duration}"]
|
||||
##teamcity[testStarted name='Parsing warnings']
|
||||
##teamcity[testFinished name='Parsing warnings' duration="{duration}"]
|
||||
##teamcity[testStarted name='Pointers can be compared to null']
|
||||
##teamcity[testFinished name='Pointers can be compared to null' duration="{duration}"]
|
||||
##teamcity[testStarted name='Precision of floating point stringification can be set']
|
||||
##teamcity[testFinished name='Precision of floating point stringification can be set' duration="{duration}"]
|
||||
##teamcity[testStarted name='Predicate matcher can accept const char*']
|
||||
##teamcity[testFinished name='Predicate matcher can accept const char*' duration="{duration}"]
|
||||
##teamcity[testStarted name='Process can be configured on command line']
|
||||
##teamcity[testFinished name='Process can be configured on command line' duration="{duration}"]
|
||||
##teamcity[testStarted name='Product with differing arities - std::tuple<int, double, float>']
|
||||
##teamcity[testFinished name='Product with differing arities - std::tuple<int, double, float>' duration="{duration}"]
|
||||
##teamcity[testStarted name='Product with differing arities - std::tuple<int, double>']
|
||||
##teamcity[testFinished name='Product with differing arities - std::tuple<int, double>' duration="{duration}"]
|
||||
##teamcity[testStarted name='Product with differing arities - std::tuple<int>']
|
||||
##teamcity[testFinished name='Product with differing arities - std::tuple<int>' duration="{duration}"]
|
||||
##teamcity[testStarted name='Random seed generation accepts known methods']
|
||||
##teamcity[testFinished name='Random seed generation accepts known methods' duration="{duration}"]
|
||||
##teamcity[testStarted name='Random seed generation reports unknown methods']
|
||||
##teamcity[testFinished name='Random seed generation reports unknown methods' duration="{duration}"]
|
||||
##teamcity[testStarted name='Range type with sentinel']
|
||||
##teamcity[testFinished name='Range type with sentinel' duration="{duration}"]
|
||||
##teamcity[testStarted name='Reconstruction should be based on stringification: #914']
|
||||
##teamcity[testFailed name='Reconstruction should be based on stringification: #914' message='Decomposition.tests.cpp:<line number>|n...............................................................................|n|nDecomposition.tests.cpp:<line number>|nexpression failed|n CHECK( truthy(false) )|nwith expansion:|n Hey, its truthy!|n']
|
||||
##teamcity[testFinished name='Reconstruction should be based on stringification: #914' duration="{duration}"]
|
||||
##teamcity[testStarted name='Regex string matcher']
|
||||
##teamcity[testFailed name='Regex string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Matches( "this STRING contains |'abc|' as a substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" matches "this STRING contains |'abc|' as a substring" case sensitively|n']
|
||||
##teamcity[testFailed name='Regex string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Matches( "contains |'abc|' as a substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" matches "contains |'abc|' as a substring" case sensitively|n']
|
||||
##teamcity[testFailed name='Regex string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Matches( "this string contains |'abc|' as a" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" matches "this string contains |'abc|' as a" case sensitively|n']
|
||||
##teamcity[testFinished name='Regex string matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Registering reporter with |'::|' in name fails']
|
||||
##teamcity[testFinished name='Registering reporter with |'::|' in name fails' duration="{duration}"]
|
||||
##teamcity[testStarted name='Regression test #1']
|
||||
##teamcity[testFinished name='Regression test #1' duration="{duration}"]
|
||||
##teamcity[testStarted name='Reporter|'s write listings to provided stream']
|
||||
##teamcity[testFinished name='Reporter|'s write listings to provided stream' duration="{duration}"]
|
||||
##teamcity[testStarted name='Reproducer for #2309 - a very long description past 80 chars (default console width) with a late colon : blablabla']
|
||||
##teamcity[testFinished name='Reproducer for #2309 - a very long description past 80 chars (default console width) with a late colon : blablabla' duration="{duration}"]
|
||||
##teamcity[testStarted name='SUCCEED counts as a test pass']
|
||||
##teamcity[testFinished name='SUCCEED counts as a test pass' duration="{duration}"]
|
||||
##teamcity[testStarted name='SUCCEED does not require an argument']
|
||||
##teamcity[testFinished name='SUCCEED does not require an argument' duration="{duration}"]
|
||||
##teamcity[testStarted name='Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods']
|
||||
##teamcity[testFinished name='Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods' duration="{duration}"]
|
||||
##teamcity[testStarted name='Scenario: Do that thing with the thing']
|
||||
##teamcity[testFinished name='Scenario: Do that thing with the thing' duration="{duration}"]
|
||||
##teamcity[testStarted name='Scenario: This is a really long scenario name to see how the list command deals with wrapping']
|
||||
##teamcity[testFinished name='Scenario: This is a really long scenario name to see how the list command deals with wrapping' duration="{duration}"]
|
||||
##teamcity[testStarted name='Scenario: Vector resizing affects size and capacity']
|
||||
##teamcity[testFinished name='Scenario: Vector resizing affects size and capacity' duration="{duration}"]
|
||||
##teamcity[testStarted name='Sends stuff to stdout and stderr']
|
||||
##teamcity[testStdOut name='Sends stuff to stdout and stderr' out='A string sent directly to stdout|n']
|
||||
##teamcity[testStdErr name='Sends stuff to stdout and stderr' out='A string sent directly to stderr|nA string sent to stderr via clog|n']
|
||||
##teamcity[testFinished name='Sends stuff to stdout and stderr' duration="{duration}"]
|
||||
##teamcity[testStarted name='Some simple comparisons between doubles']
|
||||
##teamcity[testFinished name='Some simple comparisons between doubles' duration="{duration}"]
|
||||
##teamcity[testStarted name='Standard output from all sections is reported']
|
||||
##teamcity[testStdOut name='Standard output from all sections is reported' out='Message from section one|nMessage from section two|n']
|
||||
##teamcity[testFinished name='Standard output from all sections is reported' duration="{duration}"]
|
||||
##teamcity[testStarted name='StartsWith string matcher']
|
||||
##teamcity[testFailed name='StartsWith string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), StartsWith( "This String" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" starts with: "This String"|n']
|
||||
##teamcity[testFailed name='StartsWith string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), StartsWith( "string", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" starts with: "string" (case insensitive)|n']
|
||||
##teamcity[testFinished name='StartsWith string matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Static arrays are convertible to string']
|
||||
##teamcity[testFinished name='Static arrays are convertible to string' duration="{duration}"]
|
||||
##teamcity[testStarted name='String matchers']
|
||||
##teamcity[testFinished name='String matchers' duration="{duration}"]
|
||||
##teamcity[testStarted name='StringRef']
|
||||
##teamcity[testFinished name='StringRef' duration="{duration}"]
|
||||
##teamcity[testStarted name='StringRef at compilation time']
|
||||
##teamcity[testFinished name='StringRef at compilation time' duration="{duration}"]
|
||||
##teamcity[testStarted name='Stringifying char arrays with statically known sizes - char']
|
||||
##teamcity[testFinished name='Stringifying char arrays with statically known sizes - char' duration="{duration}"]
|
||||
##teamcity[testStarted name='Stringifying char arrays with statically known sizes - signed char']
|
||||
##teamcity[testFinished name='Stringifying char arrays with statically known sizes - signed char' duration="{duration}"]
|
||||
##teamcity[testStarted name='Stringifying char arrays with statically known sizes - unsigned char']
|
||||
##teamcity[testFinished name='Stringifying char arrays with statically known sizes - unsigned char' duration="{duration}"]
|
||||
##teamcity[testStarted name='Stringifying std::chrono::duration helpers']
|
||||
##teamcity[testFinished name='Stringifying std::chrono::duration helpers' duration="{duration}"]
|
||||
##teamcity[testStarted name='Stringifying std::chrono::duration with weird ratios']
|
||||
##teamcity[testFinished name='Stringifying std::chrono::duration with weird ratios' duration="{duration}"]
|
||||
##teamcity[testStarted name='Stringifying std::chrono::time_point<system_clock>']
|
||||
##teamcity[testFinished name='Stringifying std::chrono::time_point<system_clock>' duration="{duration}"]
|
||||
##teamcity[testStarted name='Tabs and newlines show in output']
|
||||
##teamcity[testFailed name='Tabs and newlines show in output' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n CHECK( s1 == s2 )|nwith expansion:|n "if ($b == 10) {|n $a = 20;|n}"|n==|n"if ($b == 10) {|n $a = 20;|n}|n"|n']
|
||||
##teamcity[testFinished name='Tabs and newlines show in output' duration="{duration}"]
|
||||
##teamcity[testStarted name='Tag alias can be registered against tag patterns']
|
||||
##teamcity[testFinished name='Tag alias can be registered against tag patterns' duration="{duration}"]
|
||||
##teamcity[testStarted name='Tags with spaces and non-alphanumerical characters are accepted']
|
||||
##teamcity[testFinished name='Tags with spaces and non-alphanumerical characters are accepted' duration="{duration}"]
|
||||
##teamcity[testStarted name='Template test case method with test types specified inside std::tuple - MyTypes - 0']
|
||||
##teamcity[testFinished name='Template test case method with test types specified inside std::tuple - MyTypes - 0' duration="{duration}"]
|
||||
##teamcity[testStarted name='Template test case method with test types specified inside std::tuple - MyTypes - 1']
|
||||
##teamcity[testFinished name='Template test case method with test types specified inside std::tuple - MyTypes - 1' duration="{duration}"]
|
||||
##teamcity[testStarted name='Template test case method with test types specified inside std::tuple - MyTypes - 2']
|
||||
##teamcity[testFinished name='Template test case method with test types specified inside std::tuple - MyTypes - 2' duration="{duration}"]
|
||||
##teamcity[testStarted name='Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 0']
|
||||
##teamcity[testFinished name='Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 0' duration="{duration}"]
|
||||
##teamcity[testStarted name='Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 1']
|
||||
##teamcity[testFinished name='Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 1' duration="{duration}"]
|
||||
##teamcity[testStarted name='Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 0']
|
||||
##teamcity[testFinished name='Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 0' duration="{duration}"]
|
||||
##teamcity[testStarted name='Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 1']
|
||||
##teamcity[testFinished name='Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 1' duration="{duration}"]
|
||||
##teamcity[testStarted name='Template test case with test types specified inside std::tuple - MyTypes - 0']
|
||||
##teamcity[testFinished name='Template test case with test types specified inside std::tuple - MyTypes - 0' duration="{duration}"]
|
||||
##teamcity[testStarted name='Template test case with test types specified inside std::tuple - MyTypes - 1']
|
||||
##teamcity[testFinished name='Template test case with test types specified inside std::tuple - MyTypes - 1' duration="{duration}"]
|
||||
##teamcity[testStarted name='Template test case with test types specified inside std::tuple - MyTypes - 2']
|
||||
##teamcity[testFinished name='Template test case with test types specified inside std::tuple - MyTypes - 2' duration="{duration}"]
|
||||
##teamcity[testStarted name='TemplateTest: vectors can be sized and resized - float']
|
||||
##teamcity[testFinished name='TemplateTest: vectors can be sized and resized - float' duration="{duration}"]
|
||||
##teamcity[testStarted name='TemplateTest: vectors can be sized and resized - int']
|
||||
##teamcity[testFinished name='TemplateTest: vectors can be sized and resized - int' duration="{duration}"]
|
||||
##teamcity[testStarted name='TemplateTest: vectors can be sized and resized - std::string']
|
||||
##teamcity[testFinished name='TemplateTest: vectors can be sized and resized - std::string' duration="{duration}"]
|
||||
##teamcity[testStarted name='TemplateTest: vectors can be sized and resized - std::tuple<int,float>']
|
||||
##teamcity[testFinished name='TemplateTest: vectors can be sized and resized - std::tuple<int,float>' duration="{duration}"]
|
||||
##teamcity[testStarted name='TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6']
|
||||
##teamcity[testFinished name='TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6' duration="{duration}"]
|
||||
##teamcity[testStarted name='TemplateTestSig: vectors can be sized and resized - float,4']
|
||||
##teamcity[testFinished name='TemplateTestSig: vectors can be sized and resized - float,4' duration="{duration}"]
|
||||
##teamcity[testStarted name='TemplateTestSig: vectors can be sized and resized - int,5']
|
||||
##teamcity[testFinished name='TemplateTestSig: vectors can be sized and resized - int,5' duration="{duration}"]
|
||||
##teamcity[testStarted name='TemplateTestSig: vectors can be sized and resized - std::string,15']
|
||||
##teamcity[testFinished name='TemplateTestSig: vectors can be sized and resized - std::string,15' duration="{duration}"]
|
||||
##teamcity[testStarted name='Test case with identical tags keeps just one']
|
||||
##teamcity[testFinished name='Test case with identical tags keeps just one' duration="{duration}"]
|
||||
##teamcity[testStarted name='Test case with one argument']
|
||||
##teamcity[testFinished name='Test case with one argument' duration="{duration}"]
|
||||
##teamcity[testStarted name='Test enum bit values']
|
||||
##teamcity[testFinished name='Test enum bit values' duration="{duration}"]
|
||||
##teamcity[testStarted name='Test with special, characters "in name']
|
||||
##teamcity[testFinished name='Test with special, characters "in name' duration="{duration}"]
|
||||
##teamcity[testStarted name='Testing checked-if']
|
||||
##teamcity[testFinished name='Testing checked-if' duration="{duration}"]
|
||||
##teamcity[testStarted name='Testing checked-if 2']
|
||||
##teamcity[testIgnored name='Testing checked-if 2' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testFinished name='Testing checked-if 2' duration="{duration}"]
|
||||
##teamcity[testStarted name='Testing checked-if 3']
|
||||
##teamcity[testIgnored name='Testing checked-if 3' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testFinished name='Testing checked-if 3' duration="{duration}"]
|
||||
##teamcity[testStarted name='The NO_FAIL macro reports a failure but does not fail the test']
|
||||
##teamcity[testFinished name='The NO_FAIL macro reports a failure but does not fail the test' duration="{duration}"]
|
||||
##teamcity[testStarted name='The default listing implementation write to provided stream']
|
||||
##teamcity[testFinished name='The default listing implementation write to provided stream' duration="{duration}"]
|
||||
##teamcity[testStarted name='This test |'should|' fail but doesn|'t']
|
||||
##teamcity[testFinished name='This test |'should|' fail but doesn|'t' duration="{duration}"]
|
||||
##teamcity[testStarted name='Thrown string literals are translated']
|
||||
##teamcity[testFailed name='Thrown string literals are translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "For some reason someone is throwing a string literal!"']
|
||||
##teamcity[testFinished name='Thrown string literals are translated' duration="{duration}"]
|
||||
##teamcity[testStarted name='Tracker']
|
||||
##teamcity[testFinished name='Tracker' duration="{duration}"]
|
||||
##teamcity[testStarted name='Trim strings']
|
||||
##teamcity[testFinished name='Trim strings' duration="{duration}"]
|
||||
##teamcity[testStarted name='Type conversions of RangeEquals and similar']
|
||||
##teamcity[testFinished name='Type conversions of RangeEquals and similar' duration="{duration}"]
|
||||
##teamcity[testStarted name='Unexpected exceptions can be translated']
|
||||
##teamcity[testFailed name='Unexpected exceptions can be translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "3.14"']
|
||||
##teamcity[testFinished name='Unexpected exceptions can be translated' duration="{duration}"]
|
||||
##teamcity[testStarted name='Upcasting special member functions']
|
||||
##teamcity[testFinished name='Upcasting special member functions' duration="{duration}"]
|
||||
##teamcity[testStarted name='Usage of AllMatch range matcher']
|
||||
##teamcity[testFinished name='Usage of AllMatch range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Usage of AllTrue range matcher']
|
||||
##teamcity[testFinished name='Usage of AllTrue range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Usage of AnyMatch range matcher']
|
||||
##teamcity[testFinished name='Usage of AnyMatch range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Usage of AnyTrue range matcher']
|
||||
##teamcity[testFinished name='Usage of AnyTrue range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Usage of NoneMatch range matcher']
|
||||
##teamcity[testFinished name='Usage of NoneMatch range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Usage of NoneTrue range matcher']
|
||||
##teamcity[testFinished name='Usage of NoneTrue range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Usage of RangeEquals range matcher']
|
||||
##teamcity[testFinished name='Usage of RangeEquals range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Usage of UnorderedRangeEquals range matcher']
|
||||
##teamcity[testFinished name='Usage of UnorderedRangeEquals range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Usage of the SizeIs range matcher']
|
||||
##teamcity[testFinished name='Usage of the SizeIs range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Use a custom approx']
|
||||
##teamcity[testFinished name='Use a custom approx' duration="{duration}"]
|
||||
##teamcity[testStarted name='Variadic macros']
|
||||
##teamcity[testFinished name='Variadic macros' duration="{duration}"]
|
||||
##teamcity[testStarted name='Vector Approx matcher']
|
||||
##teamcity[testFinished name='Vector Approx matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Vector Approx matcher -- failing']
|
||||
##teamcity[testFailed name='Vector Approx matcher -- failing' message='-------------------------------------------------------------------------------|nEmpty and non empty vectors are not approx equal|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, Approx( t1 ) )|nwith expansion:|n { } is approx: { 1.0, 2.0 }|n']
|
||||
##teamcity[testFailed name='Vector Approx matcher -- failing' message='-------------------------------------------------------------------------------|nJust different vectors|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v1, Approx( v2 ) )|nwith expansion:|n { 2.0, 4.0, 6.0 } is approx: { 1.0, 3.0, 5.0 }|n']
|
||||
##teamcity[testFinished name='Vector Approx matcher -- failing' duration="{duration}"]
|
||||
##teamcity[testStarted name='Vector matchers']
|
||||
##teamcity[testFinished name='Vector matchers' duration="{duration}"]
|
||||
##teamcity[testStarted name='Vector matchers that fail']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='-------------------------------------------------------------------------------|nContains (element)|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, VectorContains( -1 ) )|nwith expansion:|n { 1, 2, 3 } Contains: -1|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, VectorContains( 1 ) )|nwith expansion:|n { } Contains: 1|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='-------------------------------------------------------------------------------|nContains (vector)|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, Contains( v ) )|nwith expansion:|n { } Contains: { 1, 2, 3 }|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, Contains( v2 ) )|nwith expansion:|n { 1, 2, 3 } Contains: { 1, 2, 4 }|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='-------------------------------------------------------------------------------|nEquals|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, Equals( v2 ) )|nwith expansion:|n { 1, 2, 3 } Equals: { 1, 2 }|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v2, Equals( v ) )|nwith expansion:|n { 1, 2 } Equals: { 1, 2, 3 }|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, Equals( v ) )|nwith expansion:|n { } Equals: { 1, 2, 3 }|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, Equals( empty ) )|nwith expansion:|n { 1, 2, 3 } Equals: { }|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='-------------------------------------------------------------------------------|nUnorderedEquals|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, UnorderedEquals( empty ) )|nwith expansion:|n { 1, 2, 3 } UnorderedEquals: { }|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, UnorderedEquals( v ) )|nwith expansion:|n { } UnorderedEquals: { 1, 2, 3 }|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( permuted, UnorderedEquals( v ) )|nwith expansion:|n { 1, 3 } UnorderedEquals: { 1, 2, 3 }|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( permuted, UnorderedEquals( v ) )|nwith expansion:|n { 3, 1 } UnorderedEquals: { 1, 2, 3 }|n']
|
||||
##teamcity[testFinished name='Vector matchers that fail' duration="{duration}"]
|
||||
##teamcity[testStarted name='When checked exceptions are thrown they can be expected or unexpected']
|
||||
##teamcity[testFinished name='When checked exceptions are thrown they can be expected or unexpected' duration="{duration}"]
|
||||
##teamcity[testStarted name='When unchecked exceptions are thrown directly they are always failures']
|
||||
##teamcity[testFailed name='When unchecked exceptions are thrown directly they are always failures' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "unexpected exception"']
|
||||
##teamcity[testFinished name='When unchecked exceptions are thrown directly they are always failures' duration="{duration}"]
|
||||
##teamcity[testStarted name='When unchecked exceptions are thrown during a CHECK the test should continue']
|
||||
##teamcity[testFailed name='When unchecked exceptions are thrown during a CHECK the test should continue' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK( thisThrows() == 0 )|nwith expansion:|n thisThrows() == 0|n']
|
||||
##teamcity[testFinished name='When unchecked exceptions are thrown during a CHECK the test should continue' duration="{duration}"]
|
||||
##teamcity[testStarted name='When unchecked exceptions are thrown during a REQUIRE the test should abort fail']
|
||||
##teamcity[testFailed name='When unchecked exceptions are thrown during a REQUIRE the test should abort fail' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n REQUIRE( thisThrows() == 0 )|nwith expansion:|n thisThrows() == 0|n']
|
||||
##teamcity[testFinished name='When unchecked exceptions are thrown during a REQUIRE the test should abort fail' duration="{duration}"]
|
||||
##teamcity[testStarted name='When unchecked exceptions are thrown from functions they are always failures']
|
||||
##teamcity[testFailed name='When unchecked exceptions are thrown from functions they are always failures' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK( thisThrows() == 0 )|nwith expansion:|n thisThrows() == 0|n']
|
||||
##teamcity[testFinished name='When unchecked exceptions are thrown from functions they are always failures' duration="{duration}"]
|
||||
##teamcity[testStarted name='When unchecked exceptions are thrown from sections they are always failures']
|
||||
##teamcity[testFailed name='When unchecked exceptions are thrown from sections they are always failures' message='-------------------------------------------------------------------------------|nsection name|n-------------------------------------------------------------------------------|nException.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "unexpected exception"']
|
||||
##teamcity[testFinished name='When unchecked exceptions are thrown from sections they are always failures' duration="{duration}"]
|
||||
##teamcity[testStarted name='When unchecked exceptions are thrown, but caught, they do not affect the test']
|
||||
##teamcity[testFinished name='When unchecked exceptions are thrown, but caught, they do not affect the test' duration="{duration}"]
|
||||
##teamcity[testStarted name='X/level/0/a']
|
||||
##teamcity[testFinished name='X/level/0/a' duration="{duration}"]
|
||||
##teamcity[testStarted name='X/level/0/b']
|
||||
##teamcity[testFinished name='X/level/0/b' duration="{duration}"]
|
||||
##teamcity[testStarted name='X/level/1/a']
|
||||
##teamcity[testFinished name='X/level/1/a' duration="{duration}"]
|
||||
##teamcity[testStarted name='X/level/1/b']
|
||||
##teamcity[testFinished name='X/level/1/b' duration="{duration}"]
|
||||
##teamcity[testStarted name='XmlEncode']
|
||||
##teamcity[testFinished name='XmlEncode' duration="{duration}"]
|
||||
##teamcity[testStarted name='XmlWriter writes boolean attributes as true/false']
|
||||
##teamcity[testFinished name='XmlWriter writes boolean attributes as true/false' duration="{duration}"]
|
||||
##teamcity[testStarted name='a succeeding test can still be skipped']
|
||||
##teamcity[testIgnored name='a succeeding test can still be skipped' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
|
||||
##teamcity[testFinished name='a succeeding test can still be skipped' duration="{duration}"]
|
||||
##teamcity[testStarted name='analyse no analysis']
|
||||
##teamcity[testFinished name='analyse no analysis' duration="{duration}"]
|
||||
##teamcity[testStarted name='array<int, N> -> toString']
|
||||
##teamcity[testFinished name='array<int, N> -> toString' duration="{duration}"]
|
||||
##teamcity[testStarted name='benchmark function call']
|
||||
##teamcity[testFinished name='benchmark function call' duration="{duration}"]
|
||||
##teamcity[testStarted name='boolean member']
|
||||
##teamcity[testFinished name='boolean member' duration="{duration}"]
|
||||
##teamcity[testStarted name='checkedElse']
|
||||
##teamcity[testFinished name='checkedElse' duration="{duration}"]
|
||||
##teamcity[testStarted name='checkedElse, failing']
|
||||
##teamcity[testFailed name='checkedElse, failing' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n REQUIRE( testCheckedElse( false ) )|nwith expansion:|n false|n']
|
||||
##teamcity[testFinished name='checkedElse, failing' duration="{duration}"]
|
||||
##teamcity[testStarted name='checkedIf']
|
||||
##teamcity[testFinished name='checkedIf' duration="{duration}"]
|
||||
##teamcity[testStarted name='checkedIf, failing']
|
||||
##teamcity[testFailed name='checkedIf, failing' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n REQUIRE( testCheckedIf( false ) )|nwith expansion:|n false|n']
|
||||
##teamcity[testFinished name='checkedIf, failing' duration="{duration}"]
|
||||
##teamcity[testStarted name='classify_outliers']
|
||||
##teamcity[testFinished name='classify_outliers' duration="{duration}"]
|
||||
##teamcity[testStarted name='comparisons between const int variables']
|
||||
##teamcity[testFinished name='comparisons between const int variables' duration="{duration}"]
|
||||
##teamcity[testStarted name='comparisons between int variables']
|
||||
##teamcity[testFinished name='comparisons between int variables' duration="{duration}"]
|
||||
##teamcity[testStarted name='convertToBits']
|
||||
##teamcity[testFinished name='convertToBits' duration="{duration}"]
|
||||
##teamcity[testStarted name='dynamic skipping works with generators']
|
||||
##teamcity[testIgnored name='dynamic skipping works with generators' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip with message:|n "skipping because answer = 41"']
|
||||
##teamcity[testIgnored name='dynamic skipping works with generators' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip with message:|n "skipping because answer = 43"']
|
||||
##teamcity[testFinished name='dynamic skipping works with generators' duration="{duration}"]
|
||||
##teamcity[testStarted name='empty tags are not allowed']
|
||||
##teamcity[testFinished name='empty tags are not allowed' duration="{duration}"]
|
||||
##teamcity[testStarted name='erfc_inv']
|
||||
##teamcity[testFinished name='erfc_inv' duration="{duration}"]
|
||||
##teamcity[testStarted name='estimate_clock_resolution']
|
||||
##teamcity[testFinished name='estimate_clock_resolution' duration="{duration}"]
|
||||
##teamcity[testStarted name='even more nested SECTION tests']
|
||||
##teamcity[testFinished name='even more nested SECTION tests' duration="{duration}"]
|
||||
##teamcity[testStarted name='failed assertions before SKIP cause test case to fail']
|
||||
##teamcity[testIgnored name='failed assertions before SKIP cause test case to fail' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexpression failed|n CHECK( 3 == 4 )|nwith expansion:|n 3 == 4|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='failed assertions before SKIP cause test case to fail' message='Skip.tests.cpp:<line number>|nexplicit skip']
|
||||
##teamcity[testFinished name='failed assertions before SKIP cause test case to fail' duration="{duration}"]
|
||||
##teamcity[testStarted name='failing for some generator values causes entire test case to fail']
|
||||
##teamcity[testIgnored name='failing for some generator values causes entire test case to fail' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='failing for some generator values causes entire test case to fail' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
|
||||
##teamcity[testIgnored name='failing for some generator values causes entire test case to fail' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='failing for some generator values causes entire test case to fail' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
|
||||
##teamcity[testFinished name='failing for some generator values causes entire test case to fail' duration="{duration}"]
|
||||
##teamcity[testStarted name='failing in some unskipped sections causes entire test case to fail']
|
||||
##teamcity[testIgnored name='failing in some unskipped sections causes entire test case to fail' message='-------------------------------------------------------------------------------|nskipped|n-------------------------------------------------------------------------------|nSkip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
|
||||
##teamcity[testIgnored name='failing in some unskipped sections causes entire test case to fail' message='-------------------------------------------------------------------------------|nnot skipped|n-------------------------------------------------------------------------------|nSkip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testFinished name='failing in some unskipped sections causes entire test case to fail' duration="{duration}"]
|
||||
##teamcity[testStarted name='first tag']
|
||||
##teamcity[testFinished name='first tag' duration="{duration}"]
|
||||
##teamcity[testStarted name='has printf']
|
||||
loose text artifact
|
||||
##teamcity[testFinished name='has printf' duration="{duration}"]
|
||||
##teamcity[testStarted name='is_unary_function']
|
||||
##teamcity[testFinished name='is_unary_function' duration="{duration}"]
|
||||
##teamcity[testStarted name='just failure']
|
||||
##teamcity[testFailed name='just failure' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "Previous info should not be seen"']
|
||||
##teamcity[testFinished name='just failure' duration="{duration}"]
|
||||
##teamcity[testStarted name='just failure after unscoped info']
|
||||
##teamcity[testFailed name='just failure after unscoped info' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "previous unscoped info SHOULD not be seen"']
|
||||
##teamcity[testFinished name='just failure after unscoped info' duration="{duration}"]
|
||||
##teamcity[testStarted name='just info']
|
||||
##teamcity[testFinished name='just info' duration="{duration}"]
|
||||
##teamcity[testStarted name='just unscoped info']
|
||||
##teamcity[testFinished name='just unscoped info' duration="{duration}"]
|
||||
##teamcity[testStarted name='long long']
|
||||
##teamcity[testFinished name='long long' duration="{duration}"]
|
||||
##teamcity[testStarted name='looped SECTION tests']
|
||||
##teamcity[testFailed name='looped SECTION tests' message='-------------------------------------------------------------------------------|nb is currently: 0|n-------------------------------------------------------------------------------|nMisc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n CHECK( b > a )|nwith expansion:|n 0 > 1|n']
|
||||
##teamcity[testFailed name='looped SECTION tests' message='-------------------------------------------------------------------------------|nb is currently: 1|n-------------------------------------------------------------------------------|nMisc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n CHECK( b > a )|nwith expansion:|n 1 > 1|n']
|
||||
##teamcity[testFinished name='looped SECTION tests' duration="{duration}"]
|
||||
##teamcity[testStarted name='looped tests']
|
||||
##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[0|] (1) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
|
||||
##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[1|] (1) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
|
||||
##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[3|] (3) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
|
||||
##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[4|] (5) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
|
||||
##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[6|] (13) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
|
||||
##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[7|] (21) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
|
||||
##teamcity[testFinished name='looped tests' duration="{duration}"]
|
||||
##teamcity[testStarted name='makeStream recognizes %debug stream name']
|
||||
##teamcity[testFinished name='makeStream recognizes %debug stream name' duration="{duration}"]
|
||||
##teamcity[testStarted name='make_unique reimplementation']
|
||||
##teamcity[testFinished name='make_unique reimplementation' duration="{duration}"]
|
||||
##teamcity[testStarted name='mean']
|
||||
##teamcity[testFinished name='mean' duration="{duration}"]
|
||||
##teamcity[testStarted name='measure']
|
||||
##teamcity[testFinished name='measure' duration="{duration}"]
|
||||
##teamcity[testStarted name='mix info, unscoped info and warning']
|
||||
##teamcity[testFinished name='mix info, unscoped info and warning' duration="{duration}"]
|
||||
##teamcity[testStarted name='more nested SECTION tests']
|
||||
##teamcity[testFailed name='more nested SECTION tests' message='-------------------------------------------------------------------------------|ndoesn|'t equal|nequal|n-------------------------------------------------------------------------------|nMisc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n REQUIRE( a == b )|nwith expansion:|n 1 == 2|n']
|
||||
##teamcity[testFinished name='more nested SECTION tests' duration="{duration}"]
|
||||
##teamcity[testStarted name='nested SECTION tests']
|
||||
##teamcity[testFinished name='nested SECTION tests' duration="{duration}"]
|
||||
##teamcity[testStarted name='nested sections can be skipped dynamically at runtime']
|
||||
##teamcity[testIgnored name='nested sections can be skipped dynamically at runtime' message='-------------------------------------------------------------------------------|nB|nB2|n-------------------------------------------------------------------------------|nSkip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
|
||||
##teamcity[testStdOut name='nested sections can be skipped dynamically at runtime' out='a!|nb1!|n!|n']
|
||||
##teamcity[testFinished name='nested sections can be skipped dynamically at runtime' duration="{duration}"]
|
||||
##teamcity[testStarted name='non streamable - with conv. op']
|
||||
##teamcity[testFinished name='non streamable - with conv. op' duration="{duration}"]
|
||||
##teamcity[testStarted name='non-copyable objects']
|
||||
##teamcity[testFinished name='non-copyable objects' duration="{duration}"]
|
||||
##teamcity[testStarted name='normal_cdf']
|
||||
##teamcity[testFinished name='normal_cdf' duration="{duration}"]
|
||||
##teamcity[testStarted name='normal_quantile']
|
||||
##teamcity[testFinished name='normal_quantile' duration="{duration}"]
|
||||
##teamcity[testStarted name='not allowed']
|
||||
##teamcity[testFinished name='not allowed' duration="{duration}"]
|
||||
##teamcity[testStarted name='not prints unscoped info from previous failures']
|
||||
##teamcity[testFailed name='not prints unscoped info from previous failures' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with message:|n "this SHOULD be seen"|n REQUIRE( false )|nwith expansion:|n false|n']
|
||||
##teamcity[testFinished name='not prints unscoped info from previous failures' duration="{duration}"]
|
||||
##teamcity[testStarted name='null strings']
|
||||
##teamcity[testFinished name='null strings' duration="{duration}"]
|
||||
##teamcity[testStarted name='null_ptr']
|
||||
##teamcity[testFinished name='null_ptr' duration="{duration}"]
|
||||
##teamcity[testStarted name='pair<pair<int,const char *,pair<std::string,int> > -> toString']
|
||||
##teamcity[testFinished name='pair<pair<int,const char *,pair<std::string,int> > -> toString' duration="{duration}"]
|
||||
##teamcity[testStarted name='parseEnums']
|
||||
##teamcity[testFinished name='parseEnums' duration="{duration}"]
|
||||
##teamcity[testStarted name='pointer to class']
|
||||
##teamcity[testFinished name='pointer to class' duration="{duration}"]
|
||||
##teamcity[testStarted name='print unscoped info if passing unscoped info is printed']
|
||||
##teamcity[testFinished name='print unscoped info if passing unscoped info is printed' duration="{duration}"]
|
||||
##teamcity[testStarted name='prints unscoped info on failure']
|
||||
##teamcity[testFailed name='prints unscoped info on failure' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "this SHOULD be seen"|n "this SHOULD also be seen"|n REQUIRE( false )|nwith expansion:|n false|n']
|
||||
##teamcity[testFinished name='prints unscoped info on failure' duration="{duration}"]
|
||||
##teamcity[testStarted name='prints unscoped info only for the first assertion']
|
||||
##teamcity[testFailed name='prints unscoped info only for the first assertion' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with message:|n "this SHOULD be seen only ONCE"|n CHECK( false )|nwith expansion:|n false|n']
|
||||
##teamcity[testFinished name='prints unscoped info only for the first assertion' duration="{duration}"]
|
||||
##teamcity[testStarted name='random SECTION tests']
|
||||
##teamcity[testFinished name='random SECTION tests' duration="{duration}"]
|
||||
##teamcity[testStarted name='replaceInPlace']
|
||||
##teamcity[testFinished name='replaceInPlace' duration="{duration}"]
|
||||
##teamcity[testStarted name='request an unknown %-starting stream fails']
|
||||
##teamcity[testFinished name='request an unknown %-starting stream fails' duration="{duration}"]
|
||||
##teamcity[testStarted name='resolution']
|
||||
##teamcity[testFinished name='resolution' duration="{duration}"]
|
||||
##teamcity[testStarted name='run_for_at_least, chronometer']
|
||||
##teamcity[testFinished name='run_for_at_least, chronometer' duration="{duration}"]
|
||||
##teamcity[testStarted name='run_for_at_least, int']
|
||||
##teamcity[testFinished name='run_for_at_least, int' duration="{duration}"]
|
||||
##teamcity[testStarted name='second tag']
|
||||
##teamcity[testFinished name='second tag' duration="{duration}"]
|
||||
##teamcity[testStarted name='sections can be skipped dynamically at runtime']
|
||||
##teamcity[testIgnored name='sections can be skipped dynamically at runtime' message='-------------------------------------------------------------------------------|nskipped|n-------------------------------------------------------------------------------|nSkip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
|
||||
##teamcity[testFinished name='sections can be skipped dynamically at runtime' duration="{duration}"]
|
||||
##teamcity[testStarted name='send a single char to INFO']
|
||||
##teamcity[testFailed name='send a single char to INFO' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed with message:|n "3"|n REQUIRE( false )|nwith expansion:|n false|n']
|
||||
##teamcity[testFinished name='send a single char to INFO' duration="{duration}"]
|
||||
##teamcity[testStarted name='sends information to INFO']
|
||||
##teamcity[testFailed name='sends information to INFO' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "hi"|n "i := 7"|n REQUIRE( false )|nwith expansion:|n false|n']
|
||||
##teamcity[testFinished name='sends information to INFO' duration="{duration}"]
|
||||
##teamcity[testStarted name='shortened hide tags are split apart']
|
||||
##teamcity[testFinished name='shortened hide tags are split apart' duration="{duration}"]
|
||||
##teamcity[testStarted name='skipped tests can optionally provide a reason']
|
||||
##teamcity[testIgnored name='skipped tests can optionally provide a reason' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip with message:|n "skipping because answer = 43"']
|
||||
##teamcity[testFinished name='skipped tests can optionally provide a reason' duration="{duration}"]
|
||||
##teamcity[testStarted name='splitString']
|
||||
##teamcity[testFinished name='splitString' duration="{duration}"]
|
||||
##teamcity[testStarted name='stacks unscoped info in loops']
|
||||
##teamcity[testFailed name='stacks unscoped info in loops' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "Count 1 to 3..."|n "1"|n "2"|n "3"|n CHECK( false )|nwith expansion:|n false|n']
|
||||
##teamcity[testFailed name='stacks unscoped info in loops' message='Message.tests.cpp:<line number>|nexpression failed with messages:|n "Count 4 to 6..."|n "4"|n "5"|n "6"|n CHECK( false )|nwith expansion:|n false|n']
|
||||
##teamcity[testFinished name='stacks unscoped info in loops' duration="{duration}"]
|
||||
##teamcity[testStarted name='startsWith']
|
||||
##teamcity[testFinished name='startsWith' duration="{duration}"]
|
||||
##teamcity[testStarted name='std::map is convertible string']
|
||||
##teamcity[testFinished name='std::map is convertible string' duration="{duration}"]
|
||||
##teamcity[testStarted name='std::pair<int,const std::string> -> toString']
|
||||
##teamcity[testFinished name='std::pair<int,const std::string> -> toString' duration="{duration}"]
|
||||
##teamcity[testStarted name='std::pair<int,std::string> -> toString']
|
||||
##teamcity[testFinished name='std::pair<int,std::string> -> toString' duration="{duration}"]
|
||||
##teamcity[testStarted name='std::set is convertible string']
|
||||
##teamcity[testFinished name='std::set is convertible string' duration="{duration}"]
|
||||
##teamcity[testStarted name='std::vector<std::pair<std::string,int> > -> toString']
|
||||
##teamcity[testFinished name='std::vector<std::pair<std::string,int> > -> toString' duration="{duration}"]
|
||||
##teamcity[testStarted name='stdout and stderr streams have %-starting name']
|
||||
##teamcity[testFinished name='stdout and stderr streams have %-starting name' duration="{duration}"]
|
||||
##teamcity[testStarted name='stringify ranges']
|
||||
##teamcity[testFinished name='stringify ranges' duration="{duration}"]
|
||||
##teamcity[testStarted name='stringify( has_maker )']
|
||||
##teamcity[testFinished name='stringify( has_maker )' duration="{duration}"]
|
||||
##teamcity[testStarted name='stringify( has_maker_and_operator )']
|
||||
##teamcity[testFinished name='stringify( has_maker_and_operator )' duration="{duration}"]
|
||||
##teamcity[testStarted name='stringify( has_neither )']
|
||||
##teamcity[testFinished name='stringify( has_neither )' duration="{duration}"]
|
||||
##teamcity[testStarted name='stringify( has_operator )']
|
||||
##teamcity[testFinished name='stringify( has_operator )' duration="{duration}"]
|
||||
##teamcity[testStarted name='stringify( has_template_operator )']
|
||||
##teamcity[testFinished name='stringify( has_template_operator )' duration="{duration}"]
|
||||
##teamcity[testStarted name='stringify( vectors<has_maker> )']
|
||||
##teamcity[testFinished name='stringify( vectors<has_maker> )' duration="{duration}"]
|
||||
##teamcity[testStarted name='stringify( vectors<has_maker_and_operator> )']
|
||||
##teamcity[testFinished name='stringify( vectors<has_maker_and_operator> )' duration="{duration}"]
|
||||
##teamcity[testStarted name='stringify( vectors<has_operator> )']
|
||||
##teamcity[testFinished name='stringify( vectors<has_operator> )' duration="{duration}"]
|
||||
##teamcity[testStarted name='strlen3']
|
||||
##teamcity[testFinished name='strlen3' duration="{duration}"]
|
||||
##teamcity[testStarted name='tables']
|
||||
##teamcity[testFinished name='tables' duration="{duration}"]
|
||||
##teamcity[testStarted name='tags with dots in later positions are not parsed as hidden']
|
||||
##teamcity[testFinished name='tags with dots in later positions are not parsed as hidden' duration="{duration}"]
|
||||
##teamcity[testStarted name='tests can be skipped dynamically at runtime']
|
||||
##teamcity[testIgnored name='tests can be skipped dynamically at runtime' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
|
||||
##teamcity[testFinished name='tests can be skipped dynamically at runtime' duration="{duration}"]
|
||||
##teamcity[testStarted name='thrown std::strings are translated']
|
||||
##teamcity[testFailed name='thrown std::strings are translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "Why would you throw a std::string?"']
|
||||
##teamcity[testFinished name='thrown std::strings are translated' duration="{duration}"]
|
||||
##teamcity[testStarted name='toString on const wchar_t const pointer returns the string contents']
|
||||
##teamcity[testFinished name='toString on const wchar_t const pointer returns the string contents' duration="{duration}"]
|
||||
##teamcity[testStarted name='toString on const wchar_t pointer returns the string contents']
|
||||
##teamcity[testFinished name='toString on const wchar_t pointer returns the string contents' duration="{duration}"]
|
||||
##teamcity[testStarted name='toString on wchar_t const pointer returns the string contents']
|
||||
##teamcity[testFinished name='toString on wchar_t const pointer returns the string contents' duration="{duration}"]
|
||||
##teamcity[testStarted name='toString on wchar_t returns the string contents']
|
||||
##teamcity[testFinished name='toString on wchar_t returns the string contents' duration="{duration}"]
|
||||
##teamcity[testStarted name='toString(enum class w/operator<<)']
|
||||
##teamcity[testFinished name='toString(enum class w/operator<<)' duration="{duration}"]
|
||||
##teamcity[testStarted name='toString(enum class)']
|
||||
##teamcity[testFinished name='toString(enum class)' duration="{duration}"]
|
||||
##teamcity[testStarted name='toString(enum w/operator<<)']
|
||||
##teamcity[testFinished name='toString(enum w/operator<<)' duration="{duration}"]
|
||||
##teamcity[testStarted name='toString(enum)']
|
||||
##teamcity[testFinished name='toString(enum)' duration="{duration}"]
|
||||
##teamcity[testStarted name='tuple<>']
|
||||
##teamcity[testFinished name='tuple<>' duration="{duration}"]
|
||||
##teamcity[testStarted name='tuple<float,int>']
|
||||
##teamcity[testFinished name='tuple<float,int>' duration="{duration}"]
|
||||
##teamcity[testStarted name='tuple<int>']
|
||||
##teamcity[testFinished name='tuple<int>' duration="{duration}"]
|
||||
##teamcity[testStarted name='tuple<string,string>']
|
||||
##teamcity[testFinished name='tuple<string,string>' duration="{duration}"]
|
||||
##teamcity[testStarted name='tuple<tuple<int>,tuple<>,float>']
|
||||
##teamcity[testFinished name='tuple<tuple<int>,tuple<>,float>' duration="{duration}"]
|
||||
##teamcity[testStarted name='uniform samples']
|
||||
##teamcity[testFinished name='uniform samples' duration="{duration}"]
|
||||
##teamcity[testStarted name='unique_ptr reimplementation: basic functionality']
|
||||
##teamcity[testFinished name='unique_ptr reimplementation: basic functionality' duration="{duration}"]
|
||||
##teamcity[testStarted name='vec<vec<string,alloc>> -> toString']
|
||||
##teamcity[testFinished name='vec<vec<string,alloc>> -> toString' duration="{duration}"]
|
||||
##teamcity[testStarted name='vector<bool> -> toString']
|
||||
##teamcity[testFinished name='vector<bool> -> toString' duration="{duration}"]
|
||||
##teamcity[testStarted name='vector<int,allocator> -> toString']
|
||||
##teamcity[testFinished name='vector<int,allocator> -> toString' duration="{duration}"]
|
||||
##teamcity[testStarted name='vector<int> -> toString']
|
||||
##teamcity[testFinished name='vector<int> -> toString' duration="{duration}"]
|
||||
##teamcity[testStarted name='vector<string> -> toString']
|
||||
##teamcity[testFinished name='vector<string> -> toString' duration="{duration}"]
|
||||
##teamcity[testStarted name='vectors can be sized and resized']
|
||||
##teamcity[testFinished name='vectors can be sized and resized' duration="{duration}"]
|
||||
##teamcity[testStarted name='warmup']
|
||||
##teamcity[testFinished name='warmup' duration="{duration}"]
|
||||
##teamcity[testStarted name='weighted_average_quantile']
|
||||
##teamcity[testFinished name='weighted_average_quantile' duration="{duration}"]
|
||||
##teamcity[testStarted name='xmlentitycheck']
|
||||
##teamcity[testFinished name='xmlentitycheck' duration="{duration}"]
|
||||
##teamcity[testSuiteFinished name='<exe-name>']
|
||||
997
externals/catch2/tests/SelfTest/Baselines/teamcity.sw.multi.approved.txt
vendored
Normal file
997
externals/catch2/tests/SelfTest/Baselines/teamcity.sw.multi.approved.txt
vendored
Normal file
@@ -0,0 +1,997 @@
|
||||
##teamcity[testSuiteStarted name='<exe-name>']
|
||||
##teamcity[testStarted name='# A test name that starts with a #']
|
||||
##teamcity[testFinished name='# A test name that starts with a #' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1027: Bitfields can be captured']
|
||||
##teamcity[testFinished name='#1027: Bitfields can be captured' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1147']
|
||||
##teamcity[testFinished name='#1147' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1175 - Hidden Test']
|
||||
##teamcity[testFinished name='#1175 - Hidden Test' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1238']
|
||||
##teamcity[testFinished name='#1238' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1245']
|
||||
##teamcity[testFinished name='#1245' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1319: Sections can have description (even if it is not saved']
|
||||
##teamcity[testFinished name='#1319: Sections can have description (even if it is not saved' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1403']
|
||||
##teamcity[testFinished name='#1403' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1455 - INFO and WARN can start with a linebreak']
|
||||
##teamcity[testFinished name='#1455 - INFO and WARN can start with a linebreak' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1514: stderr/stdout is not captured in tests aborted by an exception']
|
||||
##teamcity[testFailed name='#1514: stderr/stdout is not captured in tests aborted by an exception' message='Tricky.tests.cpp:<line number>|n...............................................................................|n|nTricky.tests.cpp:<line number>|nexplicit failure with message:|n "1514"']
|
||||
##teamcity[testStdOut name='#1514: stderr/stdout is not captured in tests aborted by an exception' out='This would not be caught previously|n']
|
||||
##teamcity[testStdErr name='#1514: stderr/stdout is not captured in tests aborted by an exception' out='Nor would this|n']
|
||||
##teamcity[testFinished name='#1514: stderr/stdout is not captured in tests aborted by an exception' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1548']
|
||||
##teamcity[testFinished name='#1548' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1905 -- test spec parser properly clears internal state between compound tests']
|
||||
##teamcity[testFinished name='#1905 -- test spec parser properly clears internal state between compound tests' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1912 -- test spec parser handles escaping']
|
||||
##teamcity[testFinished name='#1912 -- test spec parser handles escaping' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1913 - GENERATE inside a for loop should not keep recreating the generator']
|
||||
##teamcity[testFinished name='#1913 - GENERATE inside a for loop should not keep recreating the generator' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1913 - GENERATEs can share a line']
|
||||
##teamcity[testFinished name='#1913 - GENERATEs can share a line' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1938 - GENERATE after a section']
|
||||
##teamcity[testFinished name='#1938 - GENERATE after a section' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1938 - Section followed by flat generate']
|
||||
##teamcity[testFinished name='#1938 - Section followed by flat generate' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1938 - flat generate']
|
||||
##teamcity[testFinished name='#1938 - flat generate' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1938 - mixed sections and generates']
|
||||
##teamcity[testFinished name='#1938 - mixed sections and generates' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1938 - nested generate']
|
||||
##teamcity[testFinished name='#1938 - nested generate' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1954 - 7 arg template test case sig compiles - 1, 1, 1, 1, 1, 0, 0']
|
||||
##teamcity[testFinished name='#1954 - 7 arg template test case sig compiles - 1, 1, 1, 1, 1, 0, 0' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1954 - 7 arg template test case sig compiles - 5, 1, 1, 1, 1, 0, 0']
|
||||
##teamcity[testFinished name='#1954 - 7 arg template test case sig compiles - 5, 1, 1, 1, 1, 0, 0' duration="{duration}"]
|
||||
##teamcity[testStarted name='#1954 - 7 arg template test case sig compiles - 5, 3, 1, 1, 1, 0, 0']
|
||||
##teamcity[testFinished name='#1954 - 7 arg template test case sig compiles - 5, 3, 1, 1, 1, 0, 0' duration="{duration}"]
|
||||
##teamcity[testStarted name='#2152 - ULP checks between differently signed values were wrong - double']
|
||||
##teamcity[testFinished name='#2152 - ULP checks between differently signed values were wrong - double' duration="{duration}"]
|
||||
##teamcity[testStarted name='#2152 - ULP checks between differently signed values were wrong - float']
|
||||
##teamcity[testFinished name='#2152 - ULP checks between differently signed values were wrong - float' duration="{duration}"]
|
||||
##teamcity[testStarted name='#2615 - Throwing in constructor generator fails test case but does not abort']
|
||||
##teamcity[testIgnored name='#2615 - Throwing in constructor generator fails test case but does not abort' message='Generators.tests.cpp:<line number>|n...............................................................................|n|nGenerators.tests.cpp:<line number>|nunexpected exception with message:|n "failure to init"- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testFinished name='#2615 - Throwing in constructor generator fails test case but does not abort' duration="{duration}"]
|
||||
##teamcity[testStarted name='#748 - captures with unexpected exceptions']
|
||||
##teamcity[testIgnored name='#748 - captures with unexpected exceptions' message='-------------------------------------------------------------------------------|noutside assertions|n-------------------------------------------------------------------------------|nException.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with messages:|n "answer := 42"|n "expected exception"- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='#748 - captures with unexpected exceptions' message='-------------------------------------------------------------------------------|ninside REQUIRE_NOTHROW|n-------------------------------------------------------------------------------|nException.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with messages:|n "answer := 42"|n "expected exception"|n REQUIRE_NOTHROW( thisThrows() )|nwith expansion:|n thisThrows()|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testFinished name='#748 - captures with unexpected exceptions' duration="{duration}"]
|
||||
##teamcity[testStarted name='#809']
|
||||
##teamcity[testFinished name='#809' duration="{duration}"]
|
||||
##teamcity[testStarted name='#833']
|
||||
##teamcity[testFinished name='#833' duration="{duration}"]
|
||||
##teamcity[testStarted name='#835 -- errno should not be touched by Catch2']
|
||||
##teamcity[testIgnored name='#835 -- errno should not be touched by Catch2' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n CHECK( f() == 0 )|nwith expansion:|n 1 == 0|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testFinished name='#835 -- errno should not be touched by Catch2' duration="{duration}"]
|
||||
##teamcity[testStarted name='#872']
|
||||
##teamcity[testFinished name='#872' duration="{duration}"]
|
||||
##teamcity[testStarted name='#961 -- Dynamically created sections should all be reported']
|
||||
##teamcity[testFinished name='#961 -- Dynamically created sections should all be reported' duration="{duration}"]
|
||||
##teamcity[testStarted name='|'Not|' checks that should fail']
|
||||
##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexpression failed|n CHECK( false != false )|nwith expansion:|n false != false|n']
|
||||
##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( true != true )|nwith expansion:|n true != true|n']
|
||||
##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( !true )|nwith expansion:|n false|n']
|
||||
##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK_FALSE( true )|nwith expansion:|n !true|n']
|
||||
##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( !trueValue )|nwith expansion:|n false|n']
|
||||
##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK_FALSE( trueValue )|nwith expansion:|n !true|n']
|
||||
##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( !(1 == 1) )|nwith expansion:|n false|n']
|
||||
##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK_FALSE( 1 == 1 )|nwith expansion:|n !(1 == 1)|n']
|
||||
##teamcity[testFinished name='|'Not|' checks that should fail' duration="{duration}"]
|
||||
##teamcity[testStarted name='|'Not|' checks that should succeed']
|
||||
##teamcity[testFinished name='|'Not|' checks that should succeed' duration="{duration}"]
|
||||
##teamcity[testStarted name='(unimplemented) static bools can be evaluated']
|
||||
##teamcity[testFinished name='(unimplemented) static bools can be evaluated' duration="{duration}"]
|
||||
##teamcity[testStarted name='3x3x3 ints']
|
||||
##teamcity[testFinished name='3x3x3 ints' duration="{duration}"]
|
||||
##teamcity[testStarted name='A METHOD_AS_TEST_CASE based test run that fails']
|
||||
##teamcity[testFailed name='A METHOD_AS_TEST_CASE based test run that fails' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( s == "world" )|nwith expansion:|n "hello" == "world"|n']
|
||||
##teamcity[testFinished name='A METHOD_AS_TEST_CASE based test run that fails' duration="{duration}"]
|
||||
##teamcity[testStarted name='A METHOD_AS_TEST_CASE based test run that succeeds']
|
||||
##teamcity[testFinished name='A METHOD_AS_TEST_CASE based test run that succeeds' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<float>']
|
||||
##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<float>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<float>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>']
|
||||
##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>']
|
||||
##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>']
|
||||
##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<float>']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<float>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<int>']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<int>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<float>']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<float>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<int>']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<int>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<float, 6>']
|
||||
##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<float, 6>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 6 < 2|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<float, 6>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>']
|
||||
##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 2 < 2|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>']
|
||||
##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 6 < 2|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>']
|
||||
##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 2 < 2|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<float,6>']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<float,6>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<int,2>']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<int,2>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<float,6>']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<float,6>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<int,2>']
|
||||
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<int,2>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - double']
|
||||
##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - double' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n 1.0 == 2|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - double' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - float']
|
||||
##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - float' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n 1.0f == 2|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - float' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - int']
|
||||
##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - int' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n 1 == 2|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - int' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - float']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - float' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - int']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - int' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1']
|
||||
##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n 1 == 0|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3']
|
||||
##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n 3 == 0|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6']
|
||||
##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n 6 == 0|n']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 3']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 3' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 6']
|
||||
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 6' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEST_CASE_METHOD based test run that fails']
|
||||
##teamcity[testFailed name='A TEST_CASE_METHOD based test run that fails' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( m_a == 2 )|nwith expansion:|n 1 == 2|n']
|
||||
##teamcity[testFinished name='A TEST_CASE_METHOD based test run that fails' duration="{duration}"]
|
||||
##teamcity[testStarted name='A TEST_CASE_METHOD based test run that succeeds']
|
||||
##teamcity[testFinished name='A TEST_CASE_METHOD based test run that succeeds' duration="{duration}"]
|
||||
##teamcity[testStarted name='A Template product test case - Foo<float>']
|
||||
##teamcity[testFinished name='A Template product test case - Foo<float>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A Template product test case - Foo<int>']
|
||||
##teamcity[testFinished name='A Template product test case - Foo<int>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A Template product test case - std::vector<float>']
|
||||
##teamcity[testFinished name='A Template product test case - std::vector<float>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A Template product test case - std::vector<int>']
|
||||
##teamcity[testFinished name='A Template product test case - std::vector<int>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A Template product test case with array signature - Bar<float, 42>']
|
||||
##teamcity[testFinished name='A Template product test case with array signature - Bar<float, 42>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A Template product test case with array signature - Bar<int, 9>']
|
||||
##teamcity[testFinished name='A Template product test case with array signature - Bar<int, 9>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A Template product test case with array signature - std::array<float, 42>']
|
||||
##teamcity[testFinished name='A Template product test case with array signature - std::array<float, 42>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A Template product test case with array signature - std::array<int, 9>']
|
||||
##teamcity[testFinished name='A Template product test case with array signature - std::array<int, 9>' duration="{duration}"]
|
||||
##teamcity[testStarted name='A comparison that uses literals instead of the normal constructor']
|
||||
##teamcity[testFinished name='A comparison that uses literals instead of the normal constructor' duration="{duration}"]
|
||||
##teamcity[testStarted name='A couple of nested sections followed by a failure']
|
||||
##teamcity[testFailed name='A couple of nested sections followed by a failure' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexplicit failure with message:|n "to infinity and beyond"']
|
||||
##teamcity[testFinished name='A couple of nested sections followed by a failure' duration="{duration}"]
|
||||
##teamcity[testStarted name='A failing expression with a non streamable type is still captured']
|
||||
##teamcity[testFailed name='A failing expression with a non streamable type is still captured' message='Tricky.tests.cpp:<line number>|n...............................................................................|n|nTricky.tests.cpp:<line number>|nexpression failed|n CHECK( &o1 == &o2 )|nwith expansion:|n 0x<hex digits> == 0x<hex digits>|n']
|
||||
##teamcity[testFailed name='A failing expression with a non streamable type is still captured' message='Tricky.tests.cpp:<line number>|nexpression failed|n CHECK( o1 == o2 )|nwith expansion:|n {?} == {?}|n']
|
||||
##teamcity[testFinished name='A failing expression with a non streamable type is still captured' duration="{duration}"]
|
||||
##teamcity[testStarted name='Absolute margin']
|
||||
##teamcity[testFinished name='Absolute margin' duration="{duration}"]
|
||||
##teamcity[testStarted name='An empty test with no assertions']
|
||||
##teamcity[testFinished name='An empty test with no assertions' duration="{duration}"]
|
||||
##teamcity[testStarted name='An expression with side-effects should only be evaluated once']
|
||||
##teamcity[testFinished name='An expression with side-effects should only be evaluated once' duration="{duration}"]
|
||||
##teamcity[testStarted name='An unchecked exception reports the line of the last assertion']
|
||||
##teamcity[testFailed name='An unchecked exception reports the line of the last assertion' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "unexpected exception"|n {Unknown expression after the reported line}|nwith expansion:|n {Unknown expression after the reported line}|n']
|
||||
##teamcity[testFinished name='An unchecked exception reports the line of the last assertion' duration="{duration}"]
|
||||
##teamcity[testStarted name='Anonymous test case 1']
|
||||
##teamcity[testFinished name='Anonymous test case 1' duration="{duration}"]
|
||||
##teamcity[testStarted name='Approx setters validate their arguments']
|
||||
##teamcity[testFinished name='Approx setters validate their arguments' duration="{duration}"]
|
||||
##teamcity[testStarted name='Approx with exactly-representable margin']
|
||||
##teamcity[testFinished name='Approx with exactly-representable margin' duration="{duration}"]
|
||||
##teamcity[testStarted name='Approximate PI']
|
||||
##teamcity[testFinished name='Approximate PI' duration="{duration}"]
|
||||
##teamcity[testStarted name='Approximate comparisons with different epsilons']
|
||||
##teamcity[testFinished name='Approximate comparisons with different epsilons' duration="{duration}"]
|
||||
##teamcity[testStarted name='Approximate comparisons with floats']
|
||||
##teamcity[testFinished name='Approximate comparisons with floats' duration="{duration}"]
|
||||
##teamcity[testStarted name='Approximate comparisons with ints']
|
||||
##teamcity[testFinished name='Approximate comparisons with ints' duration="{duration}"]
|
||||
##teamcity[testStarted name='Approximate comparisons with mixed numeric types']
|
||||
##teamcity[testFinished name='Approximate comparisons with mixed numeric types' duration="{duration}"]
|
||||
##teamcity[testStarted name='Arbitrary predicate matcher']
|
||||
##teamcity[testFinished name='Arbitrary predicate matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Assertion macros support bit operators and bool conversions']
|
||||
##teamcity[testFinished name='Assertion macros support bit operators and bool conversions' duration="{duration}"]
|
||||
##teamcity[testStarted name='Assertions then sections']
|
||||
##teamcity[testFinished name='Assertions then sections' duration="{duration}"]
|
||||
##teamcity[testStarted name='Basic use of the Contains range matcher']
|
||||
##teamcity[testFinished name='Basic use of the Contains range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Basic use of the Empty range matcher']
|
||||
##teamcity[testFinished name='Basic use of the Empty range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='CAPTURE can deal with complex expressions']
|
||||
##teamcity[testFinished name='CAPTURE can deal with complex expressions' duration="{duration}"]
|
||||
##teamcity[testStarted name='CAPTURE can deal with complex expressions involving commas']
|
||||
##teamcity[testFinished name='CAPTURE can deal with complex expressions involving commas' duration="{duration}"]
|
||||
##teamcity[testStarted name='CAPTURE parses string and character constants']
|
||||
##teamcity[testFinished name='CAPTURE parses string and character constants' duration="{duration}"]
|
||||
##teamcity[testStarted name='Capture and info messages']
|
||||
##teamcity[testFinished name='Capture and info messages' duration="{duration}"]
|
||||
##teamcity[testStarted name='CaseInsensitiveEqualsTo is case insensitive']
|
||||
##teamcity[testFinished name='CaseInsensitiveEqualsTo is case insensitive' duration="{duration}"]
|
||||
##teamcity[testStarted name='CaseInsensitiveLess is case insensitive']
|
||||
##teamcity[testFinished name='CaseInsensitiveLess is case insensitive' duration="{duration}"]
|
||||
##teamcity[testStarted name='Character pretty printing']
|
||||
##teamcity[testFinished name='Character pretty printing' duration="{duration}"]
|
||||
##teamcity[testStarted name='Clara::Arg supports single-arg parse the way Opt does']
|
||||
##teamcity[testFinished name='Clara::Arg supports single-arg parse the way Opt does' duration="{duration}"]
|
||||
##teamcity[testStarted name='Clara::Opt supports accept-many lambdas']
|
||||
##teamcity[testFinished name='Clara::Opt supports accept-many lambdas' duration="{duration}"]
|
||||
##teamcity[testStarted name='ColourGuard behaviour']
|
||||
##teamcity[testFinished name='ColourGuard behaviour' duration="{duration}"]
|
||||
##teamcity[testStarted name='Combining MatchAllOfGeneric does not nest']
|
||||
##teamcity[testFinished name='Combining MatchAllOfGeneric does not nest' duration="{duration}"]
|
||||
##teamcity[testStarted name='Combining MatchAnyOfGeneric does not nest']
|
||||
##teamcity[testFinished name='Combining MatchAnyOfGeneric does not nest' duration="{duration}"]
|
||||
##teamcity[testStarted name='Combining MatchNotOfGeneric does not nest']
|
||||
##teamcity[testFinished name='Combining MatchNotOfGeneric does not nest' duration="{duration}"]
|
||||
##teamcity[testStarted name='Combining concrete matchers does not use templated matchers']
|
||||
##teamcity[testFinished name='Combining concrete matchers does not use templated matchers' duration="{duration}"]
|
||||
##teamcity[testStarted name='Combining only templated matchers']
|
||||
##teamcity[testFinished name='Combining only templated matchers' duration="{duration}"]
|
||||
##teamcity[testStarted name='Combining templated and concrete matchers']
|
||||
##teamcity[testFinished name='Combining templated and concrete matchers' duration="{duration}"]
|
||||
##teamcity[testStarted name='Combining templated matchers']
|
||||
##teamcity[testFinished name='Combining templated matchers' duration="{duration}"]
|
||||
##teamcity[testStarted name='Commas in various macros are allowed']
|
||||
##teamcity[testFinished name='Commas in various macros are allowed' duration="{duration}"]
|
||||
##teamcity[testStarted name='Comparing function pointers']
|
||||
##teamcity[testFinished name='Comparing function pointers' duration="{duration}"]
|
||||
##teamcity[testStarted name='Comparison ops']
|
||||
##teamcity[testFinished name='Comparison ops' duration="{duration}"]
|
||||
##teamcity[testStarted name='Comparison with explicitly convertible types']
|
||||
##teamcity[testFinished name='Comparison with explicitly convertible types' duration="{duration}"]
|
||||
##teamcity[testStarted name='Comparisons between ints where one side is computed']
|
||||
##teamcity[testFinished name='Comparisons between ints where one side is computed' duration="{duration}"]
|
||||
##teamcity[testStarted name='Comparisons between unsigned ints and negative signed ints match c++ standard behaviour']
|
||||
##teamcity[testFinished name='Comparisons between unsigned ints and negative signed ints match c++ standard behaviour' duration="{duration}"]
|
||||
##teamcity[testStarted name='Comparisons with int literals don|'t warn when mixing signed/ unsigned']
|
||||
##teamcity[testFinished name='Comparisons with int literals don|'t warn when mixing signed/ unsigned' duration="{duration}"]
|
||||
##teamcity[testStarted name='Composed generic matchers shortcircuit']
|
||||
##teamcity[testFinished name='Composed generic matchers shortcircuit' duration="{duration}"]
|
||||
##teamcity[testStarted name='Composed matchers shortcircuit']
|
||||
##teamcity[testFinished name='Composed matchers shortcircuit' duration="{duration}"]
|
||||
##teamcity[testStarted name='Contains string matcher']
|
||||
##teamcity[testFailed name='Contains string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), ContainsSubstring( "not there", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" contains: "not there" (case insensitive)|n']
|
||||
##teamcity[testFailed name='Contains string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), ContainsSubstring( "STRING" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" contains: "STRING"|n']
|
||||
##teamcity[testFinished name='Contains string matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Copy and then generate a range']
|
||||
##teamcity[testFinished name='Copy and then generate a range' duration="{duration}"]
|
||||
##teamcity[testStarted name='Cout stream properly declares it writes to stdout']
|
||||
##teamcity[testFinished name='Cout stream properly declares it writes to stdout' duration="{duration}"]
|
||||
##teamcity[testStarted name='Custom exceptions can be translated when testing for nothrow']
|
||||
##teamcity[testFailed name='Custom exceptions can be translated when testing for nothrow' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "custom exception - not std"|n REQUIRE_NOTHROW( throwCustom() )|nwith expansion:|n throwCustom()|n']
|
||||
##teamcity[testFinished name='Custom exceptions can be translated when testing for nothrow' duration="{duration}"]
|
||||
##teamcity[testStarted name='Custom exceptions can be translated when testing for throwing as something else']
|
||||
##teamcity[testFailed name='Custom exceptions can be translated when testing for throwing as something else' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "custom exception - not std"|n REQUIRE_THROWS_AS( throwCustom(), std::exception )|nwith expansion:|n throwCustom(), std::exception|n']
|
||||
##teamcity[testFinished name='Custom exceptions can be translated when testing for throwing as something else' duration="{duration}"]
|
||||
##teamcity[testStarted name='Custom std-exceptions can be custom translated']
|
||||
##teamcity[testFailed name='Custom std-exceptions can be custom translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "custom std exception"']
|
||||
##teamcity[testFinished name='Custom std-exceptions can be custom translated' duration="{duration}"]
|
||||
##teamcity[testStarted name='Default scale is invisible to comparison']
|
||||
##teamcity[testFinished name='Default scale is invisible to comparison' duration="{duration}"]
|
||||
##teamcity[testStarted name='Directly creating an EnumInfo']
|
||||
##teamcity[testFinished name='Directly creating an EnumInfo' duration="{duration}"]
|
||||
##teamcity[testStarted name='Empty stream name opens cout stream']
|
||||
##teamcity[testFinished name='Empty stream name opens cout stream' duration="{duration}"]
|
||||
##teamcity[testStarted name='Empty tag is not allowed']
|
||||
##teamcity[testFinished name='Empty tag is not allowed' duration="{duration}"]
|
||||
##teamcity[testStarted name='EndsWith string matcher']
|
||||
##teamcity[testFailed name='EndsWith string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), EndsWith( "Substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" ends with: "Substring"|n']
|
||||
##teamcity[testFailed name='EndsWith string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" ends with: "this" (case insensitive)|n']
|
||||
##teamcity[testFinished name='EndsWith string matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Enums can quickly have stringification enabled using REGISTER_ENUM']
|
||||
##teamcity[testFinished name='Enums can quickly have stringification enabled using REGISTER_ENUM' duration="{duration}"]
|
||||
##teamcity[testStarted name='Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM']
|
||||
##teamcity[testFinished name='Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM' duration="{duration}"]
|
||||
##teamcity[testStarted name='Epsilon only applies to Approx|'s value']
|
||||
##teamcity[testFinished name='Epsilon only applies to Approx|'s value' duration="{duration}"]
|
||||
##teamcity[testStarted name='Equality checks that should fail']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven == 6 )|nwith expansion:|n 7 == 6|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven == 8 )|nwith expansion:|n 7 == 8|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven == 0 )|nwith expansion:|n 7 == 0|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 9.11f ) )|nwith expansion:|n 9.1f == Approx( 9.1099996567 )|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 9.0f ) )|nwith expansion:|n 9.1f == Approx( 9.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 1 ) )|nwith expansion:|n 9.1f == Approx( 1.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 0 ) )|nwith expansion:|n 9.1f == Approx( 0.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.double_pi == Approx( 3.1415 ) )|nwith expansion:|n 3.1415926535 == Approx( 3.1415 )|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello == "goodbye" )|nwith expansion:|n "hello" == "goodbye"|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello == "hell" )|nwith expansion:|n "hello" == "hell"|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello == "hello1" )|nwith expansion:|n "hello" == "hello1"|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello.size() == 6 )|nwith expansion:|n 5 == 6|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( x == Approx( 1.301 ) )|nwith expansion:|n 1.3 == Approx( 1.301 )|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testFinished name='Equality checks that should fail' duration="{duration}"]
|
||||
##teamcity[testStarted name='Equality checks that should succeed']
|
||||
##teamcity[testFinished name='Equality checks that should succeed' duration="{duration}"]
|
||||
##teamcity[testStarted name='Equals']
|
||||
##teamcity[testFinished name='Equals' duration="{duration}"]
|
||||
##teamcity[testStarted name='Equals string matcher']
|
||||
##teamcity[testFailed name='Equals string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Equals( "this string contains |'ABC|' as a substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" equals: "this string contains |'ABC|' as a substring"|n']
|
||||
##teamcity[testFailed name='Equals string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Equals( "something else", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" equals: "something else" (case insensitive)|n']
|
||||
##teamcity[testFinished name='Equals string matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified']
|
||||
##teamcity[testFinished name='Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified' duration="{duration}"]
|
||||
##teamcity[testStarted name='Exception matchers that fail']
|
||||
##teamcity[testFailed name='Exception matchers that fail' message='-------------------------------------------------------------------------------|nNo exception|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nno exception was thrown where one was expected|n CHECK_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n doesNotThrow(), SpecialException, ExceptionMatcher{ 1 }|n']
|
||||
##teamcity[testFailed name='Exception matchers that fail' message='Matchers.tests.cpp:<line number>|nno exception was thrown where one was expected|n REQUIRE_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n doesNotThrow(), SpecialException, ExceptionMatcher{ 1 }|n']
|
||||
##teamcity[testFailed name='Exception matchers that fail' message='-------------------------------------------------------------------------------|nType mismatch|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nunexpected exception with message:|n "Unknown exception"|n CHECK_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 }|n']
|
||||
##teamcity[testFailed name='Exception matchers that fail' message='Matchers.tests.cpp:<line number>|nunexpected exception with message:|n "Unknown exception"|n REQUIRE_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 }|n']
|
||||
##teamcity[testFailed name='Exception matchers that fail' message='-------------------------------------------------------------------------------|nContents are wrong|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THROWS_MATCHES( throwsSpecialException( 3 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n SpecialException::what special exception has value of 1|n']
|
||||
##teamcity[testFailed name='Exception matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n REQUIRE_THROWS_MATCHES( throwsSpecialException( 4 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n SpecialException::what special exception has value of 1|n']
|
||||
##teamcity[testFinished name='Exception matchers that fail' duration="{duration}"]
|
||||
##teamcity[testStarted name='Exception matchers that succeed']
|
||||
##teamcity[testFinished name='Exception matchers that succeed' duration="{duration}"]
|
||||
##teamcity[testStarted name='Exception message can be matched']
|
||||
##teamcity[testFinished name='Exception message can be matched' duration="{duration}"]
|
||||
##teamcity[testStarted name='Exception messages can be tested for']
|
||||
##teamcity[testFinished name='Exception messages can be tested for' duration="{duration}"]
|
||||
##teamcity[testStarted name='Exceptions matchers']
|
||||
##teamcity[testFinished name='Exceptions matchers' duration="{duration}"]
|
||||
##teamcity[testStarted name='Expected exceptions that don|'t throw or unexpected exceptions fail the test']
|
||||
##teamcity[testFailed name='Expected exceptions that don|'t throw or unexpected exceptions fail the test' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK_THROWS_AS( thisThrows(), std::string )|nwith expansion:|n thisThrows(), std::string|n']
|
||||
##teamcity[testFailed name='Expected exceptions that don|'t throw or unexpected exceptions fail the test' message='Exception.tests.cpp:<line number>|nno exception was thrown where one was expected|n CHECK_THROWS_AS( thisDoesntThrow(), std::domain_error )|nwith expansion:|n thisDoesntThrow(), std::domain_error|n']
|
||||
##teamcity[testFailed name='Expected exceptions that don|'t throw or unexpected exceptions fail the test' message='Exception.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK_NOTHROW( thisThrows() )|nwith expansion:|n thisThrows()|n']
|
||||
##teamcity[testFinished name='Expected exceptions that don|'t throw or unexpected exceptions fail the test' duration="{duration}"]
|
||||
##teamcity[testStarted name='FAIL aborts the test']
|
||||
##teamcity[testFailed name='FAIL aborts the test' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "This is a failure"']
|
||||
##teamcity[testFinished name='FAIL aborts the test' duration="{duration}"]
|
||||
##teamcity[testStarted name='FAIL does not require an argument']
|
||||
##teamcity[testFailed name='FAIL does not require an argument' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure']
|
||||
##teamcity[testFinished name='FAIL does not require an argument' duration="{duration}"]
|
||||
##teamcity[testStarted name='FAIL_CHECK does not abort the test']
|
||||
##teamcity[testFailed name='FAIL_CHECK does not abort the test' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "This is a failure"']
|
||||
##teamcity[testFinished name='FAIL_CHECK does not abort the test' duration="{duration}"]
|
||||
##teamcity[testStarted name='Factorials are computed']
|
||||
##teamcity[testFinished name='Factorials are computed' duration="{duration}"]
|
||||
##teamcity[testStarted name='Filter generator throws exception for empty generator']
|
||||
##teamcity[testFinished name='Filter generator throws exception for empty generator' duration="{duration}"]
|
||||
##teamcity[testStarted name='Floating point matchers: double']
|
||||
##teamcity[testFinished name='Floating point matchers: double' duration="{duration}"]
|
||||
##teamcity[testStarted name='Floating point matchers: float']
|
||||
##teamcity[testFinished name='Floating point matchers: float' duration="{duration}"]
|
||||
##teamcity[testStarted name='Generators -- adapters']
|
||||
##teamcity[testFinished name='Generators -- adapters' duration="{duration}"]
|
||||
##teamcity[testStarted name='Generators -- simple']
|
||||
##teamcity[testFinished name='Generators -- simple' duration="{duration}"]
|
||||
##teamcity[testStarted name='Generators internals']
|
||||
##teamcity[testFinished name='Generators internals' duration="{duration}"]
|
||||
##teamcity[testStarted name='Greater-than inequalities with different epsilons']
|
||||
##teamcity[testFinished name='Greater-than inequalities with different epsilons' duration="{duration}"]
|
||||
##teamcity[testStarted name='Hashers with different seed produce different hash with same test case']
|
||||
##teamcity[testFinished name='Hashers with different seed produce different hash with same test case' duration="{duration}"]
|
||||
##teamcity[testStarted name='Hashers with same seed produce same hash']
|
||||
##teamcity[testFinished name='Hashers with same seed produce same hash' duration="{duration}"]
|
||||
##teamcity[testStarted name='Hashing different test cases produces different result']
|
||||
##teamcity[testFinished name='Hashing different test cases produces different result' duration="{duration}"]
|
||||
##teamcity[testStarted name='Hashing test case produces same hash across multiple calls']
|
||||
##teamcity[testFinished name='Hashing test case produces same hash across multiple calls' duration="{duration}"]
|
||||
##teamcity[testStarted name='INFO and WARN do not abort tests']
|
||||
##teamcity[testFinished name='INFO and WARN do not abort tests' duration="{duration}"]
|
||||
##teamcity[testStarted name='INFO gets logged on failure']
|
||||
##teamcity[testFailed name='INFO gets logged on failure' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "this message should be logged"|n "so should this"|n REQUIRE( a == 1 )|nwith expansion:|n 2 == 1|n']
|
||||
##teamcity[testFinished name='INFO gets logged on failure' duration="{duration}"]
|
||||
##teamcity[testStarted name='INFO gets logged on failure, even if captured before successful assertions']
|
||||
##teamcity[testFailed name='INFO gets logged on failure, even if captured before successful assertions' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "this message may be logged later"|n "this message should be logged"|n CHECK( a == 1 )|nwith expansion:|n 2 == 1|n']
|
||||
##teamcity[testFailed name='INFO gets logged on failure, even if captured before successful assertions' message='Message.tests.cpp:<line number>|nexpression failed with messages:|n "this message may be logged later"|n "this message should be logged"|n "and this, but later"|n CHECK( a == 0 )|nwith expansion:|n 2 == 0|n']
|
||||
##teamcity[testFinished name='INFO gets logged on failure, even if captured before successful assertions' duration="{duration}"]
|
||||
##teamcity[testStarted name='INFO is reset for each loop']
|
||||
##teamcity[testFailed name='INFO is reset for each loop' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "current counter 10"|n "i := 10"|n REQUIRE( i < 10 )|nwith expansion:|n 10 < 10|n']
|
||||
##teamcity[testFinished name='INFO is reset for each loop' duration="{duration}"]
|
||||
##teamcity[testStarted name='Inequality checks that should fail']
|
||||
##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven != 7 )|nwith expansion:|n 7 != 7|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one != Approx( 9.1f ) )|nwith expansion:|n 9.1f != Approx( 9.1000003815 )|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.double_pi != Approx( 3.1415926535 ) )|nwith expansion:|n 3.1415926535 != Approx( 3.1415926535 )|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello != "hello" )|nwith expansion:|n "hello" != "hello"|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello.size() != 5 )|nwith expansion:|n 5 != 5|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testFinished name='Inequality checks that should fail' duration="{duration}"]
|
||||
##teamcity[testStarted name='Inequality checks that should succeed']
|
||||
##teamcity[testFinished name='Inequality checks that should succeed' duration="{duration}"]
|
||||
##teamcity[testStarted name='Lambdas in assertions']
|
||||
##teamcity[testFinished name='Lambdas in assertions' duration="{duration}"]
|
||||
##teamcity[testStarted name='Less-than inequalities with different epsilons']
|
||||
##teamcity[testFinished name='Less-than inequalities with different epsilons' duration="{duration}"]
|
||||
##teamcity[testStarted name='ManuallyRegistered']
|
||||
##teamcity[testFinished name='ManuallyRegistered' duration="{duration}"]
|
||||
##teamcity[testStarted name='Matchers can be (AllOf) composed with the && operator']
|
||||
##teamcity[testFinished name='Matchers can be (AllOf) composed with the && operator' duration="{duration}"]
|
||||
##teamcity[testStarted name='Matchers can be (AnyOf) composed with the |||| operator']
|
||||
##teamcity[testFinished name='Matchers can be (AnyOf) composed with the |||| operator' duration="{duration}"]
|
||||
##teamcity[testStarted name='Matchers can be composed with both && and ||||']
|
||||
##teamcity[testFinished name='Matchers can be composed with both && and ||||' duration="{duration}"]
|
||||
##teamcity[testStarted name='Matchers can be composed with both && and |||| - failing']
|
||||
##teamcity[testFailed name='Matchers can be composed with both && and |||| - failing' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), ( ContainsSubstring( "string" ) |||| ContainsSubstring( "different" ) ) && ContainsSubstring( "random" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" ( ( contains: "string" or contains: "different" ) and contains: "random" )|n']
|
||||
##teamcity[testFinished name='Matchers can be composed with both && and |||| - failing' duration="{duration}"]
|
||||
##teamcity[testStarted name='Matchers can be negated (Not) with the ! operator']
|
||||
##teamcity[testFinished name='Matchers can be negated (Not) with the ! operator' duration="{duration}"]
|
||||
##teamcity[testStarted name='Matchers can be negated (Not) with the ! operator - failing']
|
||||
##teamcity[testFailed name='Matchers can be negated (Not) with the ! operator - failing' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), !ContainsSubstring( "substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" not contains: "substring"|n']
|
||||
##teamcity[testFinished name='Matchers can be negated (Not) with the ! operator - failing' duration="{duration}"]
|
||||
##teamcity[testStarted name='Mayfail test case with nested sections']
|
||||
##teamcity[testIgnored name='Mayfail test case with nested sections' message='-------------------------------------------------------------------------------|nA|n1|n-------------------------------------------------------------------------------|nCondition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Mayfail test case with nested sections' message='-------------------------------------------------------------------------------|nA|n2|n-------------------------------------------------------------------------------|nCondition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Mayfail test case with nested sections' message='-------------------------------------------------------------------------------|nB|n1|n-------------------------------------------------------------------------------|nCondition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='Mayfail test case with nested sections' message='-------------------------------------------------------------------------------|nB|n2|n-------------------------------------------------------------------------------|nCondition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testFinished name='Mayfail test case with nested sections' duration="{duration}"]
|
||||
##teamcity[testStarted name='Mismatching exception messages failing the test']
|
||||
##teamcity[testFailed name='Mismatching exception messages failing the test' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nexpression failed|n REQUIRE_THROWS_WITH( thisThrows(), "should fail" )|nwith expansion:|n "expected exception" equals: "should fail"|n']
|
||||
##teamcity[testFinished name='Mismatching exception messages failing the test' duration="{duration}"]
|
||||
##teamcity[testStarted name='Multireporter calls reporters and listeners in correct order']
|
||||
##teamcity[testFinished name='Multireporter calls reporters and listeners in correct order' duration="{duration}"]
|
||||
##teamcity[testStarted name='Multireporter updates ReporterPreferences properly']
|
||||
##teamcity[testFinished name='Multireporter updates ReporterPreferences properly' duration="{duration}"]
|
||||
##teamcity[testStarted name='Nested generators and captured variables']
|
||||
##teamcity[testFinished name='Nested generators and captured variables' duration="{duration}"]
|
||||
##teamcity[testStarted name='Nice descriptive name']
|
||||
##teamcity[testFinished name='Nice descriptive name' duration="{duration}"]
|
||||
##teamcity[testStarted name='Non-std exceptions can be translated']
|
||||
##teamcity[testFailed name='Non-std exceptions can be translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "custom exception"']
|
||||
##teamcity[testFinished name='Non-std exceptions can be translated' duration="{duration}"]
|
||||
##teamcity[testStarted name='Objects that evaluated in boolean contexts can be checked']
|
||||
##teamcity[testFinished name='Objects that evaluated in boolean contexts can be checked' duration="{duration}"]
|
||||
##teamcity[testStarted name='Optionally static assertions']
|
||||
##teamcity[testFinished name='Optionally static assertions' duration="{duration}"]
|
||||
##teamcity[testStarted name='Ordering comparison checks that should fail']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven > 7 )|nwith expansion:|n 7 > 7|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < 7 )|nwith expansion:|n 7 < 7|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven > 8 )|nwith expansion:|n 7 > 8|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < 6 )|nwith expansion:|n 7 < 6|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < 0 )|nwith expansion:|n 7 < 0|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < -1 )|nwith expansion:|n 7 < -1|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven >= 8 )|nwith expansion:|n 7 >= 8|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven <= 6 )|nwith expansion:|n 7 <= 6|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one < 9 )|nwith expansion:|n 9.1f < 9|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one > 10 )|nwith expansion:|n 9.1f > 10|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one > 9.2 )|nwith expansion:|n 9.1f > 9.2|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello > "hello" )|nwith expansion:|n "hello" > "hello"|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello < "hello" )|nwith expansion:|n "hello" < "hello"|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello > "hellp" )|nwith expansion:|n "hello" > "hellp"|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello > "z" )|nwith expansion:|n "hello" > "z"|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello < "hellm" )|nwith expansion:|n "hello" < "hellm"|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello < "a" )|nwith expansion:|n "hello" < "a"|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello >= "z" )|nwith expansion:|n "hello" >= "z"|n']
|
||||
##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello <= "a" )|nwith expansion:|n "hello" <= "a"|n']
|
||||
##teamcity[testFinished name='Ordering comparison checks that should fail' duration="{duration}"]
|
||||
##teamcity[testStarted name='Ordering comparison checks that should succeed']
|
||||
##teamcity[testFinished name='Ordering comparison checks that should succeed' duration="{duration}"]
|
||||
##teamcity[testStarted name='Our PCG implementation provides expected results for known seeds']
|
||||
##teamcity[testFinished name='Our PCG implementation provides expected results for known seeds' duration="{duration}"]
|
||||
##teamcity[testStarted name='Output from all sections is reported']
|
||||
##teamcity[testFailed name='Output from all sections is reported' message='-------------------------------------------------------------------------------|none|n-------------------------------------------------------------------------------|nMessage.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "Message from section one"']
|
||||
##teamcity[testFailed name='Output from all sections is reported' message='-------------------------------------------------------------------------------|ntwo|n-------------------------------------------------------------------------------|nMessage.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "Message from section two"']
|
||||
##teamcity[testFinished name='Output from all sections is reported' duration="{duration}"]
|
||||
##teamcity[testStarted name='Overloaded comma or address-of operators are not used']
|
||||
##teamcity[testFinished name='Overloaded comma or address-of operators are not used' duration="{duration}"]
|
||||
##teamcity[testStarted name='Parse uints']
|
||||
##teamcity[testFinished name='Parse uints' duration="{duration}"]
|
||||
##teamcity[testStarted name='Parsed tags are matched case insensitive']
|
||||
##teamcity[testFinished name='Parsed tags are matched case insensitive' duration="{duration}"]
|
||||
##teamcity[testStarted name='Parsing sharding-related cli flags']
|
||||
##teamcity[testFinished name='Parsing sharding-related cli flags' duration="{duration}"]
|
||||
##teamcity[testStarted name='Parsing tags with non-alphabetical characters is pass-through']
|
||||
##teamcity[testFinished name='Parsing tags with non-alphabetical characters is pass-through' duration="{duration}"]
|
||||
##teamcity[testStarted name='Parsing warnings']
|
||||
##teamcity[testFinished name='Parsing warnings' duration="{duration}"]
|
||||
##teamcity[testStarted name='Pointers can be compared to null']
|
||||
##teamcity[testFinished name='Pointers can be compared to null' duration="{duration}"]
|
||||
##teamcity[testStarted name='Precision of floating point stringification can be set']
|
||||
##teamcity[testFinished name='Precision of floating point stringification can be set' duration="{duration}"]
|
||||
##teamcity[testStarted name='Predicate matcher can accept const char*']
|
||||
##teamcity[testFinished name='Predicate matcher can accept const char*' duration="{duration}"]
|
||||
##teamcity[testStarted name='Process can be configured on command line']
|
||||
##teamcity[testFinished name='Process can be configured on command line' duration="{duration}"]
|
||||
##teamcity[testStarted name='Product with differing arities - std::tuple<int, double, float>']
|
||||
##teamcity[testFinished name='Product with differing arities - std::tuple<int, double, float>' duration="{duration}"]
|
||||
##teamcity[testStarted name='Product with differing arities - std::tuple<int, double>']
|
||||
##teamcity[testFinished name='Product with differing arities - std::tuple<int, double>' duration="{duration}"]
|
||||
##teamcity[testStarted name='Product with differing arities - std::tuple<int>']
|
||||
##teamcity[testFinished name='Product with differing arities - std::tuple<int>' duration="{duration}"]
|
||||
##teamcity[testStarted name='Random seed generation accepts known methods']
|
||||
##teamcity[testFinished name='Random seed generation accepts known methods' duration="{duration}"]
|
||||
##teamcity[testStarted name='Random seed generation reports unknown methods']
|
||||
##teamcity[testFinished name='Random seed generation reports unknown methods' duration="{duration}"]
|
||||
##teamcity[testStarted name='Range type with sentinel']
|
||||
##teamcity[testFinished name='Range type with sentinel' duration="{duration}"]
|
||||
##teamcity[testStarted name='Reconstruction should be based on stringification: #914']
|
||||
##teamcity[testFailed name='Reconstruction should be based on stringification: #914' message='Decomposition.tests.cpp:<line number>|n...............................................................................|n|nDecomposition.tests.cpp:<line number>|nexpression failed|n CHECK( truthy(false) )|nwith expansion:|n Hey, its truthy!|n']
|
||||
##teamcity[testFinished name='Reconstruction should be based on stringification: #914' duration="{duration}"]
|
||||
##teamcity[testStarted name='Regex string matcher']
|
||||
##teamcity[testFailed name='Regex string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Matches( "this STRING contains |'abc|' as a substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" matches "this STRING contains |'abc|' as a substring" case sensitively|n']
|
||||
##teamcity[testFailed name='Regex string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Matches( "contains |'abc|' as a substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" matches "contains |'abc|' as a substring" case sensitively|n']
|
||||
##teamcity[testFailed name='Regex string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Matches( "this string contains |'abc|' as a" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" matches "this string contains |'abc|' as a" case sensitively|n']
|
||||
##teamcity[testFinished name='Regex string matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Registering reporter with |'::|' in name fails']
|
||||
##teamcity[testFinished name='Registering reporter with |'::|' in name fails' duration="{duration}"]
|
||||
##teamcity[testStarted name='Regression test #1']
|
||||
##teamcity[testFinished name='Regression test #1' duration="{duration}"]
|
||||
##teamcity[testStarted name='Reporter|'s write listings to provided stream']
|
||||
##teamcity[testFinished name='Reporter|'s write listings to provided stream' duration="{duration}"]
|
||||
##teamcity[testStarted name='Reproducer for #2309 - a very long description past 80 chars (default console width) with a late colon : blablabla']
|
||||
##teamcity[testFinished name='Reproducer for #2309 - a very long description past 80 chars (default console width) with a late colon : blablabla' duration="{duration}"]
|
||||
##teamcity[testStarted name='SUCCEED counts as a test pass']
|
||||
##teamcity[testFinished name='SUCCEED counts as a test pass' duration="{duration}"]
|
||||
##teamcity[testStarted name='SUCCEED does not require an argument']
|
||||
##teamcity[testFinished name='SUCCEED does not require an argument' duration="{duration}"]
|
||||
##teamcity[testStarted name='Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods']
|
||||
##teamcity[testFinished name='Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods' duration="{duration}"]
|
||||
##teamcity[testStarted name='Scenario: Do that thing with the thing']
|
||||
##teamcity[testFinished name='Scenario: Do that thing with the thing' duration="{duration}"]
|
||||
##teamcity[testStarted name='Scenario: This is a really long scenario name to see how the list command deals with wrapping']
|
||||
##teamcity[testFinished name='Scenario: This is a really long scenario name to see how the list command deals with wrapping' duration="{duration}"]
|
||||
##teamcity[testStarted name='Scenario: Vector resizing affects size and capacity']
|
||||
##teamcity[testFinished name='Scenario: Vector resizing affects size and capacity' duration="{duration}"]
|
||||
##teamcity[testStarted name='Sends stuff to stdout and stderr']
|
||||
##teamcity[testStdOut name='Sends stuff to stdout and stderr' out='A string sent directly to stdout|n']
|
||||
##teamcity[testStdErr name='Sends stuff to stdout and stderr' out='A string sent directly to stderr|nA string sent to stderr via clog|n']
|
||||
##teamcity[testFinished name='Sends stuff to stdout and stderr' duration="{duration}"]
|
||||
##teamcity[testStarted name='Some simple comparisons between doubles']
|
||||
##teamcity[testFinished name='Some simple comparisons between doubles' duration="{duration}"]
|
||||
##teamcity[testStarted name='Standard output from all sections is reported']
|
||||
##teamcity[testStdOut name='Standard output from all sections is reported' out='Message from section one|nMessage from section two|n']
|
||||
##teamcity[testFinished name='Standard output from all sections is reported' duration="{duration}"]
|
||||
##teamcity[testStarted name='StartsWith string matcher']
|
||||
##teamcity[testFailed name='StartsWith string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), StartsWith( "This String" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" starts with: "This String"|n']
|
||||
##teamcity[testFailed name='StartsWith string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), StartsWith( "string", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" starts with: "string" (case insensitive)|n']
|
||||
##teamcity[testFinished name='StartsWith string matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Static arrays are convertible to string']
|
||||
##teamcity[testFinished name='Static arrays are convertible to string' duration="{duration}"]
|
||||
##teamcity[testStarted name='String matchers']
|
||||
##teamcity[testFinished name='String matchers' duration="{duration}"]
|
||||
##teamcity[testStarted name='StringRef']
|
||||
##teamcity[testFinished name='StringRef' duration="{duration}"]
|
||||
##teamcity[testStarted name='StringRef at compilation time']
|
||||
##teamcity[testFinished name='StringRef at compilation time' duration="{duration}"]
|
||||
##teamcity[testStarted name='Stringifying char arrays with statically known sizes - char']
|
||||
##teamcity[testFinished name='Stringifying char arrays with statically known sizes - char' duration="{duration}"]
|
||||
##teamcity[testStarted name='Stringifying char arrays with statically known sizes - signed char']
|
||||
##teamcity[testFinished name='Stringifying char arrays with statically known sizes - signed char' duration="{duration}"]
|
||||
##teamcity[testStarted name='Stringifying char arrays with statically known sizes - unsigned char']
|
||||
##teamcity[testFinished name='Stringifying char arrays with statically known sizes - unsigned char' duration="{duration}"]
|
||||
##teamcity[testStarted name='Stringifying std::chrono::duration helpers']
|
||||
##teamcity[testFinished name='Stringifying std::chrono::duration helpers' duration="{duration}"]
|
||||
##teamcity[testStarted name='Stringifying std::chrono::duration with weird ratios']
|
||||
##teamcity[testFinished name='Stringifying std::chrono::duration with weird ratios' duration="{duration}"]
|
||||
##teamcity[testStarted name='Stringifying std::chrono::time_point<system_clock>']
|
||||
##teamcity[testFinished name='Stringifying std::chrono::time_point<system_clock>' duration="{duration}"]
|
||||
##teamcity[testStarted name='Tabs and newlines show in output']
|
||||
##teamcity[testFailed name='Tabs and newlines show in output' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n CHECK( s1 == s2 )|nwith expansion:|n "if ($b == 10) {|n $a = 20;|n}"|n==|n"if ($b == 10) {|n $a = 20;|n}|n"|n']
|
||||
##teamcity[testFinished name='Tabs and newlines show in output' duration="{duration}"]
|
||||
##teamcity[testStarted name='Tag alias can be registered against tag patterns']
|
||||
##teamcity[testFinished name='Tag alias can be registered against tag patterns' duration="{duration}"]
|
||||
##teamcity[testStarted name='Tags with spaces and non-alphanumerical characters are accepted']
|
||||
##teamcity[testFinished name='Tags with spaces and non-alphanumerical characters are accepted' duration="{duration}"]
|
||||
##teamcity[testStarted name='Template test case method with test types specified inside std::tuple - MyTypes - 0']
|
||||
##teamcity[testFinished name='Template test case method with test types specified inside std::tuple - MyTypes - 0' duration="{duration}"]
|
||||
##teamcity[testStarted name='Template test case method with test types specified inside std::tuple - MyTypes - 1']
|
||||
##teamcity[testFinished name='Template test case method with test types specified inside std::tuple - MyTypes - 1' duration="{duration}"]
|
||||
##teamcity[testStarted name='Template test case method with test types specified inside std::tuple - MyTypes - 2']
|
||||
##teamcity[testFinished name='Template test case method with test types specified inside std::tuple - MyTypes - 2' duration="{duration}"]
|
||||
##teamcity[testStarted name='Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 0']
|
||||
##teamcity[testFinished name='Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 0' duration="{duration}"]
|
||||
##teamcity[testStarted name='Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 1']
|
||||
##teamcity[testFinished name='Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 1' duration="{duration}"]
|
||||
##teamcity[testStarted name='Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 0']
|
||||
##teamcity[testFinished name='Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 0' duration="{duration}"]
|
||||
##teamcity[testStarted name='Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 1']
|
||||
##teamcity[testFinished name='Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 1' duration="{duration}"]
|
||||
##teamcity[testStarted name='Template test case with test types specified inside std::tuple - MyTypes - 0']
|
||||
##teamcity[testFinished name='Template test case with test types specified inside std::tuple - MyTypes - 0' duration="{duration}"]
|
||||
##teamcity[testStarted name='Template test case with test types specified inside std::tuple - MyTypes - 1']
|
||||
##teamcity[testFinished name='Template test case with test types specified inside std::tuple - MyTypes - 1' duration="{duration}"]
|
||||
##teamcity[testStarted name='Template test case with test types specified inside std::tuple - MyTypes - 2']
|
||||
##teamcity[testFinished name='Template test case with test types specified inside std::tuple - MyTypes - 2' duration="{duration}"]
|
||||
##teamcity[testStarted name='TemplateTest: vectors can be sized and resized - float']
|
||||
##teamcity[testFinished name='TemplateTest: vectors can be sized and resized - float' duration="{duration}"]
|
||||
##teamcity[testStarted name='TemplateTest: vectors can be sized and resized - int']
|
||||
##teamcity[testFinished name='TemplateTest: vectors can be sized and resized - int' duration="{duration}"]
|
||||
##teamcity[testStarted name='TemplateTest: vectors can be sized and resized - std::string']
|
||||
##teamcity[testFinished name='TemplateTest: vectors can be sized and resized - std::string' duration="{duration}"]
|
||||
##teamcity[testStarted name='TemplateTest: vectors can be sized and resized - std::tuple<int,float>']
|
||||
##teamcity[testFinished name='TemplateTest: vectors can be sized and resized - std::tuple<int,float>' duration="{duration}"]
|
||||
##teamcity[testStarted name='TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6']
|
||||
##teamcity[testFinished name='TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6' duration="{duration}"]
|
||||
##teamcity[testStarted name='TemplateTestSig: vectors can be sized and resized - float,4']
|
||||
##teamcity[testFinished name='TemplateTestSig: vectors can be sized and resized - float,4' duration="{duration}"]
|
||||
##teamcity[testStarted name='TemplateTestSig: vectors can be sized and resized - int,5']
|
||||
##teamcity[testFinished name='TemplateTestSig: vectors can be sized and resized - int,5' duration="{duration}"]
|
||||
##teamcity[testStarted name='TemplateTestSig: vectors can be sized and resized - std::string,15']
|
||||
##teamcity[testFinished name='TemplateTestSig: vectors can be sized and resized - std::string,15' duration="{duration}"]
|
||||
##teamcity[testStarted name='Test case with identical tags keeps just one']
|
||||
##teamcity[testFinished name='Test case with identical tags keeps just one' duration="{duration}"]
|
||||
##teamcity[testStarted name='Test case with one argument']
|
||||
##teamcity[testFinished name='Test case with one argument' duration="{duration}"]
|
||||
##teamcity[testStarted name='Test enum bit values']
|
||||
##teamcity[testFinished name='Test enum bit values' duration="{duration}"]
|
||||
##teamcity[testStarted name='Test with special, characters "in name']
|
||||
##teamcity[testFinished name='Test with special, characters "in name' duration="{duration}"]
|
||||
##teamcity[testStarted name='Testing checked-if']
|
||||
##teamcity[testFinished name='Testing checked-if' duration="{duration}"]
|
||||
##teamcity[testStarted name='Testing checked-if 2']
|
||||
##teamcity[testIgnored name='Testing checked-if 2' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testFinished name='Testing checked-if 2' duration="{duration}"]
|
||||
##teamcity[testStarted name='Testing checked-if 3']
|
||||
##teamcity[testIgnored name='Testing checked-if 3' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testFinished name='Testing checked-if 3' duration="{duration}"]
|
||||
##teamcity[testStarted name='The NO_FAIL macro reports a failure but does not fail the test']
|
||||
##teamcity[testFinished name='The NO_FAIL macro reports a failure but does not fail the test' duration="{duration}"]
|
||||
##teamcity[testStarted name='The default listing implementation write to provided stream']
|
||||
##teamcity[testFinished name='The default listing implementation write to provided stream' duration="{duration}"]
|
||||
##teamcity[testStarted name='This test |'should|' fail but doesn|'t']
|
||||
##teamcity[testFinished name='This test |'should|' fail but doesn|'t' duration="{duration}"]
|
||||
##teamcity[testStarted name='Thrown string literals are translated']
|
||||
##teamcity[testFailed name='Thrown string literals are translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "For some reason someone is throwing a string literal!"']
|
||||
##teamcity[testFinished name='Thrown string literals are translated' duration="{duration}"]
|
||||
##teamcity[testStarted name='Tracker']
|
||||
##teamcity[testFinished name='Tracker' duration="{duration}"]
|
||||
##teamcity[testStarted name='Trim strings']
|
||||
##teamcity[testFinished name='Trim strings' duration="{duration}"]
|
||||
##teamcity[testStarted name='Type conversions of RangeEquals and similar']
|
||||
##teamcity[testFinished name='Type conversions of RangeEquals and similar' duration="{duration}"]
|
||||
##teamcity[testStarted name='Unexpected exceptions can be translated']
|
||||
##teamcity[testFailed name='Unexpected exceptions can be translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "3.14"']
|
||||
##teamcity[testFinished name='Unexpected exceptions can be translated' duration="{duration}"]
|
||||
##teamcity[testStarted name='Upcasting special member functions']
|
||||
##teamcity[testFinished name='Upcasting special member functions' duration="{duration}"]
|
||||
##teamcity[testStarted name='Usage of AllMatch range matcher']
|
||||
##teamcity[testFinished name='Usage of AllMatch range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Usage of AllTrue range matcher']
|
||||
##teamcity[testFinished name='Usage of AllTrue range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Usage of AnyMatch range matcher']
|
||||
##teamcity[testFinished name='Usage of AnyMatch range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Usage of AnyTrue range matcher']
|
||||
##teamcity[testFinished name='Usage of AnyTrue range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Usage of NoneMatch range matcher']
|
||||
##teamcity[testFinished name='Usage of NoneMatch range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Usage of NoneTrue range matcher']
|
||||
##teamcity[testFinished name='Usage of NoneTrue range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Usage of RangeEquals range matcher']
|
||||
##teamcity[testFinished name='Usage of RangeEquals range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Usage of UnorderedRangeEquals range matcher']
|
||||
##teamcity[testFinished name='Usage of UnorderedRangeEquals range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Usage of the SizeIs range matcher']
|
||||
##teamcity[testFinished name='Usage of the SizeIs range matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Use a custom approx']
|
||||
##teamcity[testFinished name='Use a custom approx' duration="{duration}"]
|
||||
##teamcity[testStarted name='Variadic macros']
|
||||
##teamcity[testFinished name='Variadic macros' duration="{duration}"]
|
||||
##teamcity[testStarted name='Vector Approx matcher']
|
||||
##teamcity[testFinished name='Vector Approx matcher' duration="{duration}"]
|
||||
##teamcity[testStarted name='Vector Approx matcher -- failing']
|
||||
##teamcity[testFailed name='Vector Approx matcher -- failing' message='-------------------------------------------------------------------------------|nEmpty and non empty vectors are not approx equal|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, Approx( t1 ) )|nwith expansion:|n { } is approx: { 1.0, 2.0 }|n']
|
||||
##teamcity[testFailed name='Vector Approx matcher -- failing' message='-------------------------------------------------------------------------------|nJust different vectors|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v1, Approx( v2 ) )|nwith expansion:|n { 2.0, 4.0, 6.0 } is approx: { 1.0, 3.0, 5.0 }|n']
|
||||
##teamcity[testFinished name='Vector Approx matcher -- failing' duration="{duration}"]
|
||||
##teamcity[testStarted name='Vector matchers']
|
||||
##teamcity[testFinished name='Vector matchers' duration="{duration}"]
|
||||
##teamcity[testStarted name='Vector matchers that fail']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='-------------------------------------------------------------------------------|nContains (element)|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, VectorContains( -1 ) )|nwith expansion:|n { 1, 2, 3 } Contains: -1|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, VectorContains( 1 ) )|nwith expansion:|n { } Contains: 1|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='-------------------------------------------------------------------------------|nContains (vector)|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, Contains( v ) )|nwith expansion:|n { } Contains: { 1, 2, 3 }|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, Contains( v2 ) )|nwith expansion:|n { 1, 2, 3 } Contains: { 1, 2, 4 }|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='-------------------------------------------------------------------------------|nEquals|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, Equals( v2 ) )|nwith expansion:|n { 1, 2, 3 } Equals: { 1, 2 }|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v2, Equals( v ) )|nwith expansion:|n { 1, 2 } Equals: { 1, 2, 3 }|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, Equals( v ) )|nwith expansion:|n { } Equals: { 1, 2, 3 }|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, Equals( empty ) )|nwith expansion:|n { 1, 2, 3 } Equals: { }|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='-------------------------------------------------------------------------------|nUnorderedEquals|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, UnorderedEquals( empty ) )|nwith expansion:|n { 1, 2, 3 } UnorderedEquals: { }|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, UnorderedEquals( v ) )|nwith expansion:|n { } UnorderedEquals: { 1, 2, 3 }|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( permuted, UnorderedEquals( v ) )|nwith expansion:|n { 1, 3 } UnorderedEquals: { 1, 2, 3 }|n']
|
||||
##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( permuted, UnorderedEquals( v ) )|nwith expansion:|n { 3, 1 } UnorderedEquals: { 1, 2, 3 }|n']
|
||||
##teamcity[testFinished name='Vector matchers that fail' duration="{duration}"]
|
||||
##teamcity[testStarted name='When checked exceptions are thrown they can be expected or unexpected']
|
||||
##teamcity[testFinished name='When checked exceptions are thrown they can be expected or unexpected' duration="{duration}"]
|
||||
##teamcity[testStarted name='When unchecked exceptions are thrown directly they are always failures']
|
||||
##teamcity[testFailed name='When unchecked exceptions are thrown directly they are always failures' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "unexpected exception"']
|
||||
##teamcity[testFinished name='When unchecked exceptions are thrown directly they are always failures' duration="{duration}"]
|
||||
##teamcity[testStarted name='When unchecked exceptions are thrown during a CHECK the test should continue']
|
||||
##teamcity[testFailed name='When unchecked exceptions are thrown during a CHECK the test should continue' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK( thisThrows() == 0 )|nwith expansion:|n thisThrows() == 0|n']
|
||||
##teamcity[testFinished name='When unchecked exceptions are thrown during a CHECK the test should continue' duration="{duration}"]
|
||||
##teamcity[testStarted name='When unchecked exceptions are thrown during a REQUIRE the test should abort fail']
|
||||
##teamcity[testFailed name='When unchecked exceptions are thrown during a REQUIRE the test should abort fail' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n REQUIRE( thisThrows() == 0 )|nwith expansion:|n thisThrows() == 0|n']
|
||||
##teamcity[testFinished name='When unchecked exceptions are thrown during a REQUIRE the test should abort fail' duration="{duration}"]
|
||||
##teamcity[testStarted name='When unchecked exceptions are thrown from functions they are always failures']
|
||||
##teamcity[testFailed name='When unchecked exceptions are thrown from functions they are always failures' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK( thisThrows() == 0 )|nwith expansion:|n thisThrows() == 0|n']
|
||||
##teamcity[testFinished name='When unchecked exceptions are thrown from functions they are always failures' duration="{duration}"]
|
||||
##teamcity[testStarted name='When unchecked exceptions are thrown from sections they are always failures']
|
||||
##teamcity[testFailed name='When unchecked exceptions are thrown from sections they are always failures' message='-------------------------------------------------------------------------------|nsection name|n-------------------------------------------------------------------------------|nException.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "unexpected exception"']
|
||||
##teamcity[testFinished name='When unchecked exceptions are thrown from sections they are always failures' duration="{duration}"]
|
||||
##teamcity[testStarted name='When unchecked exceptions are thrown, but caught, they do not affect the test']
|
||||
##teamcity[testFinished name='When unchecked exceptions are thrown, but caught, they do not affect the test' duration="{duration}"]
|
||||
##teamcity[testStarted name='X/level/0/a']
|
||||
##teamcity[testFinished name='X/level/0/a' duration="{duration}"]
|
||||
##teamcity[testStarted name='X/level/0/b']
|
||||
##teamcity[testFinished name='X/level/0/b' duration="{duration}"]
|
||||
##teamcity[testStarted name='X/level/1/a']
|
||||
##teamcity[testFinished name='X/level/1/a' duration="{duration}"]
|
||||
##teamcity[testStarted name='X/level/1/b']
|
||||
##teamcity[testFinished name='X/level/1/b' duration="{duration}"]
|
||||
##teamcity[testStarted name='XmlEncode']
|
||||
##teamcity[testFinished name='XmlEncode' duration="{duration}"]
|
||||
##teamcity[testStarted name='XmlWriter writes boolean attributes as true/false']
|
||||
##teamcity[testFinished name='XmlWriter writes boolean attributes as true/false' duration="{duration}"]
|
||||
##teamcity[testStarted name='a succeeding test can still be skipped']
|
||||
##teamcity[testIgnored name='a succeeding test can still be skipped' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
|
||||
##teamcity[testFinished name='a succeeding test can still be skipped' duration="{duration}"]
|
||||
##teamcity[testStarted name='analyse no analysis']
|
||||
##teamcity[testFinished name='analyse no analysis' duration="{duration}"]
|
||||
##teamcity[testStarted name='array<int, N> -> toString']
|
||||
##teamcity[testFinished name='array<int, N> -> toString' duration="{duration}"]
|
||||
##teamcity[testStarted name='benchmark function call']
|
||||
##teamcity[testFinished name='benchmark function call' duration="{duration}"]
|
||||
##teamcity[testStarted name='boolean member']
|
||||
##teamcity[testFinished name='boolean member' duration="{duration}"]
|
||||
##teamcity[testStarted name='checkedElse']
|
||||
##teamcity[testFinished name='checkedElse' duration="{duration}"]
|
||||
##teamcity[testStarted name='checkedElse, failing']
|
||||
##teamcity[testFailed name='checkedElse, failing' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n REQUIRE( testCheckedElse( false ) )|nwith expansion:|n false|n']
|
||||
##teamcity[testFinished name='checkedElse, failing' duration="{duration}"]
|
||||
##teamcity[testStarted name='checkedIf']
|
||||
##teamcity[testFinished name='checkedIf' duration="{duration}"]
|
||||
##teamcity[testStarted name='checkedIf, failing']
|
||||
##teamcity[testFailed name='checkedIf, failing' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n REQUIRE( testCheckedIf( false ) )|nwith expansion:|n false|n']
|
||||
##teamcity[testFinished name='checkedIf, failing' duration="{duration}"]
|
||||
##teamcity[testStarted name='classify_outliers']
|
||||
##teamcity[testFinished name='classify_outliers' duration="{duration}"]
|
||||
##teamcity[testStarted name='comparisons between const int variables']
|
||||
##teamcity[testFinished name='comparisons between const int variables' duration="{duration}"]
|
||||
##teamcity[testStarted name='comparisons between int variables']
|
||||
##teamcity[testFinished name='comparisons between int variables' duration="{duration}"]
|
||||
##teamcity[testStarted name='convertToBits']
|
||||
##teamcity[testFinished name='convertToBits' duration="{duration}"]
|
||||
##teamcity[testStarted name='dynamic skipping works with generators']
|
||||
##teamcity[testIgnored name='dynamic skipping works with generators' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip with message:|n "skipping because answer = 41"']
|
||||
##teamcity[testIgnored name='dynamic skipping works with generators' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip with message:|n "skipping because answer = 43"']
|
||||
##teamcity[testFinished name='dynamic skipping works with generators' duration="{duration}"]
|
||||
##teamcity[testStarted name='empty tags are not allowed']
|
||||
##teamcity[testFinished name='empty tags are not allowed' duration="{duration}"]
|
||||
##teamcity[testStarted name='erfc_inv']
|
||||
##teamcity[testFinished name='erfc_inv' duration="{duration}"]
|
||||
##teamcity[testStarted name='estimate_clock_resolution']
|
||||
##teamcity[testFinished name='estimate_clock_resolution' duration="{duration}"]
|
||||
##teamcity[testStarted name='even more nested SECTION tests']
|
||||
##teamcity[testFinished name='even more nested SECTION tests' duration="{duration}"]
|
||||
##teamcity[testStarted name='failed assertions before SKIP cause test case to fail']
|
||||
##teamcity[testIgnored name='failed assertions before SKIP cause test case to fail' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexpression failed|n CHECK( 3 == 4 )|nwith expansion:|n 3 == 4|n- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='failed assertions before SKIP cause test case to fail' message='Skip.tests.cpp:<line number>|nexplicit skip']
|
||||
##teamcity[testFinished name='failed assertions before SKIP cause test case to fail' duration="{duration}"]
|
||||
##teamcity[testStarted name='failing for some generator values causes entire test case to fail']
|
||||
##teamcity[testIgnored name='failing for some generator values causes entire test case to fail' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='failing for some generator values causes entire test case to fail' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
|
||||
##teamcity[testIgnored name='failing for some generator values causes entire test case to fail' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testIgnored name='failing for some generator values causes entire test case to fail' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
|
||||
##teamcity[testFinished name='failing for some generator values causes entire test case to fail' duration="{duration}"]
|
||||
##teamcity[testStarted name='failing in some unskipped sections causes entire test case to fail']
|
||||
##teamcity[testIgnored name='failing in some unskipped sections causes entire test case to fail' message='-------------------------------------------------------------------------------|nskipped|n-------------------------------------------------------------------------------|nSkip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
|
||||
##teamcity[testIgnored name='failing in some unskipped sections causes entire test case to fail' message='-------------------------------------------------------------------------------|nnot skipped|n-------------------------------------------------------------------------------|nSkip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
|
||||
##teamcity[testFinished name='failing in some unskipped sections causes entire test case to fail' duration="{duration}"]
|
||||
##teamcity[testStarted name='first tag']
|
||||
##teamcity[testFinished name='first tag' duration="{duration}"]
|
||||
##teamcity[testStarted name='has printf']
|
||||
##teamcity[testFinished name='has printf' duration="{duration}"]
|
||||
##teamcity[testStarted name='is_unary_function']
|
||||
##teamcity[testFinished name='is_unary_function' duration="{duration}"]
|
||||
##teamcity[testStarted name='just failure']
|
||||
##teamcity[testFailed name='just failure' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "Previous info should not be seen"']
|
||||
##teamcity[testFinished name='just failure' duration="{duration}"]
|
||||
##teamcity[testStarted name='just failure after unscoped info']
|
||||
##teamcity[testFailed name='just failure after unscoped info' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "previous unscoped info SHOULD not be seen"']
|
||||
##teamcity[testFinished name='just failure after unscoped info' duration="{duration}"]
|
||||
##teamcity[testStarted name='just info']
|
||||
##teamcity[testFinished name='just info' duration="{duration}"]
|
||||
##teamcity[testStarted name='just unscoped info']
|
||||
##teamcity[testFinished name='just unscoped info' duration="{duration}"]
|
||||
##teamcity[testStarted name='long long']
|
||||
##teamcity[testFinished name='long long' duration="{duration}"]
|
||||
##teamcity[testStarted name='looped SECTION tests']
|
||||
##teamcity[testFailed name='looped SECTION tests' message='-------------------------------------------------------------------------------|nb is currently: 0|n-------------------------------------------------------------------------------|nMisc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n CHECK( b > a )|nwith expansion:|n 0 > 1|n']
|
||||
##teamcity[testFailed name='looped SECTION tests' message='-------------------------------------------------------------------------------|nb is currently: 1|n-------------------------------------------------------------------------------|nMisc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n CHECK( b > a )|nwith expansion:|n 1 > 1|n']
|
||||
##teamcity[testFinished name='looped SECTION tests' duration="{duration}"]
|
||||
##teamcity[testStarted name='looped tests']
|
||||
##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[0|] (1) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
|
||||
##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[1|] (1) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
|
||||
##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[3|] (3) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
|
||||
##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[4|] (5) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
|
||||
##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[6|] (13) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
|
||||
##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[7|] (21) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
|
||||
##teamcity[testFinished name='looped tests' duration="{duration}"]
|
||||
##teamcity[testStarted name='makeStream recognizes %debug stream name']
|
||||
##teamcity[testFinished name='makeStream recognizes %debug stream name' duration="{duration}"]
|
||||
##teamcity[testStarted name='make_unique reimplementation']
|
||||
##teamcity[testFinished name='make_unique reimplementation' duration="{duration}"]
|
||||
##teamcity[testStarted name='mean']
|
||||
##teamcity[testFinished name='mean' duration="{duration}"]
|
||||
##teamcity[testStarted name='measure']
|
||||
##teamcity[testFinished name='measure' duration="{duration}"]
|
||||
##teamcity[testStarted name='mix info, unscoped info and warning']
|
||||
##teamcity[testFinished name='mix info, unscoped info and warning' duration="{duration}"]
|
||||
##teamcity[testStarted name='more nested SECTION tests']
|
||||
##teamcity[testFailed name='more nested SECTION tests' message='-------------------------------------------------------------------------------|ndoesn|'t equal|nequal|n-------------------------------------------------------------------------------|nMisc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n REQUIRE( a == b )|nwith expansion:|n 1 == 2|n']
|
||||
##teamcity[testFinished name='more nested SECTION tests' duration="{duration}"]
|
||||
##teamcity[testStarted name='nested SECTION tests']
|
||||
##teamcity[testFinished name='nested SECTION tests' duration="{duration}"]
|
||||
##teamcity[testStarted name='nested sections can be skipped dynamically at runtime']
|
||||
##teamcity[testIgnored name='nested sections can be skipped dynamically at runtime' message='-------------------------------------------------------------------------------|nB|nB2|n-------------------------------------------------------------------------------|nSkip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
|
||||
##teamcity[testStdOut name='nested sections can be skipped dynamically at runtime' out='a!|nb1!|n!|n']
|
||||
##teamcity[testFinished name='nested sections can be skipped dynamically at runtime' duration="{duration}"]
|
||||
##teamcity[testStarted name='non streamable - with conv. op']
|
||||
##teamcity[testFinished name='non streamable - with conv. op' duration="{duration}"]
|
||||
##teamcity[testStarted name='non-copyable objects']
|
||||
##teamcity[testFinished name='non-copyable objects' duration="{duration}"]
|
||||
##teamcity[testStarted name='normal_cdf']
|
||||
##teamcity[testFinished name='normal_cdf' duration="{duration}"]
|
||||
##teamcity[testStarted name='normal_quantile']
|
||||
##teamcity[testFinished name='normal_quantile' duration="{duration}"]
|
||||
##teamcity[testStarted name='not allowed']
|
||||
##teamcity[testFinished name='not allowed' duration="{duration}"]
|
||||
##teamcity[testStarted name='not prints unscoped info from previous failures']
|
||||
##teamcity[testFailed name='not prints unscoped info from previous failures' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with message:|n "this SHOULD be seen"|n REQUIRE( false )|nwith expansion:|n false|n']
|
||||
##teamcity[testFinished name='not prints unscoped info from previous failures' duration="{duration}"]
|
||||
##teamcity[testStarted name='null strings']
|
||||
##teamcity[testFinished name='null strings' duration="{duration}"]
|
||||
##teamcity[testStarted name='null_ptr']
|
||||
##teamcity[testFinished name='null_ptr' duration="{duration}"]
|
||||
##teamcity[testStarted name='pair<pair<int,const char *,pair<std::string,int> > -> toString']
|
||||
##teamcity[testFinished name='pair<pair<int,const char *,pair<std::string,int> > -> toString' duration="{duration}"]
|
||||
##teamcity[testStarted name='parseEnums']
|
||||
##teamcity[testFinished name='parseEnums' duration="{duration}"]
|
||||
##teamcity[testStarted name='pointer to class']
|
||||
##teamcity[testFinished name='pointer to class' duration="{duration}"]
|
||||
##teamcity[testStarted name='print unscoped info if passing unscoped info is printed']
|
||||
##teamcity[testFinished name='print unscoped info if passing unscoped info is printed' duration="{duration}"]
|
||||
##teamcity[testStarted name='prints unscoped info on failure']
|
||||
##teamcity[testFailed name='prints unscoped info on failure' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "this SHOULD be seen"|n "this SHOULD also be seen"|n REQUIRE( false )|nwith expansion:|n false|n']
|
||||
##teamcity[testFinished name='prints unscoped info on failure' duration="{duration}"]
|
||||
##teamcity[testStarted name='prints unscoped info only for the first assertion']
|
||||
##teamcity[testFailed name='prints unscoped info only for the first assertion' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with message:|n "this SHOULD be seen only ONCE"|n CHECK( false )|nwith expansion:|n false|n']
|
||||
##teamcity[testFinished name='prints unscoped info only for the first assertion' duration="{duration}"]
|
||||
##teamcity[testStarted name='random SECTION tests']
|
||||
##teamcity[testFinished name='random SECTION tests' duration="{duration}"]
|
||||
##teamcity[testStarted name='replaceInPlace']
|
||||
##teamcity[testFinished name='replaceInPlace' duration="{duration}"]
|
||||
##teamcity[testStarted name='request an unknown %-starting stream fails']
|
||||
##teamcity[testFinished name='request an unknown %-starting stream fails' duration="{duration}"]
|
||||
##teamcity[testStarted name='resolution']
|
||||
##teamcity[testFinished name='resolution' duration="{duration}"]
|
||||
##teamcity[testStarted name='run_for_at_least, chronometer']
|
||||
##teamcity[testFinished name='run_for_at_least, chronometer' duration="{duration}"]
|
||||
##teamcity[testStarted name='run_for_at_least, int']
|
||||
##teamcity[testFinished name='run_for_at_least, int' duration="{duration}"]
|
||||
##teamcity[testStarted name='second tag']
|
||||
##teamcity[testFinished name='second tag' duration="{duration}"]
|
||||
##teamcity[testStarted name='sections can be skipped dynamically at runtime']
|
||||
##teamcity[testIgnored name='sections can be skipped dynamically at runtime' message='-------------------------------------------------------------------------------|nskipped|n-------------------------------------------------------------------------------|nSkip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
|
||||
##teamcity[testFinished name='sections can be skipped dynamically at runtime' duration="{duration}"]
|
||||
##teamcity[testStarted name='send a single char to INFO']
|
||||
##teamcity[testFailed name='send a single char to INFO' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed with message:|n "3"|n REQUIRE( false )|nwith expansion:|n false|n']
|
||||
##teamcity[testFinished name='send a single char to INFO' duration="{duration}"]
|
||||
##teamcity[testStarted name='sends information to INFO']
|
||||
##teamcity[testFailed name='sends information to INFO' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "hi"|n "i := 7"|n REQUIRE( false )|nwith expansion:|n false|n']
|
||||
##teamcity[testFinished name='sends information to INFO' duration="{duration}"]
|
||||
##teamcity[testStarted name='shortened hide tags are split apart']
|
||||
##teamcity[testFinished name='shortened hide tags are split apart' duration="{duration}"]
|
||||
##teamcity[testStarted name='skipped tests can optionally provide a reason']
|
||||
##teamcity[testIgnored name='skipped tests can optionally provide a reason' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip with message:|n "skipping because answer = 43"']
|
||||
##teamcity[testFinished name='skipped tests can optionally provide a reason' duration="{duration}"]
|
||||
##teamcity[testStarted name='splitString']
|
||||
##teamcity[testFinished name='splitString' duration="{duration}"]
|
||||
##teamcity[testStarted name='stacks unscoped info in loops']
|
||||
##teamcity[testFailed name='stacks unscoped info in loops' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "Count 1 to 3..."|n "1"|n "2"|n "3"|n CHECK( false )|nwith expansion:|n false|n']
|
||||
##teamcity[testFailed name='stacks unscoped info in loops' message='Message.tests.cpp:<line number>|nexpression failed with messages:|n "Count 4 to 6..."|n "4"|n "5"|n "6"|n CHECK( false )|nwith expansion:|n false|n']
|
||||
##teamcity[testFinished name='stacks unscoped info in loops' duration="{duration}"]
|
||||
##teamcity[testStarted name='startsWith']
|
||||
##teamcity[testFinished name='startsWith' duration="{duration}"]
|
||||
##teamcity[testStarted name='std::map is convertible string']
|
||||
##teamcity[testFinished name='std::map is convertible string' duration="{duration}"]
|
||||
##teamcity[testStarted name='std::pair<int,const std::string> -> toString']
|
||||
##teamcity[testFinished name='std::pair<int,const std::string> -> toString' duration="{duration}"]
|
||||
##teamcity[testStarted name='std::pair<int,std::string> -> toString']
|
||||
##teamcity[testFinished name='std::pair<int,std::string> -> toString' duration="{duration}"]
|
||||
##teamcity[testStarted name='std::set is convertible string']
|
||||
##teamcity[testFinished name='std::set is convertible string' duration="{duration}"]
|
||||
##teamcity[testStarted name='std::vector<std::pair<std::string,int> > -> toString']
|
||||
##teamcity[testFinished name='std::vector<std::pair<std::string,int> > -> toString' duration="{duration}"]
|
||||
##teamcity[testStarted name='stdout and stderr streams have %-starting name']
|
||||
##teamcity[testFinished name='stdout and stderr streams have %-starting name' duration="{duration}"]
|
||||
##teamcity[testStarted name='stringify ranges']
|
||||
##teamcity[testFinished name='stringify ranges' duration="{duration}"]
|
||||
##teamcity[testStarted name='stringify( has_maker )']
|
||||
##teamcity[testFinished name='stringify( has_maker )' duration="{duration}"]
|
||||
##teamcity[testStarted name='stringify( has_maker_and_operator )']
|
||||
##teamcity[testFinished name='stringify( has_maker_and_operator )' duration="{duration}"]
|
||||
##teamcity[testStarted name='stringify( has_neither )']
|
||||
##teamcity[testFinished name='stringify( has_neither )' duration="{duration}"]
|
||||
##teamcity[testStarted name='stringify( has_operator )']
|
||||
##teamcity[testFinished name='stringify( has_operator )' duration="{duration}"]
|
||||
##teamcity[testStarted name='stringify( has_template_operator )']
|
||||
##teamcity[testFinished name='stringify( has_template_operator )' duration="{duration}"]
|
||||
##teamcity[testStarted name='stringify( vectors<has_maker> )']
|
||||
##teamcity[testFinished name='stringify( vectors<has_maker> )' duration="{duration}"]
|
||||
##teamcity[testStarted name='stringify( vectors<has_maker_and_operator> )']
|
||||
##teamcity[testFinished name='stringify( vectors<has_maker_and_operator> )' duration="{duration}"]
|
||||
##teamcity[testStarted name='stringify( vectors<has_operator> )']
|
||||
##teamcity[testFinished name='stringify( vectors<has_operator> )' duration="{duration}"]
|
||||
##teamcity[testStarted name='strlen3']
|
||||
##teamcity[testFinished name='strlen3' duration="{duration}"]
|
||||
##teamcity[testStarted name='tables']
|
||||
##teamcity[testFinished name='tables' duration="{duration}"]
|
||||
##teamcity[testStarted name='tags with dots in later positions are not parsed as hidden']
|
||||
##teamcity[testFinished name='tags with dots in later positions are not parsed as hidden' duration="{duration}"]
|
||||
##teamcity[testStarted name='tests can be skipped dynamically at runtime']
|
||||
##teamcity[testIgnored name='tests can be skipped dynamically at runtime' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
|
||||
##teamcity[testFinished name='tests can be skipped dynamically at runtime' duration="{duration}"]
|
||||
##teamcity[testStarted name='thrown std::strings are translated']
|
||||
##teamcity[testFailed name='thrown std::strings are translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "Why would you throw a std::string?"']
|
||||
##teamcity[testFinished name='thrown std::strings are translated' duration="{duration}"]
|
||||
##teamcity[testStarted name='toString on const wchar_t const pointer returns the string contents']
|
||||
##teamcity[testFinished name='toString on const wchar_t const pointer returns the string contents' duration="{duration}"]
|
||||
##teamcity[testStarted name='toString on const wchar_t pointer returns the string contents']
|
||||
##teamcity[testFinished name='toString on const wchar_t pointer returns the string contents' duration="{duration}"]
|
||||
##teamcity[testStarted name='toString on wchar_t const pointer returns the string contents']
|
||||
##teamcity[testFinished name='toString on wchar_t const pointer returns the string contents' duration="{duration}"]
|
||||
##teamcity[testStarted name='toString on wchar_t returns the string contents']
|
||||
##teamcity[testFinished name='toString on wchar_t returns the string contents' duration="{duration}"]
|
||||
##teamcity[testStarted name='toString(enum class w/operator<<)']
|
||||
##teamcity[testFinished name='toString(enum class w/operator<<)' duration="{duration}"]
|
||||
##teamcity[testStarted name='toString(enum class)']
|
||||
##teamcity[testFinished name='toString(enum class)' duration="{duration}"]
|
||||
##teamcity[testStarted name='toString(enum w/operator<<)']
|
||||
##teamcity[testFinished name='toString(enum w/operator<<)' duration="{duration}"]
|
||||
##teamcity[testStarted name='toString(enum)']
|
||||
##teamcity[testFinished name='toString(enum)' duration="{duration}"]
|
||||
##teamcity[testStarted name='tuple<>']
|
||||
##teamcity[testFinished name='tuple<>' duration="{duration}"]
|
||||
##teamcity[testStarted name='tuple<float,int>']
|
||||
##teamcity[testFinished name='tuple<float,int>' duration="{duration}"]
|
||||
##teamcity[testStarted name='tuple<int>']
|
||||
##teamcity[testFinished name='tuple<int>' duration="{duration}"]
|
||||
##teamcity[testStarted name='tuple<string,string>']
|
||||
##teamcity[testFinished name='tuple<string,string>' duration="{duration}"]
|
||||
##teamcity[testStarted name='tuple<tuple<int>,tuple<>,float>']
|
||||
##teamcity[testFinished name='tuple<tuple<int>,tuple<>,float>' duration="{duration}"]
|
||||
##teamcity[testStarted name='uniform samples']
|
||||
##teamcity[testFinished name='uniform samples' duration="{duration}"]
|
||||
##teamcity[testStarted name='unique_ptr reimplementation: basic functionality']
|
||||
##teamcity[testFinished name='unique_ptr reimplementation: basic functionality' duration="{duration}"]
|
||||
##teamcity[testStarted name='vec<vec<string,alloc>> -> toString']
|
||||
##teamcity[testFinished name='vec<vec<string,alloc>> -> toString' duration="{duration}"]
|
||||
##teamcity[testStarted name='vector<bool> -> toString']
|
||||
##teamcity[testFinished name='vector<bool> -> toString' duration="{duration}"]
|
||||
##teamcity[testStarted name='vector<int,allocator> -> toString']
|
||||
##teamcity[testFinished name='vector<int,allocator> -> toString' duration="{duration}"]
|
||||
##teamcity[testStarted name='vector<int> -> toString']
|
||||
##teamcity[testFinished name='vector<int> -> toString' duration="{duration}"]
|
||||
##teamcity[testStarted name='vector<string> -> toString']
|
||||
##teamcity[testFinished name='vector<string> -> toString' duration="{duration}"]
|
||||
##teamcity[testStarted name='vectors can be sized and resized']
|
||||
##teamcity[testFinished name='vectors can be sized and resized' duration="{duration}"]
|
||||
##teamcity[testStarted name='warmup']
|
||||
##teamcity[testFinished name='warmup' duration="{duration}"]
|
||||
##teamcity[testStarted name='weighted_average_quantile']
|
||||
##teamcity[testFinished name='weighted_average_quantile' duration="{duration}"]
|
||||
##teamcity[testStarted name='xmlentitycheck']
|
||||
##teamcity[testFinished name='xmlentitycheck' duration="{duration}"]
|
||||
##teamcity[testSuiteFinished name='<exe-name>']
|
||||
21208
externals/catch2/tests/SelfTest/Baselines/xml.sw.approved.txt
vendored
Normal file
21208
externals/catch2/tests/SelfTest/Baselines/xml.sw.approved.txt
vendored
Normal file
File diff suppressed because it is too large
Load Diff
21207
externals/catch2/tests/SelfTest/Baselines/xml.sw.multi.approved.txt
vendored
Normal file
21207
externals/catch2/tests/SelfTest/Baselines/xml.sw.multi.approved.txt
vendored
Normal file
File diff suppressed because it is too large
Load Diff
94
externals/catch2/tests/SelfTest/IntrospectiveTests/Algorithms.tests.cpp
vendored
Normal file
94
externals/catch2/tests/SelfTest/IntrospectiveTests/Algorithms.tests.cpp
vendored
Normal file
@@ -0,0 +1,94 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/internal/catch_is_permutation.hpp>
|
||||
|
||||
#include <helpers/range_test_helpers.hpp>
|
||||
|
||||
#include <array>
|
||||
|
||||
namespace {
|
||||
template <typename Range1, typename Range2>
|
||||
static bool is_permutation(Range1 const& r1, Range2 const& r2) {
|
||||
using std::begin; using std::end;
|
||||
return Catch::Detail::is_permutation(
|
||||
begin( r1 ), end( r1 ), begin( r2 ), end( r2 ), std::equal_to<>{} );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("is_permutation", "[algorithms][approvals]") {
|
||||
SECTION( "Handle empty ranges" ) {
|
||||
std::array<int, 0> empty;
|
||||
std::array<int, 2> non_empty{ { 2, 3 } };
|
||||
REQUIRE( is_permutation( empty, empty ) );
|
||||
REQUIRE_FALSE( is_permutation( empty, non_empty ) );
|
||||
REQUIRE_FALSE( is_permutation( non_empty, empty ) );
|
||||
}
|
||||
SECTION( "Different length ranges" ) {
|
||||
std::array<int, 6> arr1{ { 1, 3, 5, 7, 8, 9 } };
|
||||
// arr2 is prefix of arr1
|
||||
std::array<int, 4> arr2{ { 1, 3, 5, 7 } };
|
||||
// arr3 shares prefix with arr1 and arr2, but is not a permutation
|
||||
std::array<int, 5> arr3{ { 1, 3, 5, 9, 8 } };
|
||||
REQUIRE_FALSE( is_permutation( arr1, arr2 ) );
|
||||
REQUIRE_FALSE( is_permutation( arr1, arr3 ) );
|
||||
REQUIRE_FALSE( is_permutation( arr2, arr3 ) );
|
||||
}
|
||||
SECTION( "Same length ranges" ) {
|
||||
SECTION( "Shared elements, but different counts" ) {
|
||||
const std::array<int, 6>
|
||||
arr1{ { 1, 1, 1, 1, 2, 2 } },
|
||||
arr2{ { 1, 1, 2, 2, 2, 2 } };
|
||||
REQUIRE_FALSE( is_permutation( arr1, arr2 ) );
|
||||
}
|
||||
SECTION( "Identical ranges" ) {
|
||||
const std::array<int, 6>
|
||||
arr1{ { 1, 1, 1, 1, 2, 2 } },
|
||||
arr2{ { 1, 1, 2, 2, 2, 2 } };
|
||||
REQUIRE( is_permutation( arr1, arr1 ) );
|
||||
REQUIRE( is_permutation( arr2, arr2 ) );
|
||||
}
|
||||
SECTION( "Completely distinct elements" ) {
|
||||
// Completely distinct elements
|
||||
const std::array<int, 4>
|
||||
arr1{ { 1, 2, 3, 4 } },
|
||||
arr2{ { 10, 20, 30, 40 } };
|
||||
REQUIRE_FALSE( is_permutation( arr1, arr2 ) );
|
||||
}
|
||||
SECTION( "Reverse ranges" ) {
|
||||
const std::array<int, 5>
|
||||
arr1{ { 1, 2, 3, 4, 5 } },
|
||||
arr2{ { 5, 4, 3, 2, 1 } };
|
||||
REQUIRE( is_permutation( arr1, arr2 ) );
|
||||
}
|
||||
SECTION( "Shared prefix & permuted elements" ) {
|
||||
const std::array<int, 5>
|
||||
arr1{ { 1, 1, 2, 3, 4 } },
|
||||
arr2{ { 1, 1, 4, 2, 3 } };
|
||||
REQUIRE( is_permutation( arr1, arr2 ) );
|
||||
}
|
||||
SECTION( "Permutations with element count > 1" ) {
|
||||
const std::array<int, 7>
|
||||
arr1{ { 2, 2, 3, 3, 3, 1, 1 } },
|
||||
arr2{ { 3, 2, 1, 3, 2, 1, 3 } };
|
||||
REQUIRE( is_permutation( arr1, arr2 ) );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("is_permutation supports iterator + sentinel pairs",
|
||||
"[algorithms][is-permutation][approvals]") {
|
||||
const has_different_begin_end_types<int>
|
||||
range_1{ 1, 2, 3, 4 },
|
||||
range_2{ 4, 3, 2, 1 };
|
||||
REQUIRE( is_permutation( range_1, range_2 ) );
|
||||
|
||||
const has_different_begin_end_types<int> range_3{ 3, 3, 2, 1 };
|
||||
REQUIRE_FALSE( is_permutation( range_1, range_3 ) );
|
||||
}
|
||||
73
externals/catch2/tests/SelfTest/IntrospectiveTests/Clara.tests.cpp
vendored
Normal file
73
externals/catch2/tests/SelfTest/IntrospectiveTests/Clara.tests.cpp
vendored
Normal file
@@ -0,0 +1,73 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/internal/catch_clara.hpp>
|
||||
|
||||
|
||||
#include <string>
|
||||
|
||||
TEST_CASE("is_unary_function", "[clara][compilation]") {
|
||||
auto unary1 = [](int) {};
|
||||
auto unary2 = [](std::string const&) {};
|
||||
auto const unary3 = [](std::string const&) {};
|
||||
auto unary4 = [](int) { return 42; };
|
||||
void unary5(char);
|
||||
double unary6(long);
|
||||
|
||||
double binary1(long, int);
|
||||
auto binary2 = [](int, char) {};
|
||||
auto nullary1 = []() {};
|
||||
auto nullary2 = []() {return 42;};
|
||||
|
||||
STATIC_REQUIRE(Catch::Clara::Detail::is_unary_function<decltype(unary1)>::value);
|
||||
STATIC_REQUIRE(Catch::Clara::Detail::is_unary_function<decltype(unary2)>::value);
|
||||
STATIC_REQUIRE(Catch::Clara::Detail::is_unary_function<decltype(unary3)>::value);
|
||||
STATIC_REQUIRE(Catch::Clara::Detail::is_unary_function<decltype(unary4)>::value);
|
||||
STATIC_REQUIRE(Catch::Clara::Detail::is_unary_function<decltype(unary5)>::value);
|
||||
STATIC_REQUIRE(Catch::Clara::Detail::is_unary_function<decltype(unary6)>::value);
|
||||
|
||||
STATIC_REQUIRE_FALSE(Catch::Clara::Detail::is_unary_function<decltype(binary1)>::value);
|
||||
STATIC_REQUIRE_FALSE(Catch::Clara::Detail::is_unary_function<decltype(binary2)>::value);
|
||||
STATIC_REQUIRE_FALSE(Catch::Clara::Detail::is_unary_function<decltype(nullary1)>::value);
|
||||
STATIC_REQUIRE_FALSE(Catch::Clara::Detail::is_unary_function<decltype(nullary2)>::value);
|
||||
STATIC_REQUIRE_FALSE(Catch::Clara::Detail::is_unary_function<int>::value);
|
||||
STATIC_REQUIRE_FALSE(Catch::Clara::Detail::is_unary_function<std::string const&>::value);
|
||||
}
|
||||
|
||||
|
||||
TEST_CASE("Clara::Arg supports single-arg parse the way Opt does", "[clara][arg][compilation]") {
|
||||
std::string name;
|
||||
auto p = Catch::Clara::Arg(name, "just one arg");
|
||||
|
||||
CHECK(name.empty());
|
||||
|
||||
p.parse( Catch::Clara::Args{ "UnitTest", "foo" } );
|
||||
REQUIRE(name == "foo");
|
||||
}
|
||||
|
||||
TEST_CASE("Clara::Opt supports accept-many lambdas", "[clara][opt]") {
|
||||
using namespace Catch::Clara;
|
||||
std::vector<std::string> res;
|
||||
const auto push_to_res = [&](std::string const& s) {
|
||||
res.push_back(s);
|
||||
return ParserResult::ok( ParseResultType::Matched );
|
||||
};
|
||||
|
||||
SECTION("Parsing fails on multiple options without accept_many") {
|
||||
auto p = Parser() | Opt(push_to_res, "value")["-o"];
|
||||
auto parse_result = p.parse( Args{ "UnitTest", "-o", "aaa", "-o", "bbb" } );
|
||||
CHECK_FALSE(parse_result);
|
||||
}
|
||||
SECTION("Parsing succeeds on multiple options with accept_many") {
|
||||
auto p = Parser() | Opt(accept_many, push_to_res, "value")["-o"];
|
||||
auto parse_result = p.parse( Args{ "UnitTest", "-o", "aaa", "-o", "bbb" } );
|
||||
CHECK(parse_result);
|
||||
CHECK(res == std::vector<std::string>{ "aaa", "bbb" });
|
||||
}
|
||||
}
|
||||
467
externals/catch2/tests/SelfTest/IntrospectiveTests/CmdLine.tests.cpp
vendored
Normal file
467
externals/catch2/tests/SelfTest/IntrospectiveTests/CmdLine.tests.cpp
vendored
Normal file
@@ -0,0 +1,467 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_config.hpp>
|
||||
#include <catch2/catch_approx.hpp>
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/matchers/catch_matchers_string.hpp>
|
||||
#include <catch2/internal/catch_test_spec_parser.hpp>
|
||||
#include <catch2/catch_user_config.hpp>
|
||||
#include <catch2/catch_test_case_info.hpp>
|
||||
#include <catch2/internal/catch_commandline.hpp>
|
||||
#include <catch2/generators/catch_generators.hpp>
|
||||
#include <catch2/internal/catch_compiler_capabilities.hpp>
|
||||
|
||||
|
||||
namespace {
|
||||
auto fakeTestCase(const char* name, const char* desc = "") { return Catch::makeTestCaseInfo("", { name, desc }, CATCH_INTERNAL_LINEINFO); }
|
||||
}
|
||||
|
||||
TEST_CASE( "Process can be configured on command line", "[config][command-line]" ) {
|
||||
|
||||
using namespace Catch::Matchers;
|
||||
|
||||
Catch::ConfigData config;
|
||||
auto cli = Catch::makeCommandLineParser(config);
|
||||
|
||||
SECTION("empty args don't cause a crash") {
|
||||
auto result = cli.parse({""});
|
||||
CHECK(result);
|
||||
CHECK(config.processName == "");
|
||||
}
|
||||
|
||||
SECTION("default - no arguments") {
|
||||
auto result = cli.parse({"test"});
|
||||
CHECK(result);
|
||||
CHECK(config.processName == "test");
|
||||
CHECK(config.shouldDebugBreak == false);
|
||||
CHECK(config.abortAfter == -1);
|
||||
CHECK(config.noThrow == false);
|
||||
CHECK( config.reporterSpecifications.empty() );
|
||||
|
||||
Catch::Config cfg(config);
|
||||
CHECK_FALSE(cfg.hasTestFilters());
|
||||
|
||||
// The Config is responsible for mixing in the default reporter
|
||||
auto expectedReporter =
|
||||
#if defined( CATCH_CONFIG_DEFAULT_REPORTER )
|
||||
CATCH_CONFIG_DEFAULT_REPORTER
|
||||
#else
|
||||
"console"
|
||||
#endif
|
||||
;
|
||||
|
||||
CHECK( cfg.getReporterSpecs().size() == 1 );
|
||||
CHECK( cfg.getReporterSpecs()[0] ==
|
||||
Catch::ReporterSpec{ expectedReporter, {}, {}, {} } );
|
||||
CHECK( cfg.getProcessedReporterSpecs().size() == 1 );
|
||||
CHECK( cfg.getProcessedReporterSpecs()[0] ==
|
||||
Catch::ProcessedReporterSpec{ expectedReporter,
|
||||
std::string{},
|
||||
Catch::ColourMode::PlatformDefault,
|
||||
{} } );
|
||||
}
|
||||
|
||||
SECTION("test lists") {
|
||||
SECTION("Specify one test case using") {
|
||||
auto result = cli.parse({"test", "test1"});
|
||||
CHECK(result);
|
||||
|
||||
Catch::Config cfg(config);
|
||||
REQUIRE(cfg.hasTestFilters());
|
||||
REQUIRE(cfg.testSpec().matches(*fakeTestCase("notIncluded")) == false);
|
||||
REQUIRE(cfg.testSpec().matches(*fakeTestCase("test1")));
|
||||
}
|
||||
SECTION("Specify one test case exclusion using exclude:") {
|
||||
auto result = cli.parse({"test", "exclude:test1"});
|
||||
CHECK(result);
|
||||
|
||||
Catch::Config cfg(config);
|
||||
REQUIRE(cfg.hasTestFilters());
|
||||
REQUIRE(cfg.testSpec().matches(*fakeTestCase("test1")) == false);
|
||||
REQUIRE(cfg.testSpec().matches(*fakeTestCase("alwaysIncluded")));
|
||||
}
|
||||
|
||||
SECTION("Specify one test case exclusion using ~") {
|
||||
auto result = cli.parse({"test", "~test1"});
|
||||
CHECK(result);
|
||||
|
||||
Catch::Config cfg(config);
|
||||
REQUIRE(cfg.hasTestFilters());
|
||||
REQUIRE(cfg.testSpec().matches(*fakeTestCase("test1")) == false);
|
||||
REQUIRE(cfg.testSpec().matches(*fakeTestCase("alwaysIncluded")));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
SECTION("reporter") {
|
||||
using vec_Specs = std::vector<Catch::ReporterSpec>;
|
||||
using namespace std::string_literals;
|
||||
SECTION("-r/console") {
|
||||
auto result = cli.parse({"test", "-r", "console"});
|
||||
CAPTURE(result.errorMessage());
|
||||
CHECK(result);
|
||||
|
||||
REQUIRE( config.reporterSpecifications ==
|
||||
vec_Specs{ { "console", {}, {}, {} } } );
|
||||
}
|
||||
SECTION("-r/xml") {
|
||||
auto result = cli.parse({"test", "-r", "xml"});
|
||||
CAPTURE(result.errorMessage());
|
||||
CHECK(result);
|
||||
|
||||
REQUIRE( config.reporterSpecifications ==
|
||||
vec_Specs{ { "xml", {}, {}, {} } } );
|
||||
}
|
||||
SECTION("--reporter/junit") {
|
||||
auto result = cli.parse({"test", "--reporter", "junit"});
|
||||
CAPTURE(result.errorMessage());
|
||||
CHECK(result);
|
||||
|
||||
REQUIRE( config.reporterSpecifications ==
|
||||
vec_Specs{ { "junit", {}, {}, {} } } );
|
||||
}
|
||||
SECTION("must match one of the available ones") {
|
||||
auto result = cli.parse({"test", "--reporter", "unsupported"});
|
||||
CHECK(!result);
|
||||
|
||||
REQUIRE_THAT(result.errorMessage(), ContainsSubstring("Unrecognized reporter"));
|
||||
}
|
||||
SECTION("With output file") {
|
||||
auto result = cli.parse({ "test", "-r", "console::out=out.txt" });
|
||||
CAPTURE(result.errorMessage());
|
||||
CHECK(result);
|
||||
REQUIRE( config.reporterSpecifications ==
|
||||
vec_Specs{ { "console", "out.txt"s, {}, {} } } );
|
||||
}
|
||||
SECTION("With Windows-like absolute path as output file") {
|
||||
auto result = cli.parse({ "test", "-r", "console::out=C:\\Temp\\out.txt" });
|
||||
CAPTURE(result.errorMessage());
|
||||
CHECK(result);
|
||||
REQUIRE( config.reporterSpecifications ==
|
||||
vec_Specs{ { "console", "C:\\Temp\\out.txt"s, {}, {} } } );
|
||||
}
|
||||
SECTION("Multiple reporters") {
|
||||
SECTION("All with output files") {
|
||||
CHECK(cli.parse({ "test", "-r", "xml::out=output.xml", "-r", "junit::out=output-junit.xml" }));
|
||||
REQUIRE( config.reporterSpecifications ==
|
||||
vec_Specs{ { "xml", "output.xml"s, {}, {} },
|
||||
{ "junit", "output-junit.xml"s, {}, {} } } );
|
||||
}
|
||||
SECTION("Mixed output files and default output") {
|
||||
CHECK(cli.parse({ "test", "-r", "xml::out=output.xml", "-r", "console" }));
|
||||
REQUIRE( config.reporterSpecifications ==
|
||||
vec_Specs{ { "xml", "output.xml"s, {}, {} },
|
||||
{ "console", {}, {}, {} } } );
|
||||
}
|
||||
SECTION("cannot have multiple reporters with default output") {
|
||||
auto result = cli.parse({ "test", "-r", "console", "-r", "xml::out=output.xml", "-r", "junit" });
|
||||
CHECK(!result);
|
||||
REQUIRE_THAT(result.errorMessage(), ContainsSubstring("Only one reporter may have unspecified output file."));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SECTION("debugger") {
|
||||
SECTION("-b") {
|
||||
CHECK(cli.parse({"test", "-b"}));
|
||||
|
||||
REQUIRE(config.shouldDebugBreak == true);
|
||||
}
|
||||
SECTION("--break") {
|
||||
CHECK(cli.parse({"test", "--break"}));
|
||||
|
||||
REQUIRE(config.shouldDebugBreak);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
SECTION("abort") {
|
||||
SECTION("-a aborts after first failure") {
|
||||
CHECK(cli.parse({"test", "-a"}));
|
||||
|
||||
REQUIRE(config.abortAfter == 1);
|
||||
}
|
||||
SECTION("-x 2 aborts after two failures") {
|
||||
CHECK(cli.parse({"test", "-x", "2"}));
|
||||
|
||||
REQUIRE(config.abortAfter == 2);
|
||||
}
|
||||
SECTION("-x must be numeric") {
|
||||
auto result = cli.parse({"test", "-x", "oops"});
|
||||
CHECK(!result);
|
||||
REQUIRE_THAT(result.errorMessage(), ContainsSubstring("convert") && ContainsSubstring("oops"));
|
||||
}
|
||||
|
||||
SECTION("wait-for-keypress") {
|
||||
SECTION("Accepted options") {
|
||||
using tuple_type = std::tuple<char const*, Catch::WaitForKeypress::When>;
|
||||
auto input = GENERATE(table<char const*, Catch::WaitForKeypress::When>({
|
||||
tuple_type{"never", Catch::WaitForKeypress::Never},
|
||||
tuple_type{"start", Catch::WaitForKeypress::BeforeStart},
|
||||
tuple_type{"exit", Catch::WaitForKeypress::BeforeExit},
|
||||
tuple_type{"both", Catch::WaitForKeypress::BeforeStartAndExit},
|
||||
}));
|
||||
CHECK(cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}));
|
||||
|
||||
REQUIRE(config.waitForKeypress == std::get<1>(input));
|
||||
}
|
||||
|
||||
SECTION("invalid options are reported") {
|
||||
auto result = cli.parse({"test", "--wait-for-keypress", "sometimes"});
|
||||
CHECK(!result);
|
||||
|
||||
#ifndef CATCH_CONFIG_DISABLE_MATCHERS
|
||||
REQUIRE_THAT(result.errorMessage(), ContainsSubstring("never") && ContainsSubstring("both"));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SECTION("nothrow") {
|
||||
SECTION("-e") {
|
||||
CHECK(cli.parse({"test", "-e"}));
|
||||
|
||||
REQUIRE(config.noThrow);
|
||||
}
|
||||
SECTION("--nothrow") {
|
||||
CHECK(cli.parse({"test", "--nothrow"}));
|
||||
|
||||
REQUIRE(config.noThrow);
|
||||
}
|
||||
}
|
||||
|
||||
SECTION("output filename") {
|
||||
SECTION("-o filename") {
|
||||
CHECK(cli.parse({"test", "-o", "filename.ext"}));
|
||||
|
||||
REQUIRE(config.defaultOutputFilename == "filename.ext");
|
||||
}
|
||||
SECTION("--out") {
|
||||
CHECK(cli.parse({"test", "--out", "filename.ext"}));
|
||||
|
||||
REQUIRE(config.defaultOutputFilename == "filename.ext");
|
||||
}
|
||||
}
|
||||
|
||||
SECTION("combinations") {
|
||||
SECTION("Single character flags can be combined") {
|
||||
CHECK(cli.parse({"test", "-abe"}));
|
||||
|
||||
CHECK(config.abortAfter == 1);
|
||||
CHECK(config.shouldDebugBreak);
|
||||
CHECK(config.noThrow == true);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
SECTION( "use-colour") {
|
||||
|
||||
using Catch::ColourMode;
|
||||
|
||||
SECTION( "without option" ) {
|
||||
CHECK(cli.parse({"test"}));
|
||||
|
||||
REQUIRE( config.defaultColourMode == ColourMode::PlatformDefault );
|
||||
}
|
||||
|
||||
SECTION( "auto" ) {
|
||||
CHECK( cli.parse( { "test", "--colour-mode", "default" } ) );
|
||||
|
||||
REQUIRE( config.defaultColourMode == ColourMode::PlatformDefault );
|
||||
}
|
||||
|
||||
SECTION( "yes" ) {
|
||||
CHECK(cli.parse({"test", "--colour-mode", "ansi"}));
|
||||
|
||||
REQUIRE( config.defaultColourMode == ColourMode::ANSI );
|
||||
}
|
||||
|
||||
SECTION( "no" ) {
|
||||
CHECK(cli.parse({"test", "--colour-mode", "none"}));
|
||||
|
||||
REQUIRE( config.defaultColourMode == ColourMode::None );
|
||||
}
|
||||
|
||||
SECTION( "error" ) {
|
||||
auto result = cli.parse({"test", "--colour-mode", "wrong"});
|
||||
CHECK( !result );
|
||||
CHECK_THAT( result.errorMessage(), ContainsSubstring( "colour mode must be one of" ) );
|
||||
}
|
||||
}
|
||||
|
||||
SECTION("Benchmark options") {
|
||||
SECTION("samples") {
|
||||
CHECK(cli.parse({ "test", "--benchmark-samples=200" }));
|
||||
|
||||
REQUIRE(config.benchmarkSamples == 200);
|
||||
}
|
||||
|
||||
SECTION("resamples") {
|
||||
CHECK(cli.parse({ "test", "--benchmark-resamples=20000" }));
|
||||
|
||||
REQUIRE(config.benchmarkResamples == 20000);
|
||||
}
|
||||
|
||||
SECTION("confidence-interval") {
|
||||
CHECK(cli.parse({ "test", "--benchmark-confidence-interval=0.99" }));
|
||||
|
||||
REQUIRE(config.benchmarkConfidenceInterval == Catch::Approx(0.99));
|
||||
}
|
||||
|
||||
SECTION("no-analysis") {
|
||||
CHECK(cli.parse({ "test", "--benchmark-no-analysis" }));
|
||||
|
||||
REQUIRE(config.benchmarkNoAnalysis);
|
||||
}
|
||||
|
||||
SECTION("warmup-time") {
|
||||
CHECK(cli.parse({ "test", "--benchmark-warmup-time=10" }));
|
||||
|
||||
REQUIRE(config.benchmarkWarmupTime == 10);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("Parsing sharding-related cli flags", "[sharding]") {
|
||||
using namespace Catch::Matchers;
|
||||
|
||||
Catch::ConfigData config;
|
||||
auto cli = Catch::makeCommandLineParser(config);
|
||||
|
||||
SECTION("shard-count") {
|
||||
CHECK(cli.parse({ "test", "--shard-count=8" }));
|
||||
|
||||
REQUIRE(config.shardCount == 8);
|
||||
}
|
||||
|
||||
SECTION("Negative shard count reports error") {
|
||||
auto result = cli.parse({ "test", "--shard-count=-1" });
|
||||
|
||||
CHECK_FALSE(result);
|
||||
REQUIRE_THAT(
|
||||
result.errorMessage(),
|
||||
ContainsSubstring( "Could not parse '-1' as shard count" ) );
|
||||
}
|
||||
|
||||
SECTION("Zero shard count reports error") {
|
||||
auto result = cli.parse({ "test", "--shard-count=0" });
|
||||
|
||||
CHECK_FALSE(result);
|
||||
REQUIRE_THAT(
|
||||
result.errorMessage(),
|
||||
ContainsSubstring( "Shard count must be positive" ) );
|
||||
}
|
||||
|
||||
SECTION("shard-index") {
|
||||
CHECK(cli.parse({ "test", "--shard-index=2" }));
|
||||
|
||||
REQUIRE(config.shardIndex == 2);
|
||||
}
|
||||
|
||||
SECTION("Negative shard index reports error") {
|
||||
auto result = cli.parse({ "test", "--shard-index=-12" });
|
||||
|
||||
CHECK_FALSE(result);
|
||||
REQUIRE_THAT(
|
||||
result.errorMessage(),
|
||||
ContainsSubstring( "Could not parse '-12' as shard index" ) );
|
||||
}
|
||||
|
||||
SECTION("Shard index 0 is accepted") {
|
||||
CHECK(cli.parse({ "test", "--shard-index=0" }));
|
||||
|
||||
REQUIRE(config.shardIndex == 0);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "Parsing warnings", "[cli][warnings]" ) {
|
||||
using Catch::WarnAbout;
|
||||
|
||||
Catch::ConfigData config;
|
||||
auto cli = Catch::makeCommandLineParser( config );
|
||||
|
||||
SECTION( "NoAssertions" ) {
|
||||
REQUIRE(cli.parse( { "test", "-w", "NoAssertions" } ));
|
||||
REQUIRE( config.warnings == WarnAbout::NoAssertions );
|
||||
}
|
||||
SECTION( "NoTests is no longer supported" ) {
|
||||
REQUIRE_FALSE(cli.parse( { "test", "-w", "NoTests" } ));
|
||||
}
|
||||
SECTION( "Combining multiple warnings" ) {
|
||||
REQUIRE( cli.parse( { "test",
|
||||
"--warn", "NoAssertions",
|
||||
"--warn", "UnmatchedTestSpec" } ) );
|
||||
|
||||
REQUIRE( config.warnings == ( WarnAbout::NoAssertions | WarnAbout::UnmatchedTestSpec ) );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("Test with special, characters \"in name", "[cli][regression]") {
|
||||
// This test case succeeds if we can invoke it from the CLI
|
||||
SUCCEED();
|
||||
}
|
||||
|
||||
TEST_CASE("Various suspicious reporter specs are rejected",
|
||||
"[cli][reporter-spec][approvals]") {
|
||||
Catch::ConfigData config;
|
||||
auto cli = Catch::makeCommandLineParser( config );
|
||||
|
||||
auto spec = GENERATE( as<std::string>{},
|
||||
"",
|
||||
"::console",
|
||||
"console::",
|
||||
"console::some-file::",
|
||||
"::console::some-file::" );
|
||||
CAPTURE( spec );
|
||||
|
||||
auto result = cli.parse( { "test", "--reporter", spec } );
|
||||
REQUIRE_FALSE( result );
|
||||
}
|
||||
|
||||
TEST_CASE("Win32 colour implementation is compile-time optional",
|
||||
"[approvals][cli][colours]") {
|
||||
Catch::ConfigData config;
|
||||
auto cli = Catch::makeCommandLineParser( config );
|
||||
|
||||
auto result = cli.parse( { "test", "--colour-mode", "win32" } );
|
||||
|
||||
#if defined( CATCH_CONFIG_COLOUR_WIN32 )
|
||||
REQUIRE( result );
|
||||
#else
|
||||
REQUIRE_FALSE( result );
|
||||
#endif
|
||||
}
|
||||
|
||||
TEST_CASE( "Parse rng seed in different formats", "[approvals][cli][rng-seed]" ) {
|
||||
Catch::ConfigData config;
|
||||
auto cli = Catch::makeCommandLineParser( config );
|
||||
|
||||
SECTION("well formed cases") {
|
||||
char const* seed_string;
|
||||
uint32_t seed_value;
|
||||
// GCC-5 workaround
|
||||
using gen_type = std::tuple<char const*, uint32_t>;
|
||||
std::tie( seed_string, seed_value ) = GENERATE( table<char const*, uint32_t>({
|
||||
gen_type{ "0xBEEF", 0xBEEF },
|
||||
gen_type{ "12345678", 12345678 }
|
||||
} ) );
|
||||
CAPTURE( seed_string );
|
||||
|
||||
auto result = cli.parse( { "tests", "--rng-seed", seed_string } );
|
||||
|
||||
REQUIRE( result );
|
||||
REQUIRE( config.rngSeed == seed_value );
|
||||
}
|
||||
SECTION( "Error cases" ) {
|
||||
auto seed_string =
|
||||
GENERATE( "0xSEED", "999999999999", "08888", "BEEF", "123 456" );
|
||||
CAPTURE( seed_string );
|
||||
REQUIRE_FALSE( cli.parse( { "tests", "--rng-seed", seed_string } ) );
|
||||
}
|
||||
}
|
||||
111
externals/catch2/tests/SelfTest/IntrospectiveTests/CmdLineHelpers.tests.cpp
vendored
Normal file
111
externals/catch2/tests/SelfTest/IntrospectiveTests/CmdLineHelpers.tests.cpp
vendored
Normal file
@@ -0,0 +1,111 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/internal/catch_reporter_spec_parser.hpp>
|
||||
#include <catch2/matchers/catch_matchers_vector.hpp>
|
||||
#include <catch2/interfaces/catch_interfaces_config.hpp>
|
||||
|
||||
TEST_CASE("Reporter spec splitting", "[reporter-spec][cli][approvals]") {
|
||||
using Catch::Detail::splitReporterSpec;
|
||||
using Catch::Matchers::Equals;
|
||||
using namespace std::string_literals;
|
||||
|
||||
SECTION("Various edge cases") {
|
||||
REQUIRE_THAT( splitReporterSpec( "" ),
|
||||
Equals( std::vector<std::string>{ ""s } ) );
|
||||
REQUIRE_THAT( splitReporterSpec( "::" ),
|
||||
Equals( std::vector<std::string>{ "", "" } ) );
|
||||
REQUIRE_THAT( splitReporterSpec( "::rep" ),
|
||||
Equals( std::vector<std::string>{ "", "rep" } ) );
|
||||
REQUIRE_THAT( splitReporterSpec( "rep::" ),
|
||||
Equals( std::vector<std::string>{ "rep", "" } ) );
|
||||
|
||||
}
|
||||
|
||||
SECTION("Validish specs") {
|
||||
REQUIRE_THAT( splitReporterSpec( "newReporter" ),
|
||||
Equals( std::vector<std::string>{ "newReporter"s } ) );
|
||||
REQUIRE_THAT(
|
||||
splitReporterSpec( "foo-reporter::key1=value1::key2=value with "
|
||||
"space::key with space=some-value" ),
|
||||
Equals(
|
||||
std::vector<std::string>{ "foo-reporter"s,
|
||||
"key1=value1"s,
|
||||
"key2=value with space"s,
|
||||
"key with space=some-value"s } ) );
|
||||
REQUIRE_THAT(
|
||||
splitReporterSpec( "spaced reporter name::key:key=value:value" ),
|
||||
Equals( std::vector<std::string>{ "spaced reporter name"s,
|
||||
"key:key=value:value"s } ) );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "Parsing colour mode", "[cli][colour][approvals]" ) {
|
||||
using Catch::Detail::stringToColourMode;
|
||||
using Catch::ColourMode;
|
||||
SECTION("Valid strings") {
|
||||
REQUIRE( stringToColourMode( "none" ) == ColourMode::None );
|
||||
REQUIRE( stringToColourMode( "ansi" ) == ColourMode::ANSI );
|
||||
REQUIRE( stringToColourMode( "win32" ) == ColourMode::Win32 );
|
||||
REQUIRE( stringToColourMode( "default" ) ==
|
||||
ColourMode::PlatformDefault );
|
||||
}
|
||||
SECTION("Wrong strings") {
|
||||
REQUIRE_FALSE( stringToColourMode( "NONE" ) );
|
||||
REQUIRE_FALSE( stringToColourMode( "-" ) );
|
||||
REQUIRE_FALSE( stringToColourMode( "asdbjsdb kasbd" ) );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
TEST_CASE("Parsing reporter specs", "[cli][reporter-spec][approvals]") {
|
||||
using Catch::parseReporterSpec;
|
||||
using Catch::ReporterSpec;
|
||||
using namespace std::string_literals;
|
||||
|
||||
SECTION( "Correct specs" ) {
|
||||
REQUIRE( parseReporterSpec( "someReporter" ) ==
|
||||
ReporterSpec( "someReporter"s, {}, {}, {} ) );
|
||||
REQUIRE( parseReporterSpec( "otherReporter::Xk=v::out=c:\\blah" ) ==
|
||||
ReporterSpec(
|
||||
"otherReporter"s, "c:\\blah"s, {}, { { "Xk"s, "v"s } } ) );
|
||||
REQUIRE( parseReporterSpec( "diffReporter::Xk1=v1::Xk2==v2" ) ==
|
||||
ReporterSpec( "diffReporter",
|
||||
{},
|
||||
{},
|
||||
{ { "Xk1"s, "v1"s }, { "Xk2"s, "=v2"s } } ) );
|
||||
REQUIRE( parseReporterSpec(
|
||||
"Foo:bar:reporter::colour-mode=ansi::Xk 1=v 1::Xk2=v:3" ) ==
|
||||
ReporterSpec( "Foo:bar:reporter",
|
||||
{},
|
||||
Catch::ColourMode::ANSI,
|
||||
{ { "Xk 1"s, "v 1"s }, { "Xk2"s, "v:3"s } } ) );
|
||||
}
|
||||
|
||||
SECTION( "Bad specs" ) {
|
||||
REQUIRE_FALSE( parseReporterSpec( "::" ) );
|
||||
// Unknown Catch2 arg (should be "out")
|
||||
REQUIRE_FALSE( parseReporterSpec( "reporter::output=filename" ) );
|
||||
// Wrong colour spec
|
||||
REQUIRE_FALSE( parseReporterSpec( "reporter::colour-mode=custom" ) );
|
||||
// Duplicated colour spec
|
||||
REQUIRE_FALSE( parseReporterSpec( "reporter::colour-mode=ansi::colour-mode=ansi" ) );
|
||||
// Duplicated out arg
|
||||
REQUIRE_FALSE( parseReporterSpec( "reporter::out=f.txt::out=z.txt" ) );
|
||||
// Duplicated custom arg
|
||||
REQUIRE_FALSE( parseReporterSpec( "reporter::Xa=foo::Xa=bar" ) );
|
||||
// Empty key
|
||||
REQUIRE_FALSE( parseReporterSpec( "reporter::X=foo" ) );
|
||||
REQUIRE_FALSE( parseReporterSpec( "reporter::=foo" ) );
|
||||
// Empty value
|
||||
REQUIRE_FALSE( parseReporterSpec( "reporter::Xa=" ) );
|
||||
// non-key value later field
|
||||
REQUIRE_FALSE( parseReporterSpec( "reporter::Xab" ) );
|
||||
}
|
||||
}
|
||||
64
externals/catch2/tests/SelfTest/IntrospectiveTests/ColourImpl.tests.cpp
vendored
Normal file
64
externals/catch2/tests/SelfTest/IntrospectiveTests/ColourImpl.tests.cpp
vendored
Normal file
@@ -0,0 +1,64 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/internal/catch_console_colour.hpp>
|
||||
#include <catch2/internal/catch_istream.hpp>
|
||||
|
||||
#include <sstream>
|
||||
|
||||
namespace {
|
||||
class TestColourImpl : public Catch::ColourImpl {
|
||||
using Catch::ColourImpl::ColourImpl;
|
||||
// Inherited via ColourImpl
|
||||
void use( Catch::Colour::Code colourCode ) const override {
|
||||
m_stream->stream() << "Using code: " << colourCode << '\n';
|
||||
}
|
||||
};
|
||||
|
||||
class TestStringStream : public Catch::IStream {
|
||||
std::stringstream m_stream;
|
||||
public:
|
||||
std::ostream& stream() override {
|
||||
return m_stream;
|
||||
}
|
||||
|
||||
std::string str() const { return m_stream.str(); }
|
||||
};
|
||||
}
|
||||
|
||||
TEST_CASE("ColourGuard behaviour", "[console-colours]") {
|
||||
TestStringStream streamWrapper;
|
||||
TestColourImpl colourImpl( &streamWrapper );
|
||||
auto& stream = streamWrapper.stream();
|
||||
|
||||
SECTION("ColourGuard is disengaged by default") {
|
||||
{ auto guard = colourImpl.guardColour( Catch::Colour::Red ); }
|
||||
|
||||
REQUIRE( streamWrapper.str().empty() );
|
||||
}
|
||||
|
||||
SECTION("ColourGuard is engaged by op<<") {
|
||||
stream << "1\n" << colourImpl.guardColour( Catch::Colour::Red ) << "2\n";
|
||||
stream << "3\n";
|
||||
|
||||
REQUIRE( streamWrapper.str() == "1\nUsing code: 2\n2\nUsing code: 0\n3\n" );
|
||||
}
|
||||
|
||||
SECTION("ColourGuard can be engaged explicitly") {
|
||||
{
|
||||
auto guard =
|
||||
colourImpl.guardColour( Catch::Colour::Red ).engage( stream );
|
||||
stream << "A\n"
|
||||
<< "B\n";
|
||||
}
|
||||
stream << "C\n";
|
||||
REQUIRE( streamWrapper.str() ==
|
||||
"Using code: 2\nA\nB\nUsing code: 0\nC\n" );
|
||||
}
|
||||
}
|
||||
131
externals/catch2/tests/SelfTest/IntrospectiveTests/Details.tests.cpp
vendored
Normal file
131
externals/catch2/tests/SelfTest/IntrospectiveTests/Details.tests.cpp
vendored
Normal file
@@ -0,0 +1,131 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/internal/catch_enforce.hpp>
|
||||
#include <catch2/internal/catch_case_insensitive_comparisons.hpp>
|
||||
#include <catch2/internal/catch_optional.hpp>
|
||||
|
||||
#include <helpers/type_with_lit_0_comparisons.hpp>
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable:4702) // unreachable code in the macro expansions
|
||||
#endif
|
||||
|
||||
TEST_CASE("Check that our error handling macros throw the right exceptions", "[!throws][internals][approvals]") {
|
||||
REQUIRE_THROWS_AS(CATCH_INTERNAL_ERROR(""), std::logic_error);
|
||||
REQUIRE_THROWS_AS(CATCH_ERROR(""), std::domain_error);
|
||||
REQUIRE_THROWS_AS(CATCH_RUNTIME_ERROR(""), std::runtime_error);
|
||||
REQUIRE_THROWS_AS([](){CATCH_ENFORCE(false, "");}(), std::domain_error);
|
||||
REQUIRE_NOTHROW([](){CATCH_ENFORCE(true, "");}());
|
||||
}
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#pragma warning(pop) // unreachable code in the macro expansions
|
||||
#endif
|
||||
|
||||
TEST_CASE("CaseInsensitiveLess is case insensitive", "[comparisons][string-case]") {
|
||||
Catch::Detail::CaseInsensitiveLess lt;
|
||||
SECTION( "Degenerate cases" ) {
|
||||
REQUIRE( lt( "", "a" ) );
|
||||
REQUIRE_FALSE( lt( "a", "a" ) );
|
||||
REQUIRE_FALSE( lt( "", "" ) );
|
||||
}
|
||||
SECTION("Plain comparisons") {
|
||||
REQUIRE( lt( "a", "b" ) );
|
||||
REQUIRE( lt( "a", "B" ) );
|
||||
REQUIRE( lt( "A", "b" ) );
|
||||
REQUIRE( lt( "A", "B" ) );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "CaseInsensitiveEqualsTo is case insensitive",
|
||||
"[comparisons][string-case]" ) {
|
||||
Catch::Detail::CaseInsensitiveEqualTo eq;
|
||||
SECTION( "Degenerate cases" ) {
|
||||
REQUIRE( eq( "", "" ) );
|
||||
REQUIRE_FALSE( eq( "", "a" ) );
|
||||
}
|
||||
SECTION( "Plain comparisons" ) {
|
||||
REQUIRE( eq( "a", "a" ) );
|
||||
REQUIRE( eq( "a", "A" ) );
|
||||
REQUIRE( eq( "A", "a" ) );
|
||||
REQUIRE( eq( "A", "A" ) );
|
||||
REQUIRE_FALSE( eq( "a", "b" ) );
|
||||
REQUIRE_FALSE( eq( "a", "B" ) );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("Optional comparison ops", "[optional][approvals]") {
|
||||
using Catch::Optional;
|
||||
|
||||
Optional<int> a, b;
|
||||
|
||||
SECTION( "Empty optionals are equal" ) {
|
||||
REQUIRE( a == b );
|
||||
REQUIRE_FALSE( a != b );
|
||||
}
|
||||
SECTION( "Empty and non-empty optionals are never equal" ) {
|
||||
a = 1;
|
||||
REQUIRE_FALSE( a == b );
|
||||
REQUIRE( a != b );
|
||||
}
|
||||
SECTION(
|
||||
"non-empty optionals are equal if the contained elements are equal") {
|
||||
a = 1;
|
||||
b = 2;
|
||||
REQUIRE( a != b );
|
||||
REQUIRE_FALSE( a == b );
|
||||
|
||||
a = 2;
|
||||
REQUIRE( a == b );
|
||||
REQUIRE_FALSE( a != b );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "Decomposer checks that the argument is 0 when handling "
|
||||
"only-0-comparable types",
|
||||
"[decomposition][approvals]" ) {
|
||||
TypeWithLit0Comparisons t{};
|
||||
|
||||
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
|
||||
CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
|
||||
|
||||
REQUIRE_THROWS( Catch::Decomposer{} <= t == 42 );
|
||||
REQUIRE_THROWS( Catch::Decomposer{} <= 42 == t );
|
||||
REQUIRE_NOTHROW( Catch::Decomposer{} <= t == 0 );
|
||||
REQUIRE_NOTHROW( Catch::Decomposer{} <= 0 == t );
|
||||
|
||||
REQUIRE_THROWS( Catch::Decomposer{} <= t != 42 );
|
||||
REQUIRE_THROWS( Catch::Decomposer{} <= 42 != t );
|
||||
REQUIRE_NOTHROW( Catch::Decomposer{} <= t != 0 );
|
||||
REQUIRE_NOTHROW( Catch::Decomposer{} <= 0 != t );
|
||||
|
||||
REQUIRE_THROWS( Catch::Decomposer{} <= t < 42 );
|
||||
REQUIRE_THROWS( Catch::Decomposer{} <= 42 < t );
|
||||
REQUIRE_NOTHROW( Catch::Decomposer{} <= t < 0 );
|
||||
REQUIRE_NOTHROW( Catch::Decomposer{} <= 0 < t );
|
||||
|
||||
REQUIRE_THROWS( Catch::Decomposer{} <= t <= 42 );
|
||||
REQUIRE_THROWS( Catch::Decomposer{} <= 42 <= t );
|
||||
REQUIRE_NOTHROW( Catch::Decomposer{} <= t <= 0 );
|
||||
REQUIRE_NOTHROW( Catch::Decomposer{} <= 0 <= t );
|
||||
|
||||
REQUIRE_THROWS( Catch::Decomposer{} <= t > 42 );
|
||||
REQUIRE_THROWS( Catch::Decomposer{} <= 42 > t );
|
||||
REQUIRE_NOTHROW( Catch::Decomposer{} <= t > 0 );
|
||||
REQUIRE_NOTHROW( Catch::Decomposer{} <= 0 > t );
|
||||
|
||||
REQUIRE_THROWS( Catch::Decomposer{} <= t >= 42 );
|
||||
REQUIRE_THROWS( Catch::Decomposer{} <= 42 >= t );
|
||||
REQUIRE_NOTHROW( Catch::Decomposer{} <= t >= 0 );
|
||||
REQUIRE_NOTHROW( Catch::Decomposer{} <= 0 >= t );
|
||||
|
||||
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
|
||||
}
|
||||
74
externals/catch2/tests/SelfTest/IntrospectiveTests/FloatingPoint.tests.cpp
vendored
Normal file
74
externals/catch2/tests/SelfTest/IntrospectiveTests/FloatingPoint.tests.cpp
vendored
Normal file
@@ -0,0 +1,74 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/catch_template_test_macros.hpp>
|
||||
#include <catch2/internal/catch_floating_point_helpers.hpp>
|
||||
|
||||
|
||||
TEST_CASE("convertToBits", "[floating-point][conversion]") {
|
||||
using Catch::Detail::convertToBits;
|
||||
|
||||
CHECK( convertToBits( 0.f ) == 0 );
|
||||
CHECK( convertToBits( -0.f ) == ( 1ULL << 31 ) );
|
||||
CHECK( convertToBits( 0. ) == 0 );
|
||||
CHECK( convertToBits( -0. ) == ( 1ULL << 63 ) );
|
||||
CHECK( convertToBits( std::numeric_limits<float>::denorm_min() ) == 1 );
|
||||
CHECK( convertToBits( std::numeric_limits<double>::denorm_min() ) == 1 );
|
||||
}
|
||||
|
||||
TEMPLATE_TEST_CASE("type-shared ulpDistance tests", "[floating-point][ulp][approvals]", float, double) {
|
||||
using FP = TestType;
|
||||
using Catch::ulpDistance;
|
||||
|
||||
// Distance between zeros is zero
|
||||
CHECK( ulpDistance( FP{}, FP{} ) == 0 );
|
||||
CHECK( ulpDistance( FP{}, -FP{} ) == 0 );
|
||||
CHECK( ulpDistance( -FP{}, -FP{} ) == 0 );
|
||||
|
||||
// Distance between same-sign infinities is zero
|
||||
static constexpr FP infinity = std::numeric_limits<FP>::infinity();
|
||||
CHECK( ulpDistance( infinity, infinity ) == 0 );
|
||||
CHECK( ulpDistance( -infinity, -infinity ) == 0 );
|
||||
|
||||
// Distance between max-finite-val and same sign infinity is 1
|
||||
static constexpr FP max_finite = std::numeric_limits<FP>::max();
|
||||
CHECK( ulpDistance( max_finite, infinity ) == 1 );
|
||||
CHECK( ulpDistance( -max_finite, -infinity ) == 1 );
|
||||
|
||||
// Distance between X and 0 is half of distance between X and -X
|
||||
CHECK( ulpDistance( -infinity, infinity ) ==
|
||||
2 * ulpDistance( infinity, FP{} ) );
|
||||
CHECK( 2 * ulpDistance( FP{ -2. }, FP{} ) ==
|
||||
ulpDistance( FP{ -2. }, FP{ 2. } ) );
|
||||
CHECK( 2 * ulpDistance( FP{ 2. }, FP{} ) ==
|
||||
ulpDistance( FP{ -2. }, FP{ 2. } ) );
|
||||
|
||||
// Denorms are supported
|
||||
CHECK( ulpDistance( std::numeric_limits<FP>::denorm_min(), FP{} ) == 1 );
|
||||
CHECK( ulpDistance( std::numeric_limits<FP>::denorm_min(), -FP{} ) == 1 );
|
||||
CHECK( ulpDistance( -std::numeric_limits<FP>::denorm_min(), FP{} ) == 1 );
|
||||
CHECK( ulpDistance( -std::numeric_limits<FP>::denorm_min(), -FP{} ) == 1 );
|
||||
CHECK( ulpDistance( std::numeric_limits<FP>::denorm_min(),
|
||||
-std::numeric_limits<FP>::denorm_min() ) == 2 );
|
||||
|
||||
// Machine epsilon
|
||||
CHECK( ulpDistance( FP{ 1. },
|
||||
FP{ 1. } + std::numeric_limits<FP>::epsilon() ) == 1 );
|
||||
CHECK( ulpDistance( -FP{ 1. },
|
||||
-FP{ 1. } - std::numeric_limits<FP>::epsilon() ) == 1 );
|
||||
}
|
||||
|
||||
TEST_CASE("UlpDistance", "[floating-point][ulp][approvals]") {
|
||||
using Catch::ulpDistance;
|
||||
|
||||
CHECK( ulpDistance( 1., 2. ) == 0x10'00'00'00'00'00'00 );
|
||||
CHECK( ulpDistance( -2., 2. ) == 0x80'00'00'00'00'00'00'00 );
|
||||
CHECK( ulpDistance( 1.f, 2.f ) == 0x80'00'00 );
|
||||
CHECK( ulpDistance( -2.f, 2.f ) == 0x80'00'00'00 );
|
||||
}
|
||||
546
externals/catch2/tests/SelfTest/IntrospectiveTests/GeneratorsImpl.tests.cpp
vendored
Normal file
546
externals/catch2/tests/SelfTest/IntrospectiveTests/GeneratorsImpl.tests.cpp
vendored
Normal file
@@ -0,0 +1,546 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#if defined( __GNUC__ ) || defined( __clang__ )
|
||||
# pragma GCC diagnostic ignored "-Wfloat-equal"
|
||||
#endif
|
||||
|
||||
#include <catch2/catch_approx.hpp>
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/generators/catch_generator_exception.hpp>
|
||||
#include <catch2/generators/catch_generators_adapters.hpp>
|
||||
#include <catch2/generators/catch_generators_random.hpp>
|
||||
#include <catch2/generators/catch_generators_range.hpp>
|
||||
#include <catch2/generators/catch_generator_exception.hpp>
|
||||
|
||||
// Tests of generator implementation details
|
||||
TEST_CASE("Generators internals", "[generators][internals]") {
|
||||
using namespace Catch::Generators;
|
||||
|
||||
SECTION("Single value") {
|
||||
auto gen = value(123);
|
||||
REQUIRE(gen.get() == 123);
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
SECTION("Preset values") {
|
||||
auto gen = values({ 1, 3, 5 });
|
||||
REQUIRE(gen.get() == 1);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 3);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 5);
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
SECTION("Generator combinator") {
|
||||
auto gen = makeGenerators(1, 5, values({ 2, 4 }), 0);
|
||||
REQUIRE(gen.get() == 1);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 5);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 2);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 4);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 0);
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
SECTION("Explicitly typed generator sequence") {
|
||||
auto gen = makeGenerators(as<std::string>{}, "aa", "bb", "cc");
|
||||
// This just checks that the type is std::string:
|
||||
REQUIRE(gen.get().size() == 2);
|
||||
// Iterate over the generator
|
||||
REQUIRE(gen.get() == "aa");
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == "bb");
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == "cc");
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
SECTION("Filter generator") {
|
||||
// Normal usage
|
||||
SECTION("Simple filtering") {
|
||||
auto gen = filter([](int i) { return i != 2; }, values({ 2, 1, 2, 3, 2, 2 }));
|
||||
REQUIRE(gen.get() == 1);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 3);
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
SECTION("Filter out multiple elements at the start and end") {
|
||||
auto gen = filter([](int i) { return i != 2; }, values({ 2, 2, 1, 3, 2, 2 }));
|
||||
REQUIRE(gen.get() == 1);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 3);
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
|
||||
SECTION("Throws on construction if it can't get initial element") {
|
||||
REQUIRE_THROWS_AS(filter([](int) { return false; }, value(1)), Catch::GeneratorException);
|
||||
REQUIRE_THROWS_AS(
|
||||
filter([](int) { return false; }, values({ 1, 2, 3 })),
|
||||
Catch::GeneratorException);
|
||||
}
|
||||
}
|
||||
SECTION("Take generator") {
|
||||
SECTION("Take less") {
|
||||
auto gen = take(2, values({ 1, 2, 3 }));
|
||||
REQUIRE(gen.get() == 1);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 2);
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
SECTION("Take more") {
|
||||
auto gen = take(2, value(1));
|
||||
REQUIRE(gen.get() == 1);
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
}
|
||||
SECTION("Map with explicit return type") {
|
||||
auto gen = map<double>([] (int i) {return 2.0 * i; }, values({ 1, 2, 3 }));
|
||||
REQUIRE(gen.get() == 2.0);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 4.0);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 6.0);
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
SECTION("Map with deduced return type") {
|
||||
auto gen = map([] (int i) {return 2.0 * i; }, values({ 1, 2, 3 }));
|
||||
REQUIRE(gen.get() == 2.0);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 4.0);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 6.0);
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
SECTION("Repeat") {
|
||||
SECTION("Singular repeat") {
|
||||
auto gen = repeat(1, value(3));
|
||||
REQUIRE(gen.get() == 3);
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
SECTION("Actual repeat") {
|
||||
auto gen = repeat(2, values({ 1, 2, 3 }));
|
||||
REQUIRE(gen.get() == 1);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 2);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 3);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 1);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 2);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 3);
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
}
|
||||
SECTION("Range") {
|
||||
SECTION("Positive auto step") {
|
||||
SECTION("Integer") {
|
||||
auto gen = range(-2, 2);
|
||||
REQUIRE(gen.get() == -2);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == -1);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 0);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 1);
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
}
|
||||
SECTION("Negative auto step") {
|
||||
SECTION("Integer") {
|
||||
auto gen = range(2, -2);
|
||||
REQUIRE(gen.get() == 2);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 1);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 0);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == -1);
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
}
|
||||
SECTION("Positive manual step") {
|
||||
SECTION("Integer") {
|
||||
SECTION("Exact") {
|
||||
auto gen = range(-7, 5, 3);
|
||||
REQUIRE(gen.get() == -7);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == -4);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == -1);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 2);
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
SECTION("Slightly over end") {
|
||||
auto gen = range(-7, 4, 3);
|
||||
REQUIRE(gen.get() == -7);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == -4);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == -1);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 2);
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
SECTION("Slightly under end") {
|
||||
auto gen = range(-7, 6, 3);
|
||||
REQUIRE(gen.get() == -7);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == -4);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == -1);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 2);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 5);
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
}
|
||||
|
||||
SECTION("Floating Point") {
|
||||
using Catch::Approx;
|
||||
SECTION("Exact") {
|
||||
const auto rangeStart = -1.;
|
||||
const auto rangeEnd = 1.;
|
||||
const auto step = .1;
|
||||
|
||||
auto gen = range(rangeStart, rangeEnd, step);
|
||||
auto expected = rangeStart;
|
||||
while( (rangeEnd - expected) > step ) {
|
||||
INFO( "Current expected value is " << expected );
|
||||
REQUIRE(gen.get() == Approx(expected));
|
||||
REQUIRE(gen.next());
|
||||
|
||||
expected += step;
|
||||
}
|
||||
REQUIRE(gen.get() == Approx( rangeEnd ) );
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
SECTION("Slightly over end") {
|
||||
const auto rangeStart = -1.;
|
||||
const auto rangeEnd = 1.;
|
||||
const auto step = .3;
|
||||
|
||||
auto gen = range(rangeStart, rangeEnd, step);
|
||||
auto expected = rangeStart;
|
||||
while( (rangeEnd - expected) > step ) {
|
||||
INFO( "Current expected value is " << expected );
|
||||
REQUIRE(gen.get() == Approx(expected));
|
||||
REQUIRE(gen.next());
|
||||
|
||||
expected += step;
|
||||
}
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
SECTION("Slightly under end") {
|
||||
const auto rangeStart = -1.;
|
||||
const auto rangeEnd = .9;
|
||||
const auto step = .3;
|
||||
|
||||
auto gen = range(rangeStart, rangeEnd, step);
|
||||
auto expected = rangeStart;
|
||||
while( (rangeEnd - expected) > step ) {
|
||||
INFO( "Current expected value is " << expected );
|
||||
REQUIRE(gen.get() == Approx(expected));
|
||||
REQUIRE(gen.next());
|
||||
|
||||
expected += step;
|
||||
}
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
}
|
||||
}
|
||||
SECTION("Negative manual step") {
|
||||
SECTION("Integer") {
|
||||
SECTION("Exact") {
|
||||
auto gen = range(5, -7, -3);
|
||||
REQUIRE(gen.get() == 5);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 2);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == -1);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == -4);
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
SECTION("Slightly over end") {
|
||||
auto gen = range(5, -6, -3);
|
||||
REQUIRE(gen.get() == 5);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 2);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == -1);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == -4);
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
SECTION("Slightly under end") {
|
||||
auto gen = range(5, -8, -3);
|
||||
REQUIRE(gen.get() == 5);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == 2);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == -1);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == -4);
|
||||
REQUIRE(gen.next());
|
||||
REQUIRE(gen.get() == -7);
|
||||
REQUIRE_FALSE(gen.next());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
// todo: uncopyable type used in a generator
|
||||
// idea: uncopyable tag type for a stupid generator
|
||||
|
||||
namespace {
|
||||
struct non_copyable {
|
||||
non_copyable() = default;
|
||||
non_copyable(non_copyable const&) = delete;
|
||||
non_copyable& operator=(non_copyable const&) = delete;
|
||||
int value = -1;
|
||||
};
|
||||
|
||||
// This class shows how to implement a simple generator for Catch tests
|
||||
class TestGen : public Catch::Generators::IGenerator<int> {
|
||||
int current_number;
|
||||
public:
|
||||
|
||||
TestGen(non_copyable const& nc):
|
||||
current_number(nc.value) {}
|
||||
|
||||
int const& get() const override;
|
||||
bool next() override {
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
// Avoids -Wweak-vtables
|
||||
int const& TestGen::get() const {
|
||||
return current_number;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
TEST_CASE("GENERATE capture macros", "[generators][internals][approvals]") {
|
||||
auto value = GENERATE(take(10, random(0, 10)));
|
||||
|
||||
non_copyable nc; nc.value = value;
|
||||
// neither `GENERATE_COPY` nor plain `GENERATE` would compile here
|
||||
auto value2 = GENERATE_REF(Catch::Generators::GeneratorWrapper<int>(Catch::Detail::make_unique<TestGen>(nc)));
|
||||
REQUIRE(value == value2);
|
||||
}
|
||||
|
||||
TEST_CASE("#1809 - GENERATE_COPY and SingleValueGenerator does not compile", "[generators][compilation][approvals]") {
|
||||
// Verify Issue #1809 fix, only needs to compile.
|
||||
auto a = GENERATE_COPY(1, 2);
|
||||
(void)a;
|
||||
auto b = GENERATE_COPY(as<long>{}, 1, 2);
|
||||
(void)b;
|
||||
int i = 1;
|
||||
int j = 2;
|
||||
auto c = GENERATE_COPY(i, j);
|
||||
(void)c;
|
||||
auto d = GENERATE_COPY(as<long>{}, i, j);
|
||||
(void)d;
|
||||
SUCCEED();
|
||||
}
|
||||
|
||||
TEST_CASE("Multiple random generators in one test case output different values", "[generators][internals][approvals]") {
|
||||
SECTION("Integer") {
|
||||
auto random1 = Catch::Generators::random(0, 1000);
|
||||
auto random2 = Catch::Generators::random(0, 1000);
|
||||
size_t same = 0;
|
||||
for (size_t i = 0; i < 1000; ++i) {
|
||||
same += random1.get() == random2.get();
|
||||
random1.next(); random2.next();
|
||||
}
|
||||
// Because the previous low bound failed CI couple of times,
|
||||
// we use a very high threshold of 20% before failure is reported.
|
||||
REQUIRE(same < 200);
|
||||
}
|
||||
SECTION("Float") {
|
||||
auto random1 = Catch::Generators::random(0., 1000.);
|
||||
auto random2 = Catch::Generators::random(0., 1000.);
|
||||
size_t same = 0;
|
||||
for (size_t i = 0; i < 1000; ++i) {
|
||||
same += random1.get() == random2.get();
|
||||
random1.next(); random2.next();
|
||||
}
|
||||
// Because the previous low bound failed CI couple of times,
|
||||
// we use a very high threshold of 20% before failure is reported.
|
||||
REQUIRE(same < 200);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("#2040 - infinite compilation recursion in GENERATE with MSVC", "[generators][compilation][approvals]") {
|
||||
int x = 42;
|
||||
auto test = GENERATE_COPY(1, x, 2 * x);
|
||||
CHECK(test < 100);
|
||||
}
|
||||
|
||||
namespace {
|
||||
static bool always_true(int) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool is_even(int n) {
|
||||
return n % 2 == 0;
|
||||
}
|
||||
|
||||
static bool is_multiple_of_3(int n) {
|
||||
return n % 3 == 0;
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("GENERATE handles function (pointers)", "[generators][compilation][approvals]") {
|
||||
auto f = GENERATE(always_true, is_even, is_multiple_of_3);
|
||||
REQUIRE(f(6));
|
||||
}
|
||||
|
||||
TEST_CASE("GENERATE decays arrays", "[generators][compilation][approvals]") {
|
||||
auto str = GENERATE("abc", "def", "gh");
|
||||
STATIC_REQUIRE(std::is_same<decltype(str), const char*>::value);
|
||||
}
|
||||
|
||||
TEST_CASE("Generators count returned elements", "[generators][approvals]") {
|
||||
auto generator = Catch::Generators::FixedValuesGenerator<int>( { 1, 2, 3 } );
|
||||
REQUIRE( generator.currentElementIndex() == 0 );
|
||||
REQUIRE( generator.countedNext() );
|
||||
REQUIRE( generator.currentElementIndex() == 1 );
|
||||
REQUIRE( generator.countedNext() );
|
||||
REQUIRE( generator.currentElementIndex() == 2 );
|
||||
REQUIRE_FALSE( generator.countedNext() );
|
||||
REQUIRE( generator.currentElementIndex() == 2 );
|
||||
}
|
||||
|
||||
TEST_CASE( "Generators can stringify their elements",
|
||||
"[generators][approvals]" ) {
|
||||
auto generator =
|
||||
Catch::Generators::FixedValuesGenerator<int>( { 1, 2, 3 } );
|
||||
|
||||
REQUIRE( generator.currentElementAsString() == "1"_catch_sr );
|
||||
REQUIRE( generator.countedNext() );
|
||||
REQUIRE( generator.currentElementAsString() == "2"_catch_sr );
|
||||
REQUIRE( generator.countedNext() );
|
||||
REQUIRE( generator.currentElementAsString() == "3"_catch_sr );
|
||||
}
|
||||
|
||||
namespace {
|
||||
class CustomStringifyGenerator
|
||||
: public Catch::Generators::IGenerator<bool> {
|
||||
bool m_first = true;
|
||||
|
||||
std::string stringifyImpl() const override {
|
||||
return m_first ? "first" : "second";
|
||||
}
|
||||
|
||||
bool next() override {
|
||||
if ( m_first ) {
|
||||
m_first = false;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public:
|
||||
bool const& get() const override;
|
||||
};
|
||||
|
||||
// Avoids -Wweak-vtables
|
||||
bool const& CustomStringifyGenerator::get() const { return m_first; }
|
||||
} // namespace
|
||||
|
||||
TEST_CASE( "Generators can override element stringification",
|
||||
"[generators][approvals]" ) {
|
||||
CustomStringifyGenerator generator;
|
||||
REQUIRE( generator.currentElementAsString() == "first"_catch_sr );
|
||||
REQUIRE( generator.countedNext() );
|
||||
REQUIRE( generator.currentElementAsString() == "second"_catch_sr );
|
||||
}
|
||||
|
||||
namespace {
|
||||
class StringifyCountingGenerator
|
||||
: public Catch::Generators::IGenerator<bool> {
|
||||
bool m_first = true;
|
||||
mutable size_t m_stringificationCalls = 0;
|
||||
|
||||
std::string stringifyImpl() const override {
|
||||
++m_stringificationCalls;
|
||||
return m_first ? "first" : "second";
|
||||
}
|
||||
|
||||
bool next() override {
|
||||
if ( m_first ) {
|
||||
m_first = false;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
bool const& get() const override;
|
||||
size_t stringificationCalls() const { return m_stringificationCalls; }
|
||||
};
|
||||
|
||||
// Avoids -Wweak-vtables
|
||||
bool const& StringifyCountingGenerator::get() const { return m_first; }
|
||||
|
||||
} // namespace
|
||||
|
||||
TEST_CASE( "Generator element stringification is cached",
|
||||
"[generators][approvals]" ) {
|
||||
StringifyCountingGenerator generator;
|
||||
REQUIRE( generator.currentElementAsString() == "first"_catch_sr );
|
||||
REQUIRE( generator.currentElementAsString() == "first"_catch_sr );
|
||||
REQUIRE( generator.currentElementAsString() == "first"_catch_sr );
|
||||
REQUIRE( generator.currentElementAsString() == "first"_catch_sr );
|
||||
REQUIRE( generator.currentElementAsString() == "first"_catch_sr );
|
||||
|
||||
REQUIRE( generator.stringificationCalls() == 1 );
|
||||
}
|
||||
|
||||
TEST_CASE( "Random generators can be seeded", "[generators][approvals]" ) {
|
||||
SECTION( "Integer generator" ) {
|
||||
using Catch::Generators::RandomIntegerGenerator;
|
||||
RandomIntegerGenerator<int> rng1( 0, 100, 0x1234 ),
|
||||
rng2( 0, 100, 0x1234 );
|
||||
|
||||
for ( size_t i = 0; i < 10; ++i ) {
|
||||
REQUIRE( rng1.get() == rng2.get() );
|
||||
rng1.next(); rng2.next();
|
||||
}
|
||||
}
|
||||
SECTION("Float generator") {
|
||||
using Catch::Generators::RandomFloatingGenerator;
|
||||
RandomFloatingGenerator<double> rng1( 0., 100., 0x1234 ),
|
||||
rng2( 0., 100., 0x1234 );
|
||||
for ( size_t i = 0; i < 10; ++i ) {
|
||||
REQUIRE( rng1.get() == rng2.get() );
|
||||
rng1.next();
|
||||
rng2.next();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("Filter generator throws exception for empty generator",
|
||||
"[generators]") {
|
||||
using namespace Catch::Generators;
|
||||
|
||||
REQUIRE_THROWS_AS(
|
||||
filter( []( int ) { return false; }, value( 3 ) ),
|
||||
Catch::GeneratorException );
|
||||
}
|
||||
447
externals/catch2/tests/SelfTest/IntrospectiveTests/InternalBenchmark.tests.cpp
vendored
Normal file
447
externals/catch2/tests/SelfTest/IntrospectiveTests/InternalBenchmark.tests.cpp
vendored
Normal file
@@ -0,0 +1,447 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
// Adapted from donated nonius code.
|
||||
|
||||
|
||||
#if defined( __GNUC__ ) || defined( __clang__ )
|
||||
# pragma GCC diagnostic ignored "-Wfloat-equal"
|
||||
#endif
|
||||
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/catch_approx.hpp>
|
||||
#include <catch2/catch_config.hpp>
|
||||
#include <catch2/benchmark/catch_benchmark.hpp>
|
||||
#include <catch2/benchmark/catch_chronometer.hpp>
|
||||
#include <catch2/benchmark/detail/catch_analyse.hpp>
|
||||
#include <catch2/benchmark/detail/catch_benchmark_function.hpp>
|
||||
#include <catch2/benchmark/detail/catch_estimate_clock.hpp>
|
||||
|
||||
namespace {
|
||||
struct manual_clock {
|
||||
public:
|
||||
using duration = std::chrono::nanoseconds;
|
||||
using time_point = std::chrono::time_point<manual_clock, duration>;
|
||||
using rep = duration::rep;
|
||||
using period = duration::period;
|
||||
enum { is_steady = true };
|
||||
|
||||
static time_point now() {
|
||||
return time_point(duration(tick()));
|
||||
}
|
||||
|
||||
static void advance(int ticks = 1) {
|
||||
tick() += ticks;
|
||||
}
|
||||
|
||||
private:
|
||||
static rep& tick() {
|
||||
static rep the_tick = 0;
|
||||
return the_tick;
|
||||
}
|
||||
};
|
||||
|
||||
struct counting_clock {
|
||||
public:
|
||||
using duration = std::chrono::nanoseconds;
|
||||
using time_point = std::chrono::time_point<counting_clock, duration>;
|
||||
using rep = duration::rep;
|
||||
using period = duration::period;
|
||||
enum { is_steady = true };
|
||||
|
||||
static time_point now() {
|
||||
static rep ticks = 0;
|
||||
return time_point(duration(ticks += rate()));
|
||||
}
|
||||
|
||||
static void set_rate(rep new_rate) { rate() = new_rate; }
|
||||
|
||||
private:
|
||||
static rep& rate() {
|
||||
static rep the_rate = 1;
|
||||
return the_rate;
|
||||
}
|
||||
};
|
||||
|
||||
struct TestChronometerModel : Catch::Benchmark::Detail::ChronometerConcept {
|
||||
int started = 0;
|
||||
int finished = 0;
|
||||
|
||||
void start() override { ++started; }
|
||||
void finish() override { ++finished; }
|
||||
};
|
||||
} // namespace
|
||||
|
||||
TEST_CASE("warmup", "[benchmark]") {
|
||||
auto rate = 1000;
|
||||
counting_clock::set_rate(rate);
|
||||
|
||||
auto start = counting_clock::now();
|
||||
auto iterations = Catch::Benchmark::Detail::warmup<counting_clock>();
|
||||
auto end = counting_clock::now();
|
||||
|
||||
REQUIRE((iterations * rate) > Catch::Benchmark::Detail::warmup_time.count());
|
||||
REQUIRE((end - start) > Catch::Benchmark::Detail::warmup_time);
|
||||
}
|
||||
|
||||
TEST_CASE("resolution", "[benchmark]") {
|
||||
auto rate = 1000;
|
||||
counting_clock::set_rate(rate);
|
||||
|
||||
size_t count = 10;
|
||||
auto res = Catch::Benchmark::Detail::resolution<counting_clock>(static_cast<int>(count));
|
||||
|
||||
REQUIRE(res.size() == count);
|
||||
|
||||
for (size_t i = 1; i < count; ++i) {
|
||||
REQUIRE(res[i] == rate);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("estimate_clock_resolution", "[benchmark]") {
|
||||
auto rate = 2'000;
|
||||
counting_clock::set_rate(rate);
|
||||
|
||||
int iters = 160'000;
|
||||
auto res = Catch::Benchmark::Detail::estimate_clock_resolution<counting_clock>(iters);
|
||||
|
||||
REQUIRE(res.mean.count() == rate);
|
||||
REQUIRE(res.outliers.total() == 0);
|
||||
}
|
||||
|
||||
TEST_CASE("benchmark function call", "[benchmark]") {
|
||||
SECTION("without chronometer") {
|
||||
auto called = 0;
|
||||
auto model = TestChronometerModel{};
|
||||
auto meter = Catch::Benchmark::Chronometer{ model, 1 };
|
||||
auto fn = Catch::Benchmark::Detail::BenchmarkFunction{ [&] {
|
||||
CHECK(model.started == 1);
|
||||
CHECK(model.finished == 0);
|
||||
++called;
|
||||
} };
|
||||
|
||||
fn(meter);
|
||||
|
||||
CHECK(model.started == 1);
|
||||
CHECK(model.finished == 1);
|
||||
CHECK(called == 1);
|
||||
}
|
||||
|
||||
SECTION("with chronometer") {
|
||||
auto called = 0;
|
||||
auto model = TestChronometerModel{};
|
||||
auto meter = Catch::Benchmark::Chronometer{ model, 1 };
|
||||
auto fn = Catch::Benchmark::Detail::BenchmarkFunction{ [&](Catch::Benchmark::Chronometer) {
|
||||
CHECK(model.started == 0);
|
||||
CHECK(model.finished == 0);
|
||||
++called;
|
||||
} };
|
||||
|
||||
fn(meter);
|
||||
|
||||
CHECK(model.started == 0);
|
||||
CHECK(model.finished == 0);
|
||||
CHECK(called == 1);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("uniform samples", "[benchmark]") {
|
||||
std::vector<double> samples(100);
|
||||
std::fill(samples.begin(), samples.end(), 23);
|
||||
|
||||
using it = std::vector<double>::iterator;
|
||||
auto e = Catch::Benchmark::Detail::bootstrap(0.95, samples.begin(), samples.end(), samples, [](it a, it b) {
|
||||
auto sum = std::accumulate(a, b, 0.);
|
||||
return sum / (b - a);
|
||||
});
|
||||
CHECK(e.point == 23);
|
||||
CHECK(e.upper_bound == 23);
|
||||
CHECK(e.lower_bound == 23);
|
||||
CHECK(e.confidence_interval == 0.95);
|
||||
}
|
||||
|
||||
|
||||
TEST_CASE("normal_cdf", "[benchmark]") {
|
||||
using Catch::Benchmark::Detail::normal_cdf;
|
||||
using Catch::Approx;
|
||||
CHECK(normal_cdf(0.000000) == Approx(0.50000000000000000));
|
||||
CHECK(normal_cdf(1.000000) == Approx(0.84134474606854293));
|
||||
CHECK(normal_cdf(-1.000000) == Approx(0.15865525393145705));
|
||||
CHECK(normal_cdf(2.809729) == Approx(0.99752083845315409));
|
||||
CHECK(normal_cdf(-1.352570) == Approx(0.08809652095066035));
|
||||
}
|
||||
|
||||
TEST_CASE("erfc_inv", "[benchmark]") {
|
||||
using Catch::Benchmark::Detail::erfc_inv;
|
||||
using Catch::Approx;
|
||||
CHECK(erfc_inv(1.103560) == Approx(-0.09203687623843015));
|
||||
CHECK(erfc_inv(1.067400) == Approx(-0.05980291115763361));
|
||||
CHECK(erfc_inv(0.050000) == Approx(1.38590382434967796));
|
||||
}
|
||||
|
||||
TEST_CASE("normal_quantile", "[benchmark]") {
|
||||
using Catch::Benchmark::Detail::normal_quantile;
|
||||
using Catch::Approx;
|
||||
CHECK(normal_quantile(0.551780) == Approx(0.13015979861484198));
|
||||
CHECK(normal_quantile(0.533700) == Approx(0.08457408802851875));
|
||||
CHECK(normal_quantile(0.025000) == Approx(-1.95996398454005449));
|
||||
}
|
||||
|
||||
|
||||
TEST_CASE("mean", "[benchmark]") {
|
||||
std::vector<double> x{ 10., 20., 14., 16., 30., 24. };
|
||||
|
||||
auto m = Catch::Benchmark::Detail::mean(x.begin(), x.end());
|
||||
|
||||
REQUIRE(m == 19.);
|
||||
}
|
||||
|
||||
TEST_CASE("weighted_average_quantile", "[benchmark]") {
|
||||
std::vector<double> x{ 10., 20., 14., 16., 30., 24. };
|
||||
|
||||
auto q1 = Catch::Benchmark::Detail::weighted_average_quantile(1, 4, x.begin(), x.end());
|
||||
auto med = Catch::Benchmark::Detail::weighted_average_quantile(1, 2, x.begin(), x.end());
|
||||
auto q3 = Catch::Benchmark::Detail::weighted_average_quantile(3, 4, x.begin(), x.end());
|
||||
|
||||
REQUIRE(q1 == 14.5);
|
||||
REQUIRE(med == 18.);
|
||||
REQUIRE(q3 == 23.);
|
||||
}
|
||||
|
||||
TEST_CASE("classify_outliers", "[benchmark]") {
|
||||
auto require_outliers = [](Catch::Benchmark::OutlierClassification o, int los, int lom, int him, int his) {
|
||||
REQUIRE(o.low_severe == los);
|
||||
REQUIRE(o.low_mild == lom);
|
||||
REQUIRE(o.high_mild == him);
|
||||
REQUIRE(o.high_severe == his);
|
||||
REQUIRE(o.total() == los + lom + him + his);
|
||||
};
|
||||
|
||||
SECTION("none") {
|
||||
std::vector<double> x{ 10., 20., 14., 16., 30., 24. };
|
||||
|
||||
auto o = Catch::Benchmark::Detail::classify_outliers(x.begin(), x.end());
|
||||
|
||||
REQUIRE(o.samples_seen == static_cast<int>(x.size()));
|
||||
require_outliers(o, 0, 0, 0, 0);
|
||||
}
|
||||
SECTION("low severe") {
|
||||
std::vector<double> x{ -12., 20., 14., 16., 30., 24. };
|
||||
|
||||
auto o = Catch::Benchmark::Detail::classify_outliers(x.begin(), x.end());
|
||||
|
||||
REQUIRE(o.samples_seen == static_cast<int>(x.size()));
|
||||
require_outliers(o, 1, 0, 0, 0);
|
||||
}
|
||||
SECTION("low mild") {
|
||||
std::vector<double> x{ 1., 20., 14., 16., 30., 24. };
|
||||
|
||||
auto o = Catch::Benchmark::Detail::classify_outliers(x.begin(), x.end());
|
||||
|
||||
REQUIRE(o.samples_seen == static_cast<int>(x.size()));
|
||||
require_outliers(o, 0, 1, 0, 0);
|
||||
}
|
||||
SECTION("high mild") {
|
||||
std::vector<double> x{ 10., 20., 14., 16., 36., 24. };
|
||||
|
||||
auto o = Catch::Benchmark::Detail::classify_outliers(x.begin(), x.end());
|
||||
|
||||
REQUIRE(o.samples_seen == static_cast<int>(x.size()));
|
||||
require_outliers(o, 0, 0, 1, 0);
|
||||
}
|
||||
SECTION("high severe") {
|
||||
std::vector<double> x{ 10., 20., 14., 16., 49., 24. };
|
||||
|
||||
auto o = Catch::Benchmark::Detail::classify_outliers(x.begin(), x.end());
|
||||
|
||||
REQUIRE(o.samples_seen == static_cast<int>(x.size()));
|
||||
require_outliers(o, 0, 0, 0, 1);
|
||||
}
|
||||
SECTION("mixed") {
|
||||
std::vector<double> x{ -20., 20., 14., 16., 39., 24. };
|
||||
|
||||
auto o = Catch::Benchmark::Detail::classify_outliers(x.begin(), x.end());
|
||||
|
||||
REQUIRE(o.samples_seen == static_cast<int>(x.size()));
|
||||
require_outliers(o, 1, 0, 1, 0);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("analyse", "[approvals][benchmark]") {
|
||||
Catch::ConfigData data{};
|
||||
data.benchmarkConfidenceInterval = 0.95;
|
||||
data.benchmarkNoAnalysis = false;
|
||||
data.benchmarkResamples = 1000;
|
||||
data.benchmarkSamples = 99;
|
||||
Catch::Config config{data};
|
||||
|
||||
using Duration = Catch::Benchmark::FloatDuration<Catch::Benchmark::default_clock>;
|
||||
|
||||
Catch::Benchmark::Environment<Duration> env;
|
||||
std::vector<Duration> samples(99);
|
||||
for (size_t i = 0; i < samples.size(); ++i) {
|
||||
samples[i] = Duration(23 + (i % 3 - 1));
|
||||
}
|
||||
|
||||
auto analysis = Catch::Benchmark::Detail::analyse(config, env, samples.begin(), samples.end());
|
||||
CHECK( analysis.mean.point.count() == 23 );
|
||||
CHECK( analysis.mean.lower_bound.count() < 23 );
|
||||
CHECK(analysis.mean.lower_bound.count() > 22);
|
||||
CHECK(analysis.mean.upper_bound.count() > 23);
|
||||
CHECK(analysis.mean.upper_bound.count() < 24);
|
||||
|
||||
CHECK(analysis.standard_deviation.point.count() > 0.5);
|
||||
CHECK(analysis.standard_deviation.point.count() < 1);
|
||||
CHECK(analysis.standard_deviation.lower_bound.count() > 0.5);
|
||||
CHECK(analysis.standard_deviation.lower_bound.count() < 1);
|
||||
CHECK(analysis.standard_deviation.upper_bound.count() > 0.5);
|
||||
CHECK(analysis.standard_deviation.upper_bound.count() < 1);
|
||||
|
||||
CHECK(analysis.outliers.total() == 0);
|
||||
CHECK(analysis.outliers.low_mild == 0);
|
||||
CHECK(analysis.outliers.low_severe == 0);
|
||||
CHECK(analysis.outliers.high_mild == 0);
|
||||
CHECK(analysis.outliers.high_severe == 0);
|
||||
CHECK(analysis.outliers.samples_seen == static_cast<int>(samples.size()));
|
||||
|
||||
CHECK(analysis.outlier_variance < 0.5);
|
||||
CHECK(analysis.outlier_variance > 0);
|
||||
}
|
||||
|
||||
TEST_CASE("analyse no analysis", "[benchmark]") {
|
||||
Catch::ConfigData data{};
|
||||
data.benchmarkConfidenceInterval = 0.95;
|
||||
data.benchmarkNoAnalysis = true;
|
||||
data.benchmarkResamples = 1000;
|
||||
data.benchmarkSamples = 99;
|
||||
Catch::Config config{ data };
|
||||
|
||||
using Duration = Catch::Benchmark::FloatDuration<Catch::Benchmark::default_clock>;
|
||||
|
||||
Catch::Benchmark::Environment<Duration> env;
|
||||
std::vector<Duration> samples(99);
|
||||
for (size_t i = 0; i < samples.size(); ++i) {
|
||||
samples[i] = Duration(23 + (i % 3 - 1));
|
||||
}
|
||||
|
||||
auto analysis = Catch::Benchmark::Detail::analyse(config, env, samples.begin(), samples.end());
|
||||
CHECK(analysis.mean.point.count() == 23);
|
||||
CHECK(analysis.mean.lower_bound.count() == 23);
|
||||
CHECK(analysis.mean.upper_bound.count() == 23);
|
||||
|
||||
CHECK(analysis.standard_deviation.point.count() == 0);
|
||||
CHECK(analysis.standard_deviation.lower_bound.count() == 0);
|
||||
CHECK(analysis.standard_deviation.upper_bound.count() == 0);
|
||||
|
||||
CHECK(analysis.outliers.total() == 0);
|
||||
CHECK(analysis.outliers.low_mild == 0);
|
||||
CHECK(analysis.outliers.low_severe == 0);
|
||||
CHECK(analysis.outliers.high_mild == 0);
|
||||
CHECK(analysis.outliers.high_severe == 0);
|
||||
CHECK(analysis.outliers.samples_seen == 0);
|
||||
|
||||
CHECK(analysis.outlier_variance == 0);
|
||||
}
|
||||
|
||||
TEST_CASE("run_for_at_least, int", "[benchmark]") {
|
||||
manual_clock::duration time(100);
|
||||
|
||||
int old_x = 1;
|
||||
auto Timing = Catch::Benchmark::Detail::run_for_at_least<manual_clock>(time, 1, [&old_x](int x) -> int {
|
||||
CHECK(x >= old_x);
|
||||
manual_clock::advance(x);
|
||||
old_x = x;
|
||||
return x + 17;
|
||||
});
|
||||
|
||||
REQUIRE(Timing.elapsed >= time);
|
||||
REQUIRE(Timing.result == Timing.iterations + 17);
|
||||
REQUIRE(Timing.iterations >= time.count());
|
||||
}
|
||||
|
||||
TEST_CASE("run_for_at_least, chronometer", "[benchmark]") {
|
||||
manual_clock::duration time(100);
|
||||
|
||||
int old_runs = 1;
|
||||
auto Timing = Catch::Benchmark::Detail::run_for_at_least<manual_clock>(time, 1, [&old_runs](Catch::Benchmark::Chronometer meter) -> int {
|
||||
CHECK(meter.runs() >= old_runs);
|
||||
manual_clock::advance(100);
|
||||
meter.measure([] {
|
||||
manual_clock::advance(1);
|
||||
});
|
||||
old_runs = meter.runs();
|
||||
return meter.runs() + 17;
|
||||
});
|
||||
|
||||
REQUIRE(Timing.elapsed >= time);
|
||||
REQUIRE(Timing.result == Timing.iterations + 17);
|
||||
REQUIRE(Timing.iterations >= time.count());
|
||||
}
|
||||
|
||||
|
||||
TEST_CASE("measure", "[benchmark]") {
|
||||
auto r = Catch::Benchmark::Detail::measure<manual_clock>([](int x) -> int {
|
||||
CHECK(x == 17);
|
||||
manual_clock::advance(42);
|
||||
return 23;
|
||||
}, 17);
|
||||
auto s = Catch::Benchmark::Detail::measure<manual_clock>([](int x) -> int {
|
||||
CHECK(x == 23);
|
||||
manual_clock::advance(69);
|
||||
return 17;
|
||||
}, 23);
|
||||
|
||||
CHECK(r.elapsed.count() == 42);
|
||||
CHECK(r.result == 23);
|
||||
CHECK(r.iterations == 1);
|
||||
|
||||
CHECK(s.elapsed.count() == 69);
|
||||
CHECK(s.result == 17);
|
||||
CHECK(s.iterations == 1);
|
||||
}
|
||||
|
||||
TEST_CASE("run benchmark", "[benchmark][approvals]") {
|
||||
counting_clock::set_rate(1000);
|
||||
auto start = counting_clock::now();
|
||||
|
||||
Catch::Benchmark::Benchmark bench{ "Test Benchmark", [](Catch::Benchmark::Chronometer meter) {
|
||||
counting_clock::set_rate(100000);
|
||||
meter.measure([] { return counting_clock::now(); });
|
||||
} };
|
||||
|
||||
bench.run<counting_clock>();
|
||||
auto end = counting_clock::now();
|
||||
|
||||
CHECK((end - start).count() == 2867251000);
|
||||
}
|
||||
|
||||
TEST_CASE("Failing benchmarks", "[!benchmark][.approvals]") {
|
||||
SECTION("empty", "Benchmark that has been optimized away (because it is empty)") {
|
||||
BENCHMARK("Empty benchmark") {};
|
||||
}
|
||||
SECTION("throw", "Benchmark that throws an exception") {
|
||||
BENCHMARK("Throwing benchmark") {
|
||||
throw "just a plain literal, bleh";
|
||||
};
|
||||
}
|
||||
SECTION("assert", "Benchmark that asserts inside") {
|
||||
BENCHMARK("Asserting benchmark") {
|
||||
REQUIRE(1 == 2);
|
||||
};
|
||||
}
|
||||
SECTION("fail", "Benchmark that fails inside") {
|
||||
BENCHMARK("FAIL'd benchmark") {
|
||||
FAIL("This benchmark only fails, nothing else");
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "Failing benchmark respects should-fail",
|
||||
"[!shouldfail][!benchmark][.approvals]" ) {
|
||||
BENCHMARK( "Asserting benchmark" ) { REQUIRE( 1 == 2 ); };
|
||||
}
|
||||
38
externals/catch2/tests/SelfTest/IntrospectiveTests/Parse.tests.cpp
vendored
Normal file
38
externals/catch2/tests/SelfTest/IntrospectiveTests/Parse.tests.cpp
vendored
Normal file
@@ -0,0 +1,38 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
|
||||
#include <catch2/internal/catch_parse_numbers.hpp>
|
||||
|
||||
TEST_CASE("Parse uints", "[parse-numbers]") {
|
||||
using Catch::parseUInt;
|
||||
using Catch::Optional;
|
||||
|
||||
SECTION("proper inputs") {
|
||||
REQUIRE( parseUInt( "0" ) == Optional<unsigned int>{ 0 } );
|
||||
REQUIRE( parseUInt( "100" ) == Optional<unsigned int>{ 100 } );
|
||||
REQUIRE( parseUInt( "4294967295" ) ==
|
||||
Optional<unsigned int>{ 4294967295 } );
|
||||
REQUIRE( parseUInt( "0xFF", 16 ) == Optional<unsigned int>{ 255 } );
|
||||
}
|
||||
SECTION( "Bad inputs" ) {
|
||||
// empty
|
||||
REQUIRE_FALSE( parseUInt( "" ) );
|
||||
// random noise
|
||||
REQUIRE_FALSE( parseUInt( "!!KJHF*#" ) );
|
||||
// negative
|
||||
REQUIRE_FALSE( parseUInt( "-1" ) );
|
||||
// too large
|
||||
REQUIRE_FALSE( parseUInt( "4294967296" ) );
|
||||
REQUIRE_FALSE( parseUInt( "42949672964294967296429496729642949672964294967296" ) );
|
||||
REQUIRE_FALSE( parseUInt( "2 4" ) );
|
||||
// hex with base 10
|
||||
REQUIRE_FALSE( parseUInt( "0xFF", 10 ) );
|
||||
}
|
||||
}
|
||||
254
externals/catch2/tests/SelfTest/IntrospectiveTests/PartTracker.tests.cpp
vendored
Normal file
254
externals/catch2/tests/SelfTest/IntrospectiveTests/PartTracker.tests.cpp
vendored
Normal file
@@ -0,0 +1,254 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/generators/catch_generators.hpp>
|
||||
#include <catch2/internal/catch_test_case_tracker.hpp>
|
||||
|
||||
|
||||
using namespace Catch;
|
||||
|
||||
namespace {
|
||||
Catch::TestCaseTracking::NameAndLocationRef makeNAL( StringRef name ) {
|
||||
return Catch::TestCaseTracking::NameAndLocationRef( name, Catch::SourceLineInfo("",0) );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "Tracker" ) {
|
||||
|
||||
TrackerContext ctx;
|
||||
ctx.startRun();
|
||||
ctx.startCycle();
|
||||
|
||||
|
||||
ITracker& testCase = SectionTracker::acquire( ctx, makeNAL( "Testcase" ) );
|
||||
REQUIRE( testCase.isOpen() );
|
||||
|
||||
ITracker& s1 = SectionTracker::acquire( ctx, makeNAL( "S1" ) );
|
||||
REQUIRE( s1.isOpen() );
|
||||
|
||||
SECTION( "successfully close one section" ) {
|
||||
s1.close();
|
||||
REQUIRE( s1.isSuccessfullyCompleted() );
|
||||
REQUIRE( testCase.isComplete() == false );
|
||||
|
||||
testCase.close();
|
||||
REQUIRE( ctx.completedCycle() );
|
||||
REQUIRE( testCase.isSuccessfullyCompleted() );
|
||||
}
|
||||
|
||||
SECTION( "fail one section" ) {
|
||||
s1.fail();
|
||||
REQUIRE( s1.isComplete() );
|
||||
REQUIRE( s1.isSuccessfullyCompleted() == false );
|
||||
REQUIRE( testCase.isComplete() == false );
|
||||
|
||||
testCase.close();
|
||||
REQUIRE( ctx.completedCycle() );
|
||||
REQUIRE( testCase.isSuccessfullyCompleted() == false );
|
||||
|
||||
SECTION( "re-enter after failed section" ) {
|
||||
ctx.startCycle();
|
||||
ITracker& testCase2 = SectionTracker::acquire( ctx, makeNAL( "Testcase" ) );
|
||||
REQUIRE( testCase2.isOpen() );
|
||||
|
||||
ITracker& s1b = SectionTracker::acquire( ctx, makeNAL( "S1" ) );
|
||||
REQUIRE( s1b.isOpen() == false );
|
||||
|
||||
testCase2.close();
|
||||
REQUIRE( ctx.completedCycle() );
|
||||
REQUIRE( testCase.isComplete() );
|
||||
REQUIRE( testCase.isSuccessfullyCompleted() );
|
||||
}
|
||||
SECTION( "re-enter after failed section and find next section" ) {
|
||||
ctx.startCycle();
|
||||
ITracker& testCase2 = SectionTracker::acquire( ctx, makeNAL( "Testcase" ) );
|
||||
REQUIRE( testCase2.isOpen() );
|
||||
|
||||
ITracker& s1b = SectionTracker::acquire( ctx, makeNAL( "S1" ) );
|
||||
REQUIRE( s1b.isOpen() == false );
|
||||
|
||||
ITracker& s2 = SectionTracker::acquire( ctx, makeNAL( "S2" ) );
|
||||
REQUIRE( s2.isOpen() );
|
||||
|
||||
s2.close();
|
||||
REQUIRE( ctx.completedCycle() );
|
||||
|
||||
testCase2.close();
|
||||
REQUIRE( testCase.isComplete() );
|
||||
REQUIRE( testCase.isSuccessfullyCompleted() );
|
||||
}
|
||||
}
|
||||
|
||||
SECTION( "successfully close one section, then find another" ) {
|
||||
s1.close();
|
||||
|
||||
ITracker& s2 = SectionTracker::acquire( ctx, makeNAL( "S2" ) );
|
||||
REQUIRE( s2.isOpen() == false );
|
||||
|
||||
testCase.close();
|
||||
REQUIRE( testCase.isComplete() == false );
|
||||
|
||||
SECTION( "Re-enter - skips S1 and enters S2" ) {
|
||||
ctx.startCycle();
|
||||
ITracker& testCase2 = SectionTracker::acquire( ctx, makeNAL( "Testcase" ) );
|
||||
REQUIRE( testCase2.isOpen() );
|
||||
|
||||
ITracker& s1b = SectionTracker::acquire( ctx, makeNAL( "S1" ) );
|
||||
REQUIRE( s1b.isOpen() == false );
|
||||
|
||||
ITracker& s2b = SectionTracker::acquire( ctx, makeNAL( "S2" ) );
|
||||
REQUIRE( s2b.isOpen() );
|
||||
|
||||
REQUIRE( ctx.completedCycle() == false );
|
||||
|
||||
SECTION ("Successfully close S2") {
|
||||
s2b.close();
|
||||
REQUIRE( ctx.completedCycle() );
|
||||
|
||||
REQUIRE( s2b.isSuccessfullyCompleted() );
|
||||
REQUIRE( testCase2.isComplete() == false );
|
||||
|
||||
testCase2.close();
|
||||
REQUIRE( testCase2.isSuccessfullyCompleted() );
|
||||
}
|
||||
SECTION ("fail S2") {
|
||||
s2b.fail();
|
||||
REQUIRE( ctx.completedCycle() );
|
||||
|
||||
REQUIRE( s2b.isComplete() );
|
||||
REQUIRE( s2b.isSuccessfullyCompleted() == false );
|
||||
|
||||
testCase2.close();
|
||||
REQUIRE( testCase2.isSuccessfullyCompleted() == false );
|
||||
|
||||
// Need a final cycle
|
||||
ctx.startCycle();
|
||||
ITracker& testCase3 = SectionTracker::acquire( ctx, makeNAL( "Testcase" ) );
|
||||
REQUIRE( testCase3.isOpen() );
|
||||
|
||||
ITracker& s1c = SectionTracker::acquire( ctx, makeNAL( "S1" ) );
|
||||
REQUIRE( s1c.isOpen() == false );
|
||||
|
||||
ITracker& s2c = SectionTracker::acquire( ctx, makeNAL( "S2" ) );
|
||||
REQUIRE( s2c.isOpen() == false );
|
||||
|
||||
testCase3.close();
|
||||
REQUIRE( testCase3.isSuccessfullyCompleted() );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SECTION( "open a nested section" ) {
|
||||
ITracker& s2 = SectionTracker::acquire( ctx, makeNAL( "S2" ) );
|
||||
REQUIRE( s2.isOpen() );
|
||||
|
||||
s2.close();
|
||||
REQUIRE( s2.isComplete() );
|
||||
REQUIRE( s1.isComplete() == false );
|
||||
|
||||
s1.close();
|
||||
REQUIRE( s1.isComplete() );
|
||||
REQUIRE( testCase.isComplete() == false );
|
||||
|
||||
testCase.close();
|
||||
REQUIRE( testCase.isComplete() );
|
||||
}
|
||||
}
|
||||
|
||||
static bool previouslyRun = false;
|
||||
static bool previouslyRunNested = false;
|
||||
|
||||
TEST_CASE( "#1394", "[.][approvals][tracker]" ) {
|
||||
// -- Don't re-run after specified section is done
|
||||
REQUIRE(previouslyRun == false);
|
||||
|
||||
SECTION( "RunSection" ) {
|
||||
previouslyRun = true;
|
||||
}
|
||||
SECTION( "SkipSection" ) {
|
||||
// cause an error if this section is called because it shouldn't be
|
||||
REQUIRE(1 == 0);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "#1394 nested", "[.][approvals][tracker]" ) {
|
||||
REQUIRE(previouslyRunNested == false);
|
||||
|
||||
SECTION( "NestedRunSection" ) {
|
||||
SECTION( "s1" ) {
|
||||
previouslyRunNested = true;
|
||||
}
|
||||
}
|
||||
SECTION( "NestedSkipSection" ) {
|
||||
// cause an error if this section is called because it shouldn't be
|
||||
REQUIRE(1 == 0);
|
||||
}
|
||||
}
|
||||
|
||||
// Selecting a "not last" section inside a test case via -c "section" would
|
||||
// previously only run the first subsection, instead of running all of them.
|
||||
// This allows us to check that `"#1670 regression check" -c A` leads to
|
||||
// 2 successful assertions.
|
||||
TEST_CASE("#1670 regression check", "[.approvals][tracker]") {
|
||||
SECTION("A") {
|
||||
SECTION("1") SUCCEED();
|
||||
SECTION("2") SUCCEED();
|
||||
}
|
||||
SECTION("B") {
|
||||
SECTION("1") SUCCEED();
|
||||
SECTION("2") SUCCEED();
|
||||
}
|
||||
}
|
||||
|
||||
// #1938 required a rework on how generator tracking works, so that `GENERATE`
|
||||
// supports being sandwiched between two `SECTION`s. The following tests check
|
||||
// various other scenarios through checking output in approval tests.
|
||||
TEST_CASE("#1938 - GENERATE after a section", "[.][regression][generators]") {
|
||||
SECTION("A") {
|
||||
SUCCEED("A");
|
||||
}
|
||||
auto m = GENERATE(1, 2, 3);
|
||||
SECTION("B") {
|
||||
REQUIRE(m);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("#1938 - flat generate", "[.][regression][generators]") {
|
||||
auto m = GENERATE(1, 2, 3);
|
||||
REQUIRE(m);
|
||||
}
|
||||
|
||||
TEST_CASE("#1938 - nested generate", "[.][regression][generators]") {
|
||||
auto m = GENERATE(1, 2, 3);
|
||||
auto n = GENERATE(1, 2, 3);
|
||||
REQUIRE(m);
|
||||
REQUIRE(n);
|
||||
}
|
||||
|
||||
TEST_CASE("#1938 - mixed sections and generates", "[.][regression][generators]") {
|
||||
auto i = GENERATE(1, 2);
|
||||
SECTION("A") {
|
||||
SUCCEED("A");
|
||||
}
|
||||
auto j = GENERATE(3, 4);
|
||||
SECTION("B") {
|
||||
SUCCEED("B");
|
||||
}
|
||||
auto k = GENERATE(5, 6);
|
||||
CAPTURE(i, j, k);
|
||||
SUCCEED();
|
||||
}
|
||||
|
||||
TEST_CASE("#1938 - Section followed by flat generate", "[.][regression][generators]") {
|
||||
SECTION("A") {
|
||||
REQUIRE(1);
|
||||
}
|
||||
auto m = GENERATE(2, 3);
|
||||
REQUIRE(m);
|
||||
}
|
||||
62
externals/catch2/tests/SelfTest/IntrospectiveTests/RandomNumberGeneration.tests.cpp
vendored
Normal file
62
externals/catch2/tests/SelfTest/IntrospectiveTests/RandomNumberGeneration.tests.cpp
vendored
Normal file
@@ -0,0 +1,62 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/internal/catch_random_number_generator.hpp>
|
||||
#include <catch2/internal/catch_random_seed_generation.hpp>
|
||||
#include <catch2/generators/catch_generators.hpp>
|
||||
|
||||
TEST_CASE("Our PCG implementation provides expected results for known seeds", "[rng]") {
|
||||
Catch::SimplePcg32 rng;
|
||||
SECTION("Default seeded") {
|
||||
REQUIRE(rng() == 0xfcdb943b);
|
||||
REQUIRE(rng() == 0x6f55b921);
|
||||
REQUIRE(rng() == 0x4c17a916);
|
||||
REQUIRE(rng() == 0x71eae25f);
|
||||
REQUIRE(rng() == 0x6ce7909c);
|
||||
}
|
||||
SECTION("Specific seed") {
|
||||
rng.seed(0xabcd1234);
|
||||
REQUIRE(rng() == 0x57c08495);
|
||||
REQUIRE(rng() == 0x33c956ac);
|
||||
REQUIRE(rng() == 0x2206fd76);
|
||||
REQUIRE(rng() == 0x3501a35b);
|
||||
REQUIRE(rng() == 0xfdffb30f);
|
||||
|
||||
// Also check repeated output after reseeding
|
||||
rng.seed(0xabcd1234);
|
||||
REQUIRE(rng() == 0x57c08495);
|
||||
REQUIRE(rng() == 0x33c956ac);
|
||||
REQUIRE(rng() == 0x2206fd76);
|
||||
REQUIRE(rng() == 0x3501a35b);
|
||||
REQUIRE(rng() == 0xfdffb30f);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("Comparison ops", "[rng]") {
|
||||
using Catch::SimplePcg32;
|
||||
REQUIRE(SimplePcg32{} == SimplePcg32{});
|
||||
REQUIRE(SimplePcg32{ 0 } != SimplePcg32{});
|
||||
REQUIRE_FALSE(SimplePcg32{ 1 } == SimplePcg32{ 2 });
|
||||
REQUIRE_FALSE(SimplePcg32{ 1 } != SimplePcg32{ 1 });
|
||||
}
|
||||
|
||||
TEST_CASE("Random seed generation reports unknown methods", "[rng][seed]") {
|
||||
REQUIRE_THROWS(Catch::generateRandomSeed(static_cast<Catch::GenerateFrom>(77)));
|
||||
}
|
||||
|
||||
TEST_CASE("Random seed generation accepts known methods", "[rng][seed]") {
|
||||
using Catch::GenerateFrom;
|
||||
const auto method = GENERATE(
|
||||
GenerateFrom::Time,
|
||||
GenerateFrom::RandomDevice,
|
||||
GenerateFrom::Default
|
||||
);
|
||||
|
||||
REQUIRE_NOTHROW(Catch::generateRandomSeed(method));
|
||||
}
|
||||
329
externals/catch2/tests/SelfTest/IntrospectiveTests/Reporters.tests.cpp
vendored
Normal file
329
externals/catch2/tests/SelfTest/IntrospectiveTests/Reporters.tests.cpp
vendored
Normal file
@@ -0,0 +1,329 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
|
||||
#include <catch2/catch_test_case_info.hpp>
|
||||
#include <catch2/catch_config.hpp>
|
||||
#include <catch2/interfaces/catch_interfaces_reporter.hpp>
|
||||
#include <catch2/interfaces/catch_interfaces_reporter_factory.hpp>
|
||||
#include <catch2/interfaces/catch_interfaces_reporter_registry.hpp>
|
||||
#include <catch2/internal/catch_console_colour.hpp>
|
||||
#include <catch2/internal/catch_enforce.hpp>
|
||||
#include <catch2/internal/catch_list.hpp>
|
||||
#include <catch2/internal/catch_reporter_registry.hpp>
|
||||
#include <catch2/internal/catch_istream.hpp>
|
||||
#include <catch2/matchers/catch_matchers_string.hpp>
|
||||
#include <catch2/reporters/catch_reporter_helpers.hpp>
|
||||
#include <catch2/reporters/catch_reporter_event_listener.hpp>
|
||||
#include <catch2/reporters/catch_reporter_streaming_base.hpp>
|
||||
#include <catch2/reporters/catch_reporter_multi.hpp>
|
||||
#include <catch2/internal/catch_move_and_forward.hpp>
|
||||
|
||||
#include <sstream>
|
||||
|
||||
namespace {
|
||||
class StringIStream : public Catch::IStream {
|
||||
public:
|
||||
std::ostream& stream() override { return sstr; }
|
||||
std::string str() const { return sstr.str(); }
|
||||
private:
|
||||
std::stringstream sstr;
|
||||
};
|
||||
|
||||
//! config must outlive the function
|
||||
Catch::ReporterConfig makeDummyRepConfig( Catch::Config const& config ) {
|
||||
return Catch::ReporterConfig{
|
||||
&config,
|
||||
Catch::Detail::make_unique<StringIStream>(),
|
||||
Catch::ColourMode::None,
|
||||
{} };
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "The default listing implementation write to provided stream",
|
||||
"[reporters][reporter-helpers]" ) {
|
||||
using Catch::Matchers::ContainsSubstring;
|
||||
using namespace std::string_literals;
|
||||
|
||||
StringIStream sstream;
|
||||
SECTION( "Listing tags" ) {
|
||||
std::vector<Catch::TagInfo> tags(1);
|
||||
tags[0].add("fakeTag"_catch_sr);
|
||||
Catch::defaultListTags(sstream.stream(), tags, false);
|
||||
|
||||
auto listingString = sstream.str();
|
||||
REQUIRE_THAT(listingString, ContainsSubstring("[fakeTag]"s));
|
||||
}
|
||||
SECTION( "Listing reporters" ) {
|
||||
std::vector<Catch::ReporterDescription> reporters(
|
||||
{ { "fake reporter", "fake description" } } );
|
||||
Catch::defaultListReporters(sstream.stream(), reporters, Catch::Verbosity::Normal);
|
||||
|
||||
auto listingString = sstream.str();
|
||||
REQUIRE_THAT( listingString,
|
||||
ContainsSubstring( "fake reporter"s ) &&
|
||||
ContainsSubstring( "fake description"s ) );
|
||||
}
|
||||
SECTION( "Listing tests" ) {
|
||||
Catch::TestCaseInfo fakeInfo{
|
||||
""s,
|
||||
{ "fake test name"_catch_sr, "[fakeTestTag]"_catch_sr },
|
||||
{ "fake-file.cpp", 123456789 } };
|
||||
std::vector<Catch::TestCaseHandle> tests({ {&fakeInfo, nullptr} });
|
||||
auto colour = Catch::makeColourImpl( Catch::ColourMode::None, &sstream);
|
||||
Catch::defaultListTests(sstream.stream(), colour.get(), tests, false, Catch::Verbosity::Normal);
|
||||
|
||||
auto listingString = sstream.str();
|
||||
REQUIRE_THAT( listingString,
|
||||
ContainsSubstring( "fake test name"s ) &&
|
||||
ContainsSubstring( "fakeTestTag"s ) );
|
||||
}
|
||||
SECTION( "Listing listeners" ) {
|
||||
std::vector<Catch::ListenerDescription> listeners(
|
||||
{ { "fakeListener"_catch_sr, "fake description" } } );
|
||||
|
||||
Catch::defaultListListeners( sstream.stream(), listeners );
|
||||
auto listingString = sstream.str();
|
||||
REQUIRE_THAT( listingString,
|
||||
ContainsSubstring( "fakeListener"s ) &&
|
||||
ContainsSubstring( "fake description"s ) );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "Reporter's write listings to provided stream", "[reporters]" ) {
|
||||
using Catch::Matchers::ContainsSubstring;
|
||||
using namespace std::string_literals;
|
||||
|
||||
auto const& factories = Catch::getRegistryHub().getReporterRegistry().getFactories();
|
||||
// If there are no reporters, the test would pass falsely
|
||||
// while there is something obviously broken
|
||||
REQUIRE_FALSE(factories.empty());
|
||||
|
||||
for (auto const& factory : factories) {
|
||||
INFO("Tested reporter: " << factory.first);
|
||||
auto sstream = Catch::Detail::make_unique<StringIStream>();
|
||||
auto& sstreamRef = *sstream.get();
|
||||
|
||||
Catch::Config config( Catch::ConfigData{} );
|
||||
auto reporter = factory.second->create( Catch::ReporterConfig{
|
||||
&config, CATCH_MOVE( sstream ), Catch::ColourMode::None, {} } );
|
||||
|
||||
DYNAMIC_SECTION( factory.first << " reporter lists tags" ) {
|
||||
std::vector<Catch::TagInfo> tags(1);
|
||||
tags[0].add("fakeTag"_catch_sr);
|
||||
reporter->listTags(tags);
|
||||
|
||||
auto listingString = sstreamRef.str();
|
||||
REQUIRE_THAT(listingString, ContainsSubstring("fakeTag"s));
|
||||
}
|
||||
|
||||
DYNAMIC_SECTION( factory.first << " reporter lists reporters" ) {
|
||||
std::vector<Catch::ReporterDescription> reporters(
|
||||
{ { "fake reporter", "fake description" } } );
|
||||
reporter->listReporters(reporters);
|
||||
|
||||
auto listingString = sstreamRef.str();
|
||||
REQUIRE_THAT(listingString, ContainsSubstring("fake reporter"s));
|
||||
}
|
||||
|
||||
DYNAMIC_SECTION( factory.first << " reporter lists tests" ) {
|
||||
Catch::TestCaseInfo fakeInfo{
|
||||
""s,
|
||||
{ "fake test name"_catch_sr, "[fakeTestTag]"_catch_sr },
|
||||
{ "fake-file.cpp", 123456789 } };
|
||||
std::vector<Catch::TestCaseHandle> tests({ {&fakeInfo, nullptr} });
|
||||
reporter->listTests(tests);
|
||||
|
||||
auto listingString = sstreamRef.str();
|
||||
REQUIRE_THAT( listingString,
|
||||
ContainsSubstring( "fake test name"s ) &&
|
||||
ContainsSubstring( "fakeTestTag"s ) );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
TEST_CASE("Reproducer for #2309 - a very long description past 80 chars (default console width) with a late colon : blablabla", "[console-reporter]") {
|
||||
SUCCEED();
|
||||
}
|
||||
|
||||
namespace {
|
||||
// A listener that writes provided string into destination,
|
||||
// to record order of testRunStarting invocation.
|
||||
class MockListener : public Catch::EventListenerBase {
|
||||
std::string m_witness;
|
||||
std::vector<std::string>& m_recorder;
|
||||
public:
|
||||
MockListener( std::string witness,
|
||||
std::vector<std::string>& recorder,
|
||||
Catch::IConfig const* config ):
|
||||
EventListenerBase( config ),
|
||||
m_witness( witness ),
|
||||
m_recorder( recorder )
|
||||
{}
|
||||
|
||||
void testRunStarting( Catch::TestRunInfo const& ) override {
|
||||
m_recorder.push_back( m_witness );
|
||||
}
|
||||
};
|
||||
// A reporter that writes provided string into destination,
|
||||
// to record order of testRunStarting invocation.
|
||||
class MockReporter : public Catch::StreamingReporterBase {
|
||||
std::string m_witness;
|
||||
std::vector<std::string>& m_recorder;
|
||||
public:
|
||||
MockReporter( std::string witness,
|
||||
std::vector<std::string>& recorder,
|
||||
Catch::ReporterConfig&& config ):
|
||||
StreamingReporterBase( CATCH_MOVE(config) ),
|
||||
m_witness( witness ),
|
||||
m_recorder( recorder )
|
||||
{}
|
||||
|
||||
void testRunStarting( Catch::TestRunInfo const& ) override {
|
||||
m_recorder.push_back( m_witness );
|
||||
}
|
||||
};
|
||||
} // namespace
|
||||
|
||||
TEST_CASE("Multireporter calls reporters and listeners in correct order",
|
||||
"[reporters][multi-reporter]") {
|
||||
Catch::Config config( Catch::ConfigData{} );
|
||||
|
||||
// We add reporters before listeners, to check that internally they
|
||||
// get sorted properly, and listeners are called first anyway.
|
||||
Catch::MultiReporter multiReporter( &config );
|
||||
std::vector<std::string> records;
|
||||
multiReporter.addReporter( Catch::Detail::make_unique<MockReporter>(
|
||||
"Goodbye", records, makeDummyRepConfig(config) ) );
|
||||
multiReporter.addListener(
|
||||
Catch::Detail::make_unique<MockListener>( "Hello", records, &config ) );
|
||||
multiReporter.addListener(
|
||||
Catch::Detail::make_unique<MockListener>( "world", records, &config ) );
|
||||
multiReporter.addReporter( Catch::Detail::make_unique<MockReporter>(
|
||||
"world", records, makeDummyRepConfig(config) ) );
|
||||
multiReporter.testRunStarting( { "" } );
|
||||
|
||||
std::vector<std::string> expected( { "Hello", "world", "Goodbye", "world" } );
|
||||
REQUIRE( records == expected );
|
||||
}
|
||||
|
||||
namespace {
|
||||
// A listener that sets it preferences to test that multireporter,
|
||||
// properly sets up its own preferences
|
||||
class PreferenceListener : public Catch::EventListenerBase {
|
||||
public:
|
||||
PreferenceListener( bool redirectStdout,
|
||||
bool reportAllAssertions,
|
||||
Catch::IConfig const* config ):
|
||||
EventListenerBase( config ) {
|
||||
m_preferences.shouldRedirectStdOut = redirectStdout;
|
||||
m_preferences.shouldReportAllAssertions = reportAllAssertions;
|
||||
}
|
||||
};
|
||||
// A reporter that sets it preferences to test that multireporter,
|
||||
// properly sets up its own preferences
|
||||
class PreferenceReporter : public Catch::StreamingReporterBase {
|
||||
public:
|
||||
PreferenceReporter( bool redirectStdout,
|
||||
bool reportAllAssertions,
|
||||
Catch::ReporterConfig&& config ):
|
||||
StreamingReporterBase( CATCH_MOVE(config) ) {
|
||||
m_preferences.shouldRedirectStdOut = redirectStdout;
|
||||
m_preferences.shouldReportAllAssertions = reportAllAssertions;
|
||||
}
|
||||
};
|
||||
} // namespace
|
||||
|
||||
TEST_CASE("Multireporter updates ReporterPreferences properly",
|
||||
"[reporters][multi-reporter]") {
|
||||
|
||||
Catch::Config config( Catch::ConfigData{} );
|
||||
Catch::MultiReporter multiReporter( &config );
|
||||
|
||||
// Post init defaults
|
||||
REQUIRE( multiReporter.getPreferences().shouldRedirectStdOut == false );
|
||||
REQUIRE( multiReporter.getPreferences().shouldReportAllAssertions == false );
|
||||
|
||||
SECTION( "Adding listeners" ) {
|
||||
multiReporter.addListener(
|
||||
Catch::Detail::make_unique<PreferenceListener>(
|
||||
true, false, &config ) );
|
||||
REQUIRE( multiReporter.getPreferences().shouldRedirectStdOut == true );
|
||||
REQUIRE( multiReporter.getPreferences().shouldReportAllAssertions == false );
|
||||
|
||||
multiReporter.addListener(
|
||||
Catch::Detail::make_unique<PreferenceListener>(
|
||||
false, true, &config ) );
|
||||
REQUIRE( multiReporter.getPreferences().shouldRedirectStdOut == true );
|
||||
REQUIRE( multiReporter.getPreferences().shouldReportAllAssertions == true);
|
||||
|
||||
multiReporter.addListener(
|
||||
Catch::Detail::make_unique<PreferenceListener>(
|
||||
false, false, &config ) );
|
||||
REQUIRE( multiReporter.getPreferences().shouldRedirectStdOut == true );
|
||||
REQUIRE( multiReporter.getPreferences().shouldReportAllAssertions == true );
|
||||
}
|
||||
SECTION( "Adding reporters" ) {
|
||||
multiReporter.addReporter(
|
||||
Catch::Detail::make_unique<PreferenceReporter>(
|
||||
true, false, makeDummyRepConfig(config) ) );
|
||||
REQUIRE( multiReporter.getPreferences().shouldRedirectStdOut == true );
|
||||
REQUIRE( multiReporter.getPreferences().shouldReportAllAssertions == false );
|
||||
|
||||
multiReporter.addReporter(
|
||||
Catch::Detail::make_unique<PreferenceReporter>(
|
||||
false, true, makeDummyRepConfig( config ) ) );
|
||||
REQUIRE( multiReporter.getPreferences().shouldRedirectStdOut == true );
|
||||
REQUIRE( multiReporter.getPreferences().shouldReportAllAssertions == true );
|
||||
|
||||
multiReporter.addReporter(
|
||||
Catch::Detail::make_unique<PreferenceReporter>(
|
||||
false, false, makeDummyRepConfig( config ) ) );
|
||||
REQUIRE( multiReporter.getPreferences().shouldRedirectStdOut == true );
|
||||
REQUIRE( multiReporter.getPreferences().shouldReportAllAssertions == true );
|
||||
}
|
||||
}
|
||||
|
||||
namespace {
|
||||
class TestReporterFactory : public Catch::IReporterFactory {
|
||||
Catch::IEventListenerPtr create( Catch::ReporterConfig&& ) const override {
|
||||
CATCH_INTERNAL_ERROR(
|
||||
"This factory should never create a reporter" );
|
||||
}
|
||||
std::string getDescription() const override {
|
||||
return "Fake test factory";
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
TEST_CASE("Registering reporter with '::' in name fails",
|
||||
"[reporters][registration]") {
|
||||
Catch::ReporterRegistry registry;
|
||||
|
||||
REQUIRE_THROWS_WITH( registry.registerReporter(
|
||||
"with::doublecolons",
|
||||
Catch::Detail::make_unique<TestReporterFactory>() ),
|
||||
"'::' is not allowed in reporter name: 'with::doublecolons'" );
|
||||
}
|
||||
|
||||
TEST_CASE("Registering multiple reporters with the same name fails",
|
||||
"[reporters][registration][approvals]") {
|
||||
Catch::ReporterRegistry registry;
|
||||
|
||||
registry.registerReporter(
|
||||
"some-reporter-name",
|
||||
Catch::Detail::make_unique<TestReporterFactory>() );
|
||||
|
||||
REQUIRE_THROWS_WITH(
|
||||
registry.registerReporter(
|
||||
"some-reporter-name",
|
||||
Catch::Detail::make_unique<TestReporterFactory>() ),
|
||||
"reporter using 'some-reporter-name' as name was already registered" );
|
||||
}
|
||||
45
externals/catch2/tests/SelfTest/IntrospectiveTests/Sharding.tests.cpp
vendored
Normal file
45
externals/catch2/tests/SelfTest/IntrospectiveTests/Sharding.tests.cpp
vendored
Normal file
@@ -0,0 +1,45 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/generators/catch_generators_all.hpp>
|
||||
|
||||
#include <catch2/internal/catch_sharding.hpp>
|
||||
|
||||
#include <unordered_map>
|
||||
#include <vector>
|
||||
|
||||
TEST_CASE("Sharding Function", "[approvals]") {
|
||||
std::vector<int> testContainer = { 0, 1, 2, 3, 4, 5, 6 };
|
||||
std::unordered_map<int, std::vector<std::size_t>> expectedShardSizes = {
|
||||
{1, {7}},
|
||||
{2, {4, 3}},
|
||||
{3, {3, 2, 2}},
|
||||
{4, {2, 2, 2, 1}},
|
||||
{5, {2, 2, 1, 1, 1}},
|
||||
{6, {2, 1, 1, 1, 1, 1}},
|
||||
{7, {1, 1, 1, 1, 1, 1, 1}},
|
||||
};
|
||||
|
||||
auto shardCount = GENERATE(range(1, 7));
|
||||
auto shardIndex = GENERATE_COPY(filter([=](int i) { return i < shardCount; }, range(0, 6)));
|
||||
|
||||
std::vector<int> result = Catch::createShard(testContainer, shardCount, shardIndex);
|
||||
|
||||
auto& sizes = expectedShardSizes[shardCount];
|
||||
REQUIRE(result.size() == sizes[shardIndex]);
|
||||
|
||||
std::size_t startIndex = 0;
|
||||
for(int i = 0; i < shardIndex; i++) {
|
||||
startIndex += sizes[i];
|
||||
}
|
||||
|
||||
for(std::size_t i = 0; i < sizes[shardIndex]; i++) {
|
||||
CHECK(result[i] == testContainer[i + startIndex]);
|
||||
}
|
||||
}
|
||||
32
externals/catch2/tests/SelfTest/IntrospectiveTests/Stream.tests.cpp
vendored
Normal file
32
externals/catch2/tests/SelfTest/IntrospectiveTests/Stream.tests.cpp
vendored
Normal file
@@ -0,0 +1,32 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
|
||||
#include <catch2/internal/catch_istream.hpp>
|
||||
|
||||
TEST_CASE( "Cout stream properly declares it writes to stdout", "[streams]" ) {
|
||||
REQUIRE( Catch::makeStream( "-" )->isConsole() );
|
||||
}
|
||||
|
||||
TEST_CASE( "Empty stream name opens cout stream", "[streams]" ) {
|
||||
REQUIRE( Catch::makeStream( "" )->isConsole() );
|
||||
}
|
||||
|
||||
TEST_CASE( "stdout and stderr streams have %-starting name", "[streams]" ) {
|
||||
REQUIRE( Catch::makeStream( "%stderr" )->isConsole() );
|
||||
REQUIRE( Catch::makeStream( "%stdout" )->isConsole() );
|
||||
}
|
||||
|
||||
TEST_CASE( "request an unknown %-starting stream fails", "[streams]" ) {
|
||||
REQUIRE_THROWS( Catch::makeStream( "%somestream" ) );
|
||||
}
|
||||
|
||||
TEST_CASE( "makeStream recognizes %debug stream name", "[streams]" ) {
|
||||
REQUIRE_NOTHROW( Catch::makeStream( "%debug" ) );
|
||||
}
|
||||
212
externals/catch2/tests/SelfTest/IntrospectiveTests/String.tests.cpp
vendored
Normal file
212
externals/catch2/tests/SelfTest/IntrospectiveTests/String.tests.cpp
vendored
Normal file
@@ -0,0 +1,212 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/internal/catch_stringref.hpp>
|
||||
|
||||
#include <cstring>
|
||||
|
||||
TEST_CASE( "StringRef", "[Strings][StringRef]" ) {
|
||||
using Catch::StringRef;
|
||||
|
||||
SECTION( "Empty string" ) {
|
||||
StringRef empty;
|
||||
REQUIRE( empty.empty() );
|
||||
REQUIRE( empty.size() == 0 );
|
||||
REQUIRE( std::strcmp( empty.data(), "" ) == 0 );
|
||||
}
|
||||
|
||||
SECTION( "From string literal" ) {
|
||||
StringRef s = "hello";
|
||||
REQUIRE( s.empty() == false );
|
||||
REQUIRE( s.size() == 5 );
|
||||
|
||||
auto rawChars = s.data();
|
||||
REQUIRE( std::strcmp( rawChars, "hello" ) == 0 );
|
||||
|
||||
REQUIRE(s.data() == rawChars);
|
||||
}
|
||||
SECTION( "From sub-string" ) {
|
||||
StringRef original = StringRef( "original string" ).substr(0, 8);
|
||||
REQUIRE( original == "original" );
|
||||
|
||||
REQUIRE_NOTHROW(original.data());
|
||||
}
|
||||
SECTION( "Copy construction is shallow" ) {
|
||||
StringRef original = StringRef( "original string" );
|
||||
StringRef copy = original;
|
||||
REQUIRE(original.begin() == copy.begin());
|
||||
}
|
||||
SECTION( "Copy assignment is shallow" ) {
|
||||
StringRef original = StringRef( "original string" );
|
||||
StringRef copy;
|
||||
copy = original;
|
||||
REQUIRE(original.begin() == copy.begin());
|
||||
}
|
||||
|
||||
SECTION( "Substrings" ) {
|
||||
StringRef s = "hello world!";
|
||||
StringRef ss = s.substr(0, 5);
|
||||
|
||||
SECTION( "zero-based substring" ) {
|
||||
REQUIRE( ss.empty() == false );
|
||||
REQUIRE( ss.size() == 5 );
|
||||
REQUIRE( std::strncmp( ss.data(), "hello", 5 ) == 0 );
|
||||
REQUIRE( ss == "hello" );
|
||||
}
|
||||
|
||||
SECTION( "non-zero-based substring") {
|
||||
ss = s.substr( 6, 6 );
|
||||
REQUIRE( ss.size() == 6 );
|
||||
REQUIRE( std::strcmp( ss.data(), "world!" ) == 0 );
|
||||
}
|
||||
|
||||
SECTION( "Pointer values of full refs should match" ) {
|
||||
StringRef s2 = s;
|
||||
REQUIRE( s.data() == s2.data() );
|
||||
}
|
||||
|
||||
SECTION( "Pointer values of substring refs should also match" ) {
|
||||
REQUIRE( s.data() == ss.data() );
|
||||
}
|
||||
|
||||
SECTION("Past the end substring") {
|
||||
REQUIRE(s.substr(s.size() + 1, 123).empty());
|
||||
}
|
||||
|
||||
SECTION("Substring off the end are trimmed") {
|
||||
ss = s.substr(6, 123);
|
||||
REQUIRE(std::strcmp(ss.data(), "world!") == 0);
|
||||
}
|
||||
SECTION("substring start after the end is empty") {
|
||||
REQUIRE(s.substr(1'000'000, 1).empty());
|
||||
}
|
||||
}
|
||||
|
||||
SECTION( "Comparisons are deep" ) {
|
||||
char buffer1[] = "Hello";
|
||||
char buffer2[] = "Hello";
|
||||
CHECK(reinterpret_cast<char*>(buffer1) != reinterpret_cast<char*>(buffer2));
|
||||
|
||||
StringRef left(buffer1), right(buffer2);
|
||||
REQUIRE( left == right );
|
||||
REQUIRE(left != left.substr(0, 3));
|
||||
}
|
||||
|
||||
SECTION( "from std::string" ) {
|
||||
std::string stdStr = "a standard string";
|
||||
|
||||
SECTION( "implicitly constructed" ) {
|
||||
StringRef sr = stdStr;
|
||||
REQUIRE( sr == "a standard string" );
|
||||
REQUIRE( sr.size() == stdStr.size() );
|
||||
}
|
||||
SECTION( "explicitly constructed" ) {
|
||||
StringRef sr( stdStr );
|
||||
REQUIRE( sr == "a standard string" );
|
||||
REQUIRE( sr.size() == stdStr.size() );
|
||||
}
|
||||
SECTION( "assigned" ) {
|
||||
StringRef sr;
|
||||
sr = stdStr;
|
||||
REQUIRE( sr == "a standard string" );
|
||||
REQUIRE( sr.size() == stdStr.size() );
|
||||
}
|
||||
}
|
||||
|
||||
SECTION( "to std::string" ) {
|
||||
StringRef sr = "a stringref";
|
||||
|
||||
SECTION( "explicitly constructed" ) {
|
||||
std::string stdStr( sr );
|
||||
REQUIRE( stdStr == "a stringref" );
|
||||
REQUIRE( stdStr.size() == sr.size() );
|
||||
}
|
||||
SECTION( "assigned" ) {
|
||||
std::string stdStr;
|
||||
stdStr = static_cast<std::string>(sr);
|
||||
REQUIRE( stdStr == "a stringref" );
|
||||
REQUIRE( stdStr.size() == sr.size() );
|
||||
}
|
||||
}
|
||||
|
||||
SECTION("std::string += StringRef") {
|
||||
StringRef sr = "the stringref contents";
|
||||
std::string lhs("some string += ");
|
||||
lhs += sr;
|
||||
REQUIRE(lhs == "some string += the stringref contents");
|
||||
}
|
||||
SECTION("StringRef + StringRef") {
|
||||
StringRef sr1 = "abraka", sr2 = "dabra";
|
||||
std::string together = sr1 + sr2;
|
||||
REQUIRE(together == "abrakadabra");
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("StringRef at compilation time", "[Strings][StringRef][constexpr]") {
|
||||
using Catch::StringRef;
|
||||
SECTION("Simple constructors") {
|
||||
constexpr StringRef empty{};
|
||||
STATIC_REQUIRE(empty.size() == 0);
|
||||
STATIC_REQUIRE(empty.begin() == empty.end());
|
||||
|
||||
constexpr char const* const abc = "abc";
|
||||
|
||||
constexpr StringRef stringref(abc, 3);
|
||||
STATIC_REQUIRE(stringref.size() == 3);
|
||||
STATIC_REQUIRE(stringref.data() == abc);
|
||||
STATIC_REQUIRE(stringref.begin() == abc);
|
||||
STATIC_REQUIRE(stringref.begin() != stringref.end());
|
||||
STATIC_REQUIRE(stringref.substr(10, 0).empty());
|
||||
STATIC_REQUIRE(stringref.substr(2, 1).data() == abc + 2);
|
||||
STATIC_REQUIRE(stringref[1] == 'b');
|
||||
|
||||
|
||||
constexpr StringRef shortened(abc, 2);
|
||||
STATIC_REQUIRE(shortened.size() == 2);
|
||||
STATIC_REQUIRE(shortened.data() == abc);
|
||||
STATIC_REQUIRE(shortened.begin() != shortened.end());
|
||||
}
|
||||
SECTION("UDL construction") {
|
||||
constexpr auto sr1 = "abc"_catch_sr;
|
||||
STATIC_REQUIRE_FALSE(sr1.empty());
|
||||
STATIC_REQUIRE(sr1.size() == 3);
|
||||
|
||||
using Catch::operator"" _sr;
|
||||
constexpr auto sr2 = ""_sr;
|
||||
STATIC_REQUIRE(sr2.empty());
|
||||
STATIC_REQUIRE(sr2.size() == 0);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("StringRef::compare", "[Strings][StringRef][approvals]") {
|
||||
using Catch::StringRef;
|
||||
|
||||
SECTION("Same length on both sides") {
|
||||
StringRef sr1("abcdc");
|
||||
StringRef sr2("abcdd");
|
||||
StringRef sr3("abcdc");
|
||||
|
||||
REQUIRE(sr1.compare(sr2) < 0);
|
||||
REQUIRE(sr2.compare(sr1) > 0);
|
||||
REQUIRE(sr1.compare(sr3) == 0);
|
||||
REQUIRE(sr3.compare(sr1) == 0);
|
||||
}
|
||||
SECTION("Different lengths") {
|
||||
StringRef sr1("def");
|
||||
StringRef sr2("deff");
|
||||
StringRef sr3("ab");
|
||||
|
||||
REQUIRE(sr1.compare(sr2) < 0);
|
||||
REQUIRE(sr2.compare(sr1) > 0);
|
||||
REQUIRE(sr1.compare(sr3) > 0);
|
||||
REQUIRE(sr2.compare(sr3) > 0);
|
||||
REQUIRE(sr3.compare(sr1) < 0);
|
||||
REQUIRE(sr3.compare(sr2) < 0);
|
||||
}
|
||||
}
|
||||
83
externals/catch2/tests/SelfTest/IntrospectiveTests/StringManip.tests.cpp
vendored
Normal file
83
externals/catch2/tests/SelfTest/IntrospectiveTests/StringManip.tests.cpp
vendored
Normal file
@@ -0,0 +1,83 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/matchers/catch_matchers_vector.hpp>
|
||||
#include <catch2/internal/catch_string_manip.hpp>
|
||||
|
||||
static const char * const no_whitespace = "There is no extra whitespace here";
|
||||
static const char * const leading_whitespace = " \r \t\n There is no extra whitespace here";
|
||||
static const char * const trailing_whitespace = "There is no extra whitespace here \t \n \r ";
|
||||
static const char * const whitespace_at_both_ends = " \r\n \t There is no extra whitespace here \t\t\t \n";
|
||||
|
||||
TEST_CASE("Trim strings", "[string-manip]") {
|
||||
using Catch::trim; using Catch::StringRef;
|
||||
static_assert(std::is_same<std::string, decltype(trim(std::string{}))>::value, "Trimming std::string should return std::string");
|
||||
static_assert(std::is_same<StringRef, decltype(trim(StringRef{}))>::value, "Trimming StringRef should return StringRef");
|
||||
|
||||
REQUIRE(trim(std::string(no_whitespace)) == no_whitespace);
|
||||
REQUIRE(trim(std::string(leading_whitespace)) == no_whitespace);
|
||||
REQUIRE(trim(std::string(trailing_whitespace)) == no_whitespace);
|
||||
REQUIRE(trim(std::string(whitespace_at_both_ends)) == no_whitespace);
|
||||
|
||||
REQUIRE(trim(StringRef(no_whitespace)) == StringRef(no_whitespace));
|
||||
REQUIRE(trim(StringRef(leading_whitespace)) == StringRef(no_whitespace));
|
||||
REQUIRE(trim(StringRef(trailing_whitespace)) == StringRef(no_whitespace));
|
||||
REQUIRE(trim(StringRef(whitespace_at_both_ends)) == StringRef(no_whitespace));
|
||||
}
|
||||
|
||||
TEST_CASE("replaceInPlace", "[string-manip]") {
|
||||
std::string letters = "abcdefcg";
|
||||
SECTION("replace single char") {
|
||||
CHECK(Catch::replaceInPlace(letters, "b", "z"));
|
||||
CHECK(letters == "azcdefcg");
|
||||
}
|
||||
SECTION("replace two chars") {
|
||||
CHECK(Catch::replaceInPlace(letters, "c", "z"));
|
||||
CHECK(letters == "abzdefzg");
|
||||
}
|
||||
SECTION("replace first char") {
|
||||
CHECK(Catch::replaceInPlace(letters, "a", "z"));
|
||||
CHECK(letters == "zbcdefcg");
|
||||
}
|
||||
SECTION("replace last char") {
|
||||
CHECK(Catch::replaceInPlace(letters, "g", "z"));
|
||||
CHECK(letters == "abcdefcz");
|
||||
}
|
||||
SECTION("replace all chars") {
|
||||
CHECK(Catch::replaceInPlace(letters, letters, "replaced"));
|
||||
CHECK(letters == "replaced");
|
||||
}
|
||||
SECTION("replace no chars") {
|
||||
CHECK_FALSE(Catch::replaceInPlace(letters, "x", "z"));
|
||||
CHECK(letters == letters);
|
||||
}
|
||||
SECTION("escape '") {
|
||||
std::string s = "didn't";
|
||||
CHECK(Catch::replaceInPlace(s, "'", "|'"));
|
||||
CHECK(s == "didn|'t");
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("splitString", "[string-manip]") {
|
||||
using namespace Catch::Matchers;
|
||||
using Catch::splitStringRef;
|
||||
using Catch::StringRef;
|
||||
|
||||
CHECK_THAT(splitStringRef("", ','), Equals(std::vector<StringRef>()));
|
||||
CHECK_THAT(splitStringRef("abc", ','), Equals(std::vector<StringRef>{"abc"}));
|
||||
CHECK_THAT(splitStringRef("abc,def", ','), Equals(std::vector<StringRef>{"abc", "def"}));
|
||||
}
|
||||
|
||||
TEST_CASE("startsWith", "[string-manip]") {
|
||||
using Catch::startsWith;
|
||||
|
||||
CHECK_FALSE(startsWith("", 'c'));
|
||||
CHECK(startsWith(std::string("abc"), 'a'));
|
||||
CHECK(startsWith("def"_catch_sr, 'd'));
|
||||
}
|
||||
104
externals/catch2/tests/SelfTest/IntrospectiveTests/Tag.tests.cpp
vendored
Normal file
104
externals/catch2/tests/SelfTest/IntrospectiveTests/Tag.tests.cpp
vendored
Normal file
@@ -0,0 +1,104 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/matchers/catch_matchers_string.hpp>
|
||||
#include <catch2/matchers/catch_matchers_vector.hpp>
|
||||
#include <catch2/internal/catch_tag_alias_registry.hpp>
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/catch_test_case_info.hpp>
|
||||
|
||||
TEST_CASE( "Tag alias can be registered against tag patterns" ) {
|
||||
|
||||
Catch::TagAliasRegistry registry;
|
||||
|
||||
registry.add( "[@zzz]", "[one][two]", Catch::SourceLineInfo( "file", 2 ) );
|
||||
|
||||
SECTION( "The same tag alias can only be registered once" ) {
|
||||
|
||||
try {
|
||||
registry.add( "[@zzz]", "[one][two]", Catch::SourceLineInfo( "file", 10 ) );
|
||||
FAIL( "expected exception" );
|
||||
}
|
||||
catch( std::exception& ex ) {
|
||||
std::string what = ex.what();
|
||||
using namespace Catch::Matchers;
|
||||
CHECK_THAT( what, ContainsSubstring( "[@zzz]" ) );
|
||||
CHECK_THAT( what, ContainsSubstring( "file" ) );
|
||||
CHECK_THAT( what, ContainsSubstring( "2" ) );
|
||||
CHECK_THAT( what, ContainsSubstring( "10" ) );
|
||||
}
|
||||
}
|
||||
|
||||
SECTION( "Tag aliases must be of the form [@name]" ) {
|
||||
CHECK_THROWS( registry.add( "[no ampersat]", "", Catch::SourceLineInfo( "file", 3 ) ) );
|
||||
CHECK_THROWS( registry.add( "[the @ is not at the start]", "", Catch::SourceLineInfo( "file", 3 ) ) );
|
||||
CHECK_THROWS( registry.add( "@no square bracket at start]", "", Catch::SourceLineInfo( "file", 3 ) ) );
|
||||
CHECK_THROWS( registry.add( "[@no square bracket at end", "", Catch::SourceLineInfo( "file", 3 ) ) );
|
||||
}
|
||||
}
|
||||
|
||||
// Dummy line info for creating dummy test cases below
|
||||
static constexpr Catch::SourceLineInfo dummySourceLineInfo = CATCH_INTERNAL_LINEINFO;
|
||||
|
||||
TEST_CASE("shortened hide tags are split apart", "[tags]") {
|
||||
using Catch::StringRef;
|
||||
using Catch::Tag;
|
||||
using Catch::Matchers::VectorContains;
|
||||
|
||||
Catch::TestCaseInfo testcase("", {"fake test name", "[.magic-tag]"}, dummySourceLineInfo);
|
||||
REQUIRE_THAT( testcase.tags, VectorContains( Tag( "magic-tag" ) )
|
||||
&& VectorContains( Tag( "."_catch_sr ) ) );
|
||||
}
|
||||
|
||||
TEST_CASE("tags with dots in later positions are not parsed as hidden", "[tags]") {
|
||||
using Catch::StringRef;
|
||||
using Catch::Matchers::VectorContains;
|
||||
Catch::TestCaseInfo testcase("", { "fake test name", "[magic.tag]" }, dummySourceLineInfo);
|
||||
|
||||
REQUIRE(testcase.tags.size() == 1);
|
||||
REQUIRE(testcase.tags[0].original == "magic.tag"_catch_sr);
|
||||
}
|
||||
|
||||
TEST_CASE( "empty tags are not allowed", "[tags]" ) {
|
||||
REQUIRE_THROWS(
|
||||
Catch::TestCaseInfo("", { "test with an empty tag", "[]" }, dummySourceLineInfo)
|
||||
);
|
||||
}
|
||||
|
||||
TEST_CASE( "Tags with spaces and non-alphanumerical characters are accepted",
|
||||
"[tags]" ) {
|
||||
using Catch::Tag;
|
||||
using Catch::Matchers::VectorContains;
|
||||
|
||||
Catch::TestCaseInfo testCase(
|
||||
"",
|
||||
{ "fake test name", "[tag with spaces][I said \"good day\" sir!]" },
|
||||
dummySourceLineInfo );
|
||||
|
||||
REQUIRE( testCase.tags.size() == 2 );
|
||||
REQUIRE_THAT( testCase.tags,
|
||||
VectorContains( Tag( "tag with spaces" ) ) &&
|
||||
VectorContains( Tag( "I said \"good day\" sir!"_catch_sr ) ) );
|
||||
}
|
||||
|
||||
TEST_CASE( "Test case with identical tags keeps just one", "[tags]" ) {
|
||||
using Catch::Tag;
|
||||
|
||||
Catch::TestCaseInfo testCase(
|
||||
"",
|
||||
{ "fake test name", "[TaG1][tAg1][TAG1][tag1]" },
|
||||
dummySourceLineInfo );
|
||||
|
||||
REQUIRE( testCase.tags.size() == 1 );
|
||||
REQUIRE( testCase.tags[0] == Tag( "tag1" ) );
|
||||
}
|
||||
|
||||
TEST_CASE( "Empty tag is not allowed" ) {
|
||||
REQUIRE_THROWS( Catch::TestCaseInfo(
|
||||
"", { "fake test name", "[]" }, dummySourceLineInfo ) );
|
||||
}
|
||||
72
externals/catch2/tests/SelfTest/IntrospectiveTests/TestCaseInfoHasher.tests.cpp
vendored
Normal file
72
externals/catch2/tests/SelfTest/IntrospectiveTests/TestCaseInfoHasher.tests.cpp
vendored
Normal file
@@ -0,0 +1,72 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/catch_test_case_info.hpp>
|
||||
#include <catch2/internal/catch_test_case_info_hasher.hpp>
|
||||
|
||||
static constexpr Catch::SourceLineInfo dummySourceLineInfo = CATCH_INTERNAL_LINEINFO;
|
||||
|
||||
using Catch::TestCaseInfo;
|
||||
using Catch::TestCaseInfoHasher;
|
||||
|
||||
TEST_CASE("Hashers with same seed produce same hash", "[test-case-hash]") {
|
||||
TestCaseInfo dummy( "", { "name", "[a-tag]" }, dummySourceLineInfo );
|
||||
|
||||
TestCaseInfoHasher h1( 0x12345678 );
|
||||
TestCaseInfoHasher h2( 0x12345678 );
|
||||
|
||||
REQUIRE( h1( dummy ) == h2( dummy ) );
|
||||
}
|
||||
|
||||
TEST_CASE(
|
||||
"Hashers with different seed produce different hash with same test case",
|
||||
"[test-case-hash]") {
|
||||
TestCaseInfo dummy( "", { "name", "[a-tag]" }, dummySourceLineInfo );
|
||||
|
||||
TestCaseInfoHasher h1( 0x12345678 );
|
||||
TestCaseInfoHasher h2( 0x87654321 );
|
||||
|
||||
REQUIRE( h1( dummy ) != h2( dummy ) );
|
||||
}
|
||||
|
||||
TEST_CASE("Hashing test case produces same hash across multiple calls",
|
||||
"[test-case-hash]") {
|
||||
TestCaseInfo dummy( "", { "name", "[a-tag]" }, dummySourceLineInfo );
|
||||
|
||||
TestCaseInfoHasher h( 0x12345678 );
|
||||
|
||||
REQUIRE( h( dummy ) == h( dummy ) );
|
||||
}
|
||||
|
||||
TEST_CASE("Hashing different test cases produces different result", "[test-case-hash]") {
|
||||
TestCaseInfoHasher h( 0x12345678 );
|
||||
SECTION("Different test name") {
|
||||
TestCaseInfo dummy1( "class", { "name-1", "[a-tag]" }, dummySourceLineInfo );
|
||||
TestCaseInfo dummy2(
|
||||
"class", { "name-2", "[a-tag]" }, dummySourceLineInfo );
|
||||
|
||||
REQUIRE( h( dummy1 ) != h( dummy2 ) );
|
||||
}
|
||||
SECTION("Different classname") {
|
||||
TestCaseInfo dummy1(
|
||||
"class-1", { "name", "[a-tag]" }, dummySourceLineInfo );
|
||||
TestCaseInfo dummy2(
|
||||
"class-2", { "name", "[a-tag]" }, dummySourceLineInfo );
|
||||
|
||||
REQUIRE( h( dummy1 ) != h( dummy2 ) );
|
||||
}
|
||||
SECTION("Different tags") {
|
||||
TestCaseInfo dummy1(
|
||||
"class", { "name", "[a-tag]" }, dummySourceLineInfo );
|
||||
TestCaseInfo dummy2(
|
||||
"class", { "name", "[b-tag]" }, dummySourceLineInfo );
|
||||
|
||||
REQUIRE( h( dummy1 ) != h( dummy2 ) );
|
||||
}
|
||||
}
|
||||
365
externals/catch2/tests/SelfTest/IntrospectiveTests/TestSpec.tests.cpp
vendored
Normal file
365
externals/catch2/tests/SelfTest/IntrospectiveTests/TestSpec.tests.cpp
vendored
Normal file
@@ -0,0 +1,365 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_config.hpp>
|
||||
#include <catch2/catch_approx.hpp>
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/matchers/catch_matchers_string.hpp>
|
||||
#include <catch2/internal/catch_test_spec_parser.hpp>
|
||||
#include <catch2/catch_user_config.hpp>
|
||||
#include <catch2/catch_test_case_info.hpp>
|
||||
#include <catch2/internal/catch_commandline.hpp>
|
||||
#include <catch2/generators/catch_generators.hpp>
|
||||
#include <catch2/internal/catch_compiler_capabilities.hpp>
|
||||
|
||||
#include <helpers/parse_test_spec.hpp>
|
||||
|
||||
namespace {
|
||||
auto fakeTestCase(const char* name, const char* desc = "") { return Catch::makeTestCaseInfo("", { name, desc }, CATCH_INTERNAL_LINEINFO); }
|
||||
}
|
||||
|
||||
TEST_CASE( "Parse test names and tags", "[command-line][test-spec][approvals]" ) {
|
||||
using Catch::parseTestSpec;
|
||||
using Catch::TestSpec;
|
||||
|
||||
auto tcA = fakeTestCase( "a" );
|
||||
auto tcB = fakeTestCase( "b", "[one][x]" );
|
||||
auto tcC = fakeTestCase( "longer name with spaces", "[two][three][.][x]" );
|
||||
auto tcD = fakeTestCase( "zlonger name with spacesz" );
|
||||
|
||||
SECTION( "Empty test spec should have no filters" ) {
|
||||
TestSpec spec;
|
||||
CHECK( spec.hasFilters() == false );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
}
|
||||
|
||||
SECTION( "Test spec from empty string should have no filters" ) {
|
||||
TestSpec spec = parseTestSpec( "" );
|
||||
CHECK( spec.hasFilters() == false );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
}
|
||||
|
||||
SECTION( "Test spec from just a comma should have no filters" ) {
|
||||
TestSpec spec = parseTestSpec( "," );
|
||||
CHECK( spec.hasFilters() == false );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
}
|
||||
|
||||
SECTION( "Test spec from name should have one filter" ) {
|
||||
TestSpec spec = parseTestSpec( "b" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == true );
|
||||
}
|
||||
|
||||
SECTION( "Test spec from quoted name should have one filter" ) {
|
||||
TestSpec spec = parseTestSpec( "\"b\"" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == true );
|
||||
}
|
||||
|
||||
SECTION( "Test spec from name should have one filter" ) {
|
||||
TestSpec spec = parseTestSpec( "b" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == true );
|
||||
CHECK( spec.matches( *tcC ) == false );
|
||||
}
|
||||
|
||||
SECTION( "Wildcard at the start" ) {
|
||||
TestSpec spec = parseTestSpec( "*spaces" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
CHECK( spec.matches( *tcC ) == true );
|
||||
CHECK( spec.matches( *tcD ) == false );
|
||||
CHECK( parseTestSpec( "*a" ).matches( *tcA ) == true );
|
||||
}
|
||||
SECTION( "Wildcard at the end" ) {
|
||||
TestSpec spec = parseTestSpec( "long*" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
CHECK( spec.matches( *tcC ) == true );
|
||||
CHECK( spec.matches( *tcD ) == false );
|
||||
CHECK( parseTestSpec( "a*" ).matches( *tcA ) == true );
|
||||
}
|
||||
SECTION( "Wildcard at both ends" ) {
|
||||
TestSpec spec = parseTestSpec( "*name*" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
CHECK( spec.matches( *tcC ) == true );
|
||||
CHECK( spec.matches( *tcD ) == true );
|
||||
CHECK( parseTestSpec( "*a*" ).matches( *tcA ) == true );
|
||||
}
|
||||
SECTION( "Redundant wildcard at the start" ) {
|
||||
TestSpec spec = parseTestSpec( "*a" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == true );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
}
|
||||
SECTION( "Redundant wildcard at the end" ) {
|
||||
TestSpec spec = parseTestSpec( "a*" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == true );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
}
|
||||
SECTION( "Redundant wildcard at both ends" ) {
|
||||
TestSpec spec = parseTestSpec( "*a*" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == true );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
}
|
||||
SECTION( "Wildcard at both ends, redundant at start" ) {
|
||||
TestSpec spec = parseTestSpec( "*longer*" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
CHECK( spec.matches( *tcC ) == true );
|
||||
CHECK( spec.matches( *tcD ) == true );
|
||||
}
|
||||
SECTION( "Just wildcard" ) {
|
||||
TestSpec spec = parseTestSpec( "*" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == true );
|
||||
CHECK( spec.matches( *tcB ) == true );
|
||||
CHECK( spec.matches( *tcC ) == true );
|
||||
CHECK( spec.matches( *tcD ) == true );
|
||||
}
|
||||
|
||||
SECTION( "Single tag" ) {
|
||||
TestSpec spec = parseTestSpec( "[one]" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == true );
|
||||
CHECK( spec.matches( *tcC ) == false );
|
||||
}
|
||||
SECTION( "Single tag, two matches" ) {
|
||||
TestSpec spec = parseTestSpec( "[x]" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == true );
|
||||
CHECK( spec.matches( *tcC ) == true );
|
||||
}
|
||||
SECTION( "Two tags" ) {
|
||||
TestSpec spec = parseTestSpec( "[two][x]" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
CHECK( spec.matches( *tcC ) == true );
|
||||
}
|
||||
SECTION( "Two tags, spare separated" ) {
|
||||
TestSpec spec = parseTestSpec( "[two] [x]" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
CHECK( spec.matches( *tcC ) == true );
|
||||
}
|
||||
SECTION( "Wildcarded name and tag" ) {
|
||||
TestSpec spec = parseTestSpec( "*name*[x]" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
CHECK( spec.matches( *tcC ) == true );
|
||||
CHECK( spec.matches( *tcD ) == false );
|
||||
}
|
||||
SECTION( "Single tag exclusion" ) {
|
||||
TestSpec spec = parseTestSpec( "~[one]" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == true );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
CHECK( spec.matches( *tcC ) == false );
|
||||
}
|
||||
SECTION( "One tag exclusion and one tag inclusion" ) {
|
||||
TestSpec spec = parseTestSpec( "~[two][x]" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == true );
|
||||
CHECK( spec.matches( *tcC ) == false );
|
||||
}
|
||||
SECTION( "One tag exclusion and one wldcarded name inclusion" ) {
|
||||
TestSpec spec = parseTestSpec( "~[two]*name*" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
CHECK( spec.matches( *tcC ) == false );
|
||||
CHECK( spec.matches( *tcD ) == true );
|
||||
}
|
||||
SECTION( "One tag exclusion, using exclude:, and one wldcarded name inclusion" ) {
|
||||
TestSpec spec = parseTestSpec( "exclude:[two]*name*" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
CHECK( spec.matches( *tcC ) == false );
|
||||
CHECK( spec.matches( *tcD ) == true );
|
||||
}
|
||||
SECTION( "name exclusion" ) {
|
||||
TestSpec spec = parseTestSpec( "~b" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == true );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
CHECK( spec.matches( *tcC ) == false );
|
||||
CHECK( spec.matches( *tcD ) == true );
|
||||
}
|
||||
SECTION( "wildcarded name exclusion" ) {
|
||||
TestSpec spec = parseTestSpec( "~*name*" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == true );
|
||||
CHECK( spec.matches( *tcB ) == true );
|
||||
CHECK( spec.matches( *tcC ) == false );
|
||||
CHECK( spec.matches( *tcD ) == false );
|
||||
}
|
||||
SECTION( "wildcarded name exclusion with tag inclusion" ) {
|
||||
TestSpec spec = parseTestSpec( "~*name*,[three]" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == true );
|
||||
CHECK( spec.matches( *tcB ) == true );
|
||||
CHECK( spec.matches( *tcC ) == true );
|
||||
CHECK( spec.matches( *tcD ) == false );
|
||||
}
|
||||
SECTION( "wildcarded name exclusion, using exclude:, with tag inclusion" ) {
|
||||
TestSpec spec = parseTestSpec( "exclude:*name*,[three]" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == true );
|
||||
CHECK( spec.matches( *tcB ) == true );
|
||||
CHECK( spec.matches( *tcC ) == true );
|
||||
CHECK( spec.matches( *tcD ) == false );
|
||||
}
|
||||
SECTION( "two wildcarded names" ) {
|
||||
TestSpec spec = parseTestSpec( "\"longer*\"\"*spaces\"" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
CHECK( spec.matches( *tcC ) == true );
|
||||
CHECK( spec.matches( *tcD ) == false );
|
||||
}
|
||||
SECTION( "empty tag" ) {
|
||||
TestSpec spec = parseTestSpec( "[]" );
|
||||
CHECK( spec.hasFilters() == false );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
CHECK( spec.matches( *tcC ) == false );
|
||||
CHECK( spec.matches( *tcD ) == false );
|
||||
}
|
||||
SECTION( "empty quoted name" ) {
|
||||
TestSpec spec = parseTestSpec( "\"\"" );
|
||||
CHECK( spec.hasFilters() == false );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
CHECK( spec.matches( *tcC ) == false );
|
||||
CHECK( spec.matches( *tcD ) == false );
|
||||
}
|
||||
SECTION( "quoted string followed by tag exclusion" ) {
|
||||
TestSpec spec = parseTestSpec( "\"*name*\"~[.]" );
|
||||
CHECK( spec.hasFilters() == true );
|
||||
CHECK( spec.matches( *tcA ) == false );
|
||||
CHECK( spec.matches( *tcB ) == false );
|
||||
CHECK( spec.matches( *tcC ) == false );
|
||||
CHECK( spec.matches( *tcD ) == true );
|
||||
}
|
||||
SECTION( "Leading and trailing spaces in test spec" ) {
|
||||
TestSpec spec = parseTestSpec( "\" aardvark \"" );
|
||||
CHECK( spec.matches( *fakeTestCase( " aardvark " ) ) );
|
||||
CHECK( spec.matches( *fakeTestCase( " aardvark" ) ) );
|
||||
CHECK( spec.matches( *fakeTestCase( " aardvark " ) ) );
|
||||
CHECK( spec.matches( *fakeTestCase( "aardvark " ) ) );
|
||||
CHECK( spec.matches( *fakeTestCase( "aardvark" ) ) );
|
||||
|
||||
}
|
||||
SECTION( "Leading and trailing spaces in test name" ) {
|
||||
TestSpec spec = parseTestSpec( "aardvark" );
|
||||
CHECK( spec.matches( *fakeTestCase( " aardvark " ) ) );
|
||||
CHECK( spec.matches( *fakeTestCase( " aardvark" ) ) );
|
||||
CHECK( spec.matches( *fakeTestCase( " aardvark " ) ) );
|
||||
CHECK( spec.matches( *fakeTestCase( "aardvark " ) ) );
|
||||
CHECK( spec.matches( *fakeTestCase( "aardvark" ) ) );
|
||||
}
|
||||
SECTION("Shortened hide tags are split apart when parsing") {
|
||||
TestSpec spec = parseTestSpec("[.foo]");
|
||||
CHECK(spec.matches(*fakeTestCase("hidden and foo", "[.][foo]")));
|
||||
CHECK_FALSE(spec.matches(*fakeTestCase("only foo", "[foo]")));
|
||||
}
|
||||
SECTION("Shortened hide tags also properly handle exclusion") {
|
||||
TestSpec spec = parseTestSpec("~[.foo]");
|
||||
CHECK_FALSE(spec.matches(*fakeTestCase("hidden and foo", "[.][foo]")));
|
||||
CHECK_FALSE(spec.matches(*fakeTestCase("only foo", "[foo]")));
|
||||
CHECK_FALSE(spec.matches(*fakeTestCase("only hidden", "[.]")));
|
||||
CHECK(spec.matches(*fakeTestCase("neither foo nor hidden", "[bar]")));
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("#1905 -- test spec parser properly clears internal state between compound tests", "[command-line][test-spec]") {
|
||||
using Catch::parseTestSpec;
|
||||
using Catch::TestSpec;
|
||||
// We ask for one of 2 different tests and the latter one of them has a , in name that needs escaping
|
||||
TestSpec spec = parseTestSpec(R"("spec . char","spec \, char")");
|
||||
|
||||
REQUIRE(spec.matches(*fakeTestCase("spec . char")));
|
||||
REQUIRE(spec.matches(*fakeTestCase("spec , char")));
|
||||
REQUIRE_FALSE(spec.matches(*fakeTestCase(R"(spec \, char)")));
|
||||
}
|
||||
|
||||
TEST_CASE("#1912 -- test spec parser handles escaping", "[command-line][test-spec]") {
|
||||
using Catch::parseTestSpec;
|
||||
using Catch::TestSpec;
|
||||
|
||||
SECTION("Various parentheses") {
|
||||
TestSpec spec = parseTestSpec(R"(spec {a} char,spec \[a] char)");
|
||||
|
||||
REQUIRE(spec.matches(*fakeTestCase(R"(spec {a} char)")));
|
||||
REQUIRE(spec.matches(*fakeTestCase(R"(spec [a] char)")));
|
||||
REQUIRE_FALSE(spec.matches(*fakeTestCase("differs but has similar tag", "[a]")));
|
||||
}
|
||||
SECTION("backslash in test name") {
|
||||
TestSpec spec = parseTestSpec(R"(spec \\ char)");
|
||||
|
||||
REQUIRE(spec.matches(*fakeTestCase(R"(spec \ char)")));
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("Test spec serialization is round-trippable", "[test-spec][serialization][approvals]") {
|
||||
using Catch::parseTestSpec;
|
||||
using Catch::TestSpec;
|
||||
|
||||
auto serializedTestSpec = []( std::string const& spec ) {
|
||||
Catch::ReusableStringStream sstr;
|
||||
sstr << parseTestSpec( spec );
|
||||
return sstr.str();
|
||||
};
|
||||
|
||||
SECTION("Spaces are normalized") {
|
||||
CHECK( serializedTestSpec( "[abc][def]" ) == "[abc] [def]" );
|
||||
CHECK( serializedTestSpec( "[def] [abc]" ) == "[def] [abc]" );
|
||||
CHECK( serializedTestSpec( "[def] [abc]" ) == "[def] [abc]" );
|
||||
}
|
||||
SECTION("Output is order dependent") {
|
||||
CHECK( serializedTestSpec( "[abc][def]" ) == "[abc] [def]" );
|
||||
CHECK( serializedTestSpec( "[def][abc]" ) == "[def] [abc]" );
|
||||
}
|
||||
SECTION("Multiple disjunct filters") {
|
||||
CHECK( serializedTestSpec( "[abc],[def]" ) == "[abc],[def]" );
|
||||
CHECK( serializedTestSpec( "[def],[abc],[idkfa]" ) == "[def],[abc],[idkfa]" );
|
||||
}
|
||||
SECTION("Test names are enclosed in string") {
|
||||
CHECK( serializedTestSpec( "Some test" ) == "\"Some test\"" );
|
||||
CHECK( serializedTestSpec( "*Some test" ) == "\"*Some test\"" );
|
||||
CHECK( serializedTestSpec( "* Some test" ) == "\"* Some test\"" );
|
||||
CHECK( serializedTestSpec( "* Some test *" ) == "\"* Some test *\"" );
|
||||
}
|
||||
SECTION( "Mixing test names and tags" ) {
|
||||
CHECK( serializedTestSpec( "some test[abcd]" ) ==
|
||||
"\"some test\" [abcd]" );
|
||||
CHECK( serializedTestSpec( "[ab]some test[cd]" ) ==
|
||||
"[ab] \"some test\" [cd]" );
|
||||
}
|
||||
}
|
||||
55
externals/catch2/tests/SelfTest/IntrospectiveTests/TestSpecParser.tests.cpp
vendored
Normal file
55
externals/catch2/tests/SelfTest/IntrospectiveTests/TestSpecParser.tests.cpp
vendored
Normal file
@@ -0,0 +1,55 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/generators/catch_generators.hpp>
|
||||
#include <catch2/catch_test_case_info.hpp>
|
||||
#include <catch2/internal/catch_tag_alias_registry.hpp>
|
||||
#include <catch2/internal/catch_test_spec_parser.hpp>
|
||||
|
||||
namespace {
|
||||
static constexpr Catch::SourceLineInfo dummySourceLineInfo = CATCH_INTERNAL_LINEINFO;
|
||||
|
||||
static Catch::TestSpec parseAndCreateSpec(std::string const& str) {
|
||||
Catch::TagAliasRegistry registry;
|
||||
Catch::TestSpecParser parser( registry );
|
||||
|
||||
parser.parse( str );
|
||||
auto spec = parser.testSpec();
|
||||
REQUIRE( spec.hasFilters() );
|
||||
REQUIRE( spec.getInvalidSpecs().empty());
|
||||
|
||||
return spec;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
TEST_CASE( "Parsing tags with non-alphabetical characters is pass-through",
|
||||
"[test-spec][test-spec-parser]" ) {
|
||||
auto const& tagString = GENERATE( as<std::string>{},
|
||||
"[tag with spaces]",
|
||||
"[I said \"good day\" sir!]" );
|
||||
CAPTURE(tagString);
|
||||
|
||||
auto spec = parseAndCreateSpec( tagString );
|
||||
|
||||
Catch::TestCaseInfo testCase(
|
||||
"", { "fake test name", tagString }, dummySourceLineInfo );
|
||||
|
||||
REQUIRE( spec.matches( testCase ) );
|
||||
}
|
||||
|
||||
TEST_CASE("Parsed tags are matched case insensitive",
|
||||
"[test-spec][test-spec-parser]") {
|
||||
auto spec = parseAndCreateSpec( "[CASED tag]" );
|
||||
|
||||
Catch::TestCaseInfo testCase(
|
||||
"", { "fake test name", "[cased TAG]" }, dummySourceLineInfo );
|
||||
|
||||
REQUIRE( spec.matches( testCase ) );
|
||||
}
|
||||
200
externals/catch2/tests/SelfTest/IntrospectiveTests/TextFlow.tests.cpp
vendored
Normal file
200
externals/catch2/tests/SelfTest/IntrospectiveTests/TextFlow.tests.cpp
vendored
Normal file
@@ -0,0 +1,200 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/internal/catch_textflow.hpp>
|
||||
|
||||
#include <sstream>
|
||||
|
||||
using Catch::TextFlow::Column;
|
||||
|
||||
namespace {
|
||||
static std::string as_written(Column const& c) {
|
||||
std::stringstream sstr;
|
||||
sstr << c;
|
||||
return sstr.str();
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "TextFlow::Column one simple line",
|
||||
"[TextFlow][column][approvals]" ) {
|
||||
Column col( "simple short line" );
|
||||
|
||||
REQUIRE(as_written(col) == "simple short line");
|
||||
}
|
||||
|
||||
TEST_CASE( "TextFlow::Column respects already present newlines",
|
||||
"[TextFlow][column][approvals]" ) {
|
||||
Column col( "abc\ndef" );
|
||||
REQUIRE( as_written( col ) == "abc\ndef" );
|
||||
}
|
||||
|
||||
TEST_CASE( "TextFlow::Column respects width setting",
|
||||
"[TextFlow][column][approvals]" ) {
|
||||
Column col( "The quick brown fox jumped over the lazy dog" );
|
||||
|
||||
SECTION( "width=20" ) {
|
||||
col.width( 20 );
|
||||
REQUIRE( as_written( col ) == "The quick brown fox\n"
|
||||
"jumped over the lazy\n"
|
||||
"dog" );
|
||||
}
|
||||
SECTION("width=10") {
|
||||
col.width( 10 );
|
||||
REQUIRE( as_written( col ) == "The quick\n"
|
||||
"brown fox\n"
|
||||
"jumped\n"
|
||||
"over the\n"
|
||||
"lazy dog" );
|
||||
}
|
||||
SECTION("width=5") {
|
||||
// This is so small some words will have to be split with hyphen
|
||||
col.width(5);
|
||||
REQUIRE( as_written( col ) == "The\n"
|
||||
"quick\n"
|
||||
"brown\n"
|
||||
"fox\n"
|
||||
"jump-\n"
|
||||
"ed\n"
|
||||
"over\n"
|
||||
"the\n"
|
||||
"lazy\n"
|
||||
"dog" );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "TextFlow::Column respects indentation setting",
|
||||
"[TextFlow][column][approvals]" ) {
|
||||
Column col( "First line\nSecond line\nThird line" );
|
||||
|
||||
SECTION("Default: no indentation at all") {
|
||||
REQUIRE(as_written(col) == "First line\nSecond line\nThird line");
|
||||
}
|
||||
SECTION("Indentation on first line only") {
|
||||
col.initialIndent(3);
|
||||
REQUIRE(as_written(col) == " First line\nSecond line\nThird line");
|
||||
}
|
||||
SECTION("Indentation on all lines") {
|
||||
col.indent(3);
|
||||
REQUIRE(as_written(col) == " First line\n Second line\n Third line");
|
||||
}
|
||||
SECTION("Indentation on later lines only") {
|
||||
col.indent(5).initialIndent(0);
|
||||
REQUIRE(as_written(col) == "First line\n Second line\n Third line");
|
||||
}
|
||||
SECTION("Different indentation on first and later lines") {
|
||||
col.initialIndent(1).indent(2);
|
||||
REQUIRE(as_written(col) == " First line\n Second line\n Third line");
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("TextFlow::Column indentation respects whitespace", "[TextFlow][column][approvals]") {
|
||||
Column col(" text with whitespace\n after newlines");
|
||||
|
||||
SECTION("No extra indentation") {
|
||||
col.initialIndent(0).indent(0);
|
||||
REQUIRE(as_written(col) == " text with whitespace\n after newlines");
|
||||
}
|
||||
SECTION("Different indentation on first and later lines") {
|
||||
col.initialIndent(1).indent(2);
|
||||
REQUIRE(as_written(col) == " text with whitespace\n after newlines");
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "TextFlow::Column linebreaking prefers boundary characters",
|
||||
"[TextFlow][column][approvals]" ) {
|
||||
SECTION("parentheses") {
|
||||
Column col("(Hello)aaa(World)");
|
||||
SECTION("width=20") {
|
||||
col.width(20);
|
||||
REQUIRE(as_written(col) == "(Hello)aaa(World)");
|
||||
}
|
||||
SECTION("width=15") {
|
||||
col.width(15);
|
||||
REQUIRE(as_written(col) == "(Hello)aaa\n(World)");
|
||||
}
|
||||
SECTION("width=8") {
|
||||
col.width(8);
|
||||
REQUIRE(as_written(col) == "(Hello)\naaa\n(World)");
|
||||
}
|
||||
}
|
||||
SECTION("commas") {
|
||||
Column col("Hello, world");
|
||||
col.width(8);
|
||||
|
||||
REQUIRE(as_written(col) == "Hello,\nworld");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
TEST_CASE( "TextFlow::Column respects indentation for empty lines",
|
||||
"[TextFlow][column][approvals][!shouldfail]" ) {
|
||||
// This is currently bugged and does not do what it should
|
||||
Column col("\n\nthird line");
|
||||
col.indent(2);
|
||||
|
||||
//auto b = col.begin();
|
||||
//auto e = col.end();
|
||||
|
||||
//auto b1 = *b;
|
||||
//++b;
|
||||
//auto b2 = *b;
|
||||
//++b;
|
||||
//auto b3 = *b;
|
||||
//++b;
|
||||
|
||||
//REQUIRE(b == e);
|
||||
|
||||
std::string written = as_written(col);
|
||||
|
||||
REQUIRE(as_written(col) == " \n \n third line");
|
||||
}
|
||||
|
||||
TEST_CASE( "TextFlow::Column leading/trailing whitespace",
|
||||
"[TextFlow][column][approvals]" ) {
|
||||
SECTION("Trailing whitespace") {
|
||||
Column col("some trailing whitespace: \t");
|
||||
REQUIRE(as_written(col) == "some trailing whitespace: \t");
|
||||
}
|
||||
SECTION("Some leading whitespace") {
|
||||
Column col("\t \t whitespace wooo");
|
||||
REQUIRE(as_written(col) == "\t \t whitespace wooo");
|
||||
}
|
||||
SECTION("both") {
|
||||
Column col(" abc ");
|
||||
REQUIRE(as_written(col) == " abc ");
|
||||
}
|
||||
SECTION("whitespace only") {
|
||||
Column col("\t \t");
|
||||
REQUIRE(as_written(col) == "\t \t");
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "TextFlow::Column can handle empty string",
|
||||
"[TextFlow][column][approvals]" ) {
|
||||
Column col("");
|
||||
REQUIRE(as_written(col) == "");
|
||||
}
|
||||
|
||||
TEST_CASE( "#1400 - TextFlow::Column wrapping would sometimes duplicate words",
|
||||
"[TextFlow][column][regression][approvals]" ) {
|
||||
const auto long_string = std::string(
|
||||
"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque nisl \n"
|
||||
"massa, luctus ut ligula vitae, suscipit tempus velit. Vivamus sodales, quam in \n"
|
||||
"convallis posuere, libero nisi ultricies orci, nec lobortis.\n");
|
||||
|
||||
auto col = Column(long_string)
|
||||
.width(79)
|
||||
.indent(2);
|
||||
|
||||
REQUIRE(as_written(col) ==
|
||||
" Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque nisl \n"
|
||||
" massa, luctus ut ligula vitae, suscipit tempus velit. Vivamus sodales, quam\n"
|
||||
" in \n"
|
||||
" convallis posuere, libero nisi ultricies orci, nec lobortis.");
|
||||
}
|
||||
97
externals/catch2/tests/SelfTest/IntrospectiveTests/ToString.tests.cpp
vendored
Normal file
97
externals/catch2/tests/SelfTest/IntrospectiveTests/ToString.tests.cpp
vendored
Normal file
@@ -0,0 +1,97 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/internal/catch_enum_values_registry.hpp>
|
||||
#include <catch2/matchers/catch_matchers_vector.hpp>
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/catch_template_test_macros.hpp>
|
||||
|
||||
enum class EnumClass3 { Value1, Value2, Value3, Value4 };
|
||||
|
||||
struct UsesSentinel {
|
||||
using const_iterator = int const*;
|
||||
using const_sentinel = std::nullptr_t;
|
||||
|
||||
const_iterator begin() const { return nullptr; }
|
||||
const_iterator end() const { return nullptr; }
|
||||
};
|
||||
|
||||
TEST_CASE( "parseEnums", "[Strings][enums]" ) {
|
||||
using namespace Catch::Matchers;
|
||||
using Catch::Detail::parseEnums;
|
||||
|
||||
SECTION( "No enums" )
|
||||
CHECK_THAT( parseEnums( "" ), Equals( std::vector<Catch::StringRef>{} ) );
|
||||
|
||||
SECTION( "One enum value" ) {
|
||||
CHECK_THAT( parseEnums( "ClassName::EnumName::Value1" ),
|
||||
Equals(std::vector<Catch::StringRef>{"Value1"} ) );
|
||||
CHECK_THAT( parseEnums( "Value1" ),
|
||||
Equals( std::vector<Catch::StringRef>{"Value1"} ) );
|
||||
CHECK_THAT( parseEnums( "EnumName::Value1" ),
|
||||
Equals(std::vector<Catch::StringRef>{"Value1"} ) );
|
||||
}
|
||||
|
||||
SECTION( "Multiple enum values" ) {
|
||||
CHECK_THAT( parseEnums( "ClassName::EnumName::Value1, ClassName::EnumName::Value2" ),
|
||||
Equals( std::vector<Catch::StringRef>{"Value1", "Value2"} ) );
|
||||
CHECK_THAT( parseEnums( "ClassName::EnumName::Value1, ClassName::EnumName::Value2, ClassName::EnumName::Value3" ),
|
||||
Equals( std::vector<Catch::StringRef>{"Value1", "Value2", "Value3"} ) );
|
||||
CHECK_THAT( parseEnums( "ClassName::EnumName::Value1,ClassName::EnumName::Value2 , ClassName::EnumName::Value3" ),
|
||||
Equals( std::vector<Catch::StringRef>{"Value1", "Value2", "Value3"} ) );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "Directly creating an EnumInfo" ) {
|
||||
|
||||
using namespace Catch::Detail;
|
||||
auto enumInfo = makeEnumInfo( "EnumName", "EnumName::Value1, EnumName::Value2", {0, 1} );
|
||||
|
||||
CHECK( enumInfo->lookup(0) == "Value1" );
|
||||
CHECK( enumInfo->lookup(1) == "Value2" );
|
||||
CHECK( enumInfo->lookup(3) == "{** unexpected enum value **}" );
|
||||
}
|
||||
|
||||
TEST_CASE("Range type with sentinel") {
|
||||
CHECK( Catch::Detail::stringify(UsesSentinel{}) == "{ }" );
|
||||
}
|
||||
|
||||
TEST_CASE("convertIntoString stringification helper", "[toString][approvals]") {
|
||||
using namespace std::string_literals;
|
||||
using Catch::Detail::convertIntoString;
|
||||
using namespace Catch;
|
||||
|
||||
SECTION("No escaping") {
|
||||
CHECK(convertIntoString(""_sr, false) == R"("")"s);
|
||||
CHECK(convertIntoString("abcd"_sr, false) == R"("abcd")"s);
|
||||
CHECK(convertIntoString("ab\ncd"_sr, false) == "\"ab\ncd\""s);
|
||||
CHECK(convertIntoString("ab\r\ncd"_sr, false) == "\"ab\r\ncd\""s);
|
||||
CHECK(convertIntoString("ab\"cd"_sr, false) == R"("ab"cd")"s);
|
||||
}
|
||||
SECTION("Escaping invisibles") {
|
||||
CHECK(convertIntoString(""_sr, true) == R"("")"s);
|
||||
CHECK(convertIntoString("ab\ncd"_sr, true) == R"("ab\ncd")"s);
|
||||
CHECK(convertIntoString("ab\r\ncd"_sr, true) == R"("ab\r\ncd")"s);
|
||||
CHECK(convertIntoString("ab\tcd"_sr, true) == R"("ab\tcd")"s);
|
||||
CHECK(convertIntoString("ab\fcd"_sr, true) == R"("ab\fcd")"s);
|
||||
CHECK(convertIntoString("ab\"cd"_sr, true) == R"("ab"cd")"s);
|
||||
}
|
||||
}
|
||||
|
||||
TEMPLATE_TEST_CASE( "Stringifying char arrays with statically known sizes",
|
||||
"[toString]",
|
||||
char,
|
||||
signed char,
|
||||
unsigned char ) {
|
||||
using namespace std::string_literals;
|
||||
TestType with_null_terminator[10] = "abc";
|
||||
CHECK( ::Catch::Detail::stringify( with_null_terminator ) == R"("abc")"s );
|
||||
|
||||
TestType no_null_terminator[3] = { 'a', 'b', 'c' };
|
||||
CHECK( ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s );
|
||||
}
|
||||
45
externals/catch2/tests/SelfTest/IntrospectiveTests/Traits.tests.cpp
vendored
Normal file
45
externals/catch2/tests/SelfTest/IntrospectiveTests/Traits.tests.cpp
vendored
Normal file
@@ -0,0 +1,45 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/internal/catch_compare_traits.hpp>
|
||||
#include <helpers/type_with_lit_0_comparisons.hpp>
|
||||
|
||||
|
||||
#define ADD_TRAIT_TEST_CASE( op ) \
|
||||
TEST_CASE( "is_" #op "_comparable", \
|
||||
"[traits][is_comparable][approvals]" ) { \
|
||||
using Catch::Detail::is_##op##_0_comparable; \
|
||||
using Catch::Detail::is_##op##_comparable; \
|
||||
\
|
||||
STATIC_REQUIRE( is_##op##_comparable<int, int>::value ); \
|
||||
STATIC_REQUIRE( \
|
||||
is_##op##_comparable<std::string, std::string>::value ); \
|
||||
STATIC_REQUIRE( !is_##op##_comparable<int, std::string>::value ); \
|
||||
STATIC_REQUIRE( \
|
||||
!is_##op##_comparable<TypeWithLit0Comparisons, int>::value ); \
|
||||
STATIC_REQUIRE( \
|
||||
!is_##op##_comparable<int, TypeWithLit0Comparisons>::value ); \
|
||||
\
|
||||
STATIC_REQUIRE( is_##op##_0_comparable<int>::value ); \
|
||||
STATIC_REQUIRE( \
|
||||
is_##op##_0_comparable<TypeWithLit0Comparisons>::value ); \
|
||||
STATIC_REQUIRE( !is_##op##_0_comparable<std::string>::value ); \
|
||||
\
|
||||
/* This test fails with MSVC in permissive mode, because of course it does */ \
|
||||
/* STATIC_REQUIRE( !is_##op##_0_comparable<int*>::value ); */ \
|
||||
}
|
||||
|
||||
ADD_TRAIT_TEST_CASE(lt)
|
||||
ADD_TRAIT_TEST_CASE(gt)
|
||||
ADD_TRAIT_TEST_CASE(le)
|
||||
ADD_TRAIT_TEST_CASE(ge)
|
||||
ADD_TRAIT_TEST_CASE(eq)
|
||||
ADD_TRAIT_TEST_CASE(ne)
|
||||
|
||||
#undef ADD_TRAIT_TEST_CASE
|
||||
141
externals/catch2/tests/SelfTest/IntrospectiveTests/UniquePtr.tests.cpp
vendored
Normal file
141
externals/catch2/tests/SelfTest/IntrospectiveTests/UniquePtr.tests.cpp
vendored
Normal file
@@ -0,0 +1,141 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/internal/catch_unique_ptr.hpp>
|
||||
|
||||
#include <tuple>
|
||||
|
||||
namespace {
|
||||
struct unique_ptr_test_helper {
|
||||
bool dummy = false;
|
||||
};
|
||||
} // end unnamed namespace
|
||||
|
||||
TEST_CASE("unique_ptr reimplementation: basic functionality", "[internals][unique-ptr]") {
|
||||
using Catch::Detail::unique_ptr;
|
||||
SECTION("Default constructed unique_ptr is empty") {
|
||||
unique_ptr<int> ptr;
|
||||
REQUIRE_FALSE(ptr);
|
||||
REQUIRE(ptr.get() == nullptr);
|
||||
}
|
||||
SECTION("Take ownership of allocation") {
|
||||
auto naked_ptr = new int{ 0 };
|
||||
unique_ptr<int> ptr(naked_ptr);
|
||||
REQUIRE(ptr);
|
||||
REQUIRE(*ptr == 0);
|
||||
REQUIRE(ptr.get() == naked_ptr);
|
||||
SECTION("Plain reset deallocates") {
|
||||
ptr.reset(); // this makes naked_ptr dangling!
|
||||
REQUIRE_FALSE(ptr);
|
||||
REQUIRE(ptr.get() == nullptr);
|
||||
}
|
||||
SECTION("Reset replaces ownership") {
|
||||
ptr.reset(new int{ 2 });
|
||||
REQUIRE(ptr);
|
||||
REQUIRE(ptr.get() != nullptr);
|
||||
REQUIRE(*ptr == 2);
|
||||
}
|
||||
}
|
||||
SECTION("Release releases ownership") {
|
||||
auto naked_ptr = new int{ 1 };
|
||||
unique_ptr<int> ptr(naked_ptr);
|
||||
ptr.release();
|
||||
CHECK_FALSE(ptr);
|
||||
CHECK(ptr.get() == nullptr);
|
||||
delete naked_ptr;
|
||||
}
|
||||
SECTION("Move constructor") {
|
||||
unique_ptr<int> ptr1(new int{ 1 });
|
||||
auto ptr2(std::move(ptr1));
|
||||
REQUIRE_FALSE(ptr1);
|
||||
REQUIRE(ptr2);
|
||||
REQUIRE(*ptr2 == 1);
|
||||
}
|
||||
SECTION("Move assignment") {
|
||||
unique_ptr<int> ptr1(new int{ 1 }), ptr2(new int{ 2 });
|
||||
ptr1 = std::move(ptr2);
|
||||
REQUIRE_FALSE(ptr2);
|
||||
REQUIRE(ptr1);
|
||||
REQUIRE(*ptr1 == 2);
|
||||
}
|
||||
SECTION("free swap") {
|
||||
unique_ptr<int> ptr1(new int{ 1 }), ptr2(new int{ 2 });
|
||||
swap(ptr1, ptr2);
|
||||
REQUIRE(*ptr1 == 2);
|
||||
REQUIRE(*ptr2 == 1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
namespace {
|
||||
struct base {
|
||||
int i;
|
||||
base(int i_) :i(i_) {}
|
||||
};
|
||||
struct derived : base { using base::base; };
|
||||
struct unrelated {};
|
||||
|
||||
} // end unnamed namespace
|
||||
|
||||
static_assert( std::is_constructible<Catch::Detail::unique_ptr<base>,
|
||||
Catch::Detail::unique_ptr<derived>>::value, "Upcasting is supported");
|
||||
static_assert(!std::is_constructible<Catch::Detail::unique_ptr<derived>,
|
||||
Catch::Detail::unique_ptr<base>>::value, "Downcasting is not supported");
|
||||
static_assert(!std::is_constructible<Catch::Detail::unique_ptr<base>,
|
||||
Catch::Detail::unique_ptr<unrelated>>::value, "Cannot just convert one ptr type to another");
|
||||
|
||||
TEST_CASE("Upcasting special member functions", "[internals][unique-ptr]") {
|
||||
using Catch::Detail::unique_ptr;
|
||||
|
||||
unique_ptr<derived> dptr(new derived{3});
|
||||
SECTION("Move constructor") {
|
||||
unique_ptr<base> bptr(std::move(dptr));
|
||||
REQUIRE(bptr->i == 3);
|
||||
}
|
||||
SECTION("move assignment") {
|
||||
unique_ptr<base> bptr(new base{ 1 });
|
||||
bptr = std::move(dptr);
|
||||
REQUIRE(bptr->i == 3);
|
||||
}
|
||||
}
|
||||
|
||||
namespace {
|
||||
struct move_detector {
|
||||
bool has_moved = false;
|
||||
move_detector() = default;
|
||||
move_detector(move_detector const& rhs) = default;
|
||||
move_detector& operator=(move_detector const& rhs) = default;
|
||||
|
||||
move_detector(move_detector&& rhs) noexcept {
|
||||
rhs.has_moved = true;
|
||||
}
|
||||
move_detector& operator=(move_detector&& rhs) noexcept {
|
||||
rhs.has_moved = true;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
} // end unnamed namespace
|
||||
|
||||
TEST_CASE("make_unique reimplementation", "[internals][unique-ptr]") {
|
||||
using Catch::Detail::make_unique;
|
||||
SECTION("From lvalue copies") {
|
||||
move_detector lval;
|
||||
auto ptr = make_unique<move_detector>(lval);
|
||||
REQUIRE_FALSE(lval.has_moved);
|
||||
}
|
||||
SECTION("From rvalue moves") {
|
||||
move_detector rval;
|
||||
auto ptr = make_unique<move_detector>(std::move(rval));
|
||||
REQUIRE(rval.has_moved);
|
||||
}
|
||||
SECTION("Variadic constructor") {
|
||||
auto ptr = make_unique<std::tuple<int, double, int>>(1, 2., 3);
|
||||
REQUIRE(*ptr == std::tuple<int, double, int>{1, 2., 3});
|
||||
}
|
||||
}
|
||||
183
externals/catch2/tests/SelfTest/IntrospectiveTests/Xml.tests.cpp
vendored
Normal file
183
externals/catch2/tests/SelfTest/IntrospectiveTests/Xml.tests.cpp
vendored
Normal file
@@ -0,0 +1,183 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/internal/catch_xmlwriter.hpp>
|
||||
|
||||
#include <catch2/internal/catch_reusable_string_stream.hpp>
|
||||
#include <catch2/matchers/catch_matchers_string.hpp>
|
||||
|
||||
#include <sstream>
|
||||
|
||||
static std::string encode( std::string const& str, Catch::XmlEncode::ForWhat forWhat = Catch::XmlEncode::ForTextNodes ) {
|
||||
Catch::ReusableStringStream oss;
|
||||
oss << Catch::XmlEncode( str, forWhat );
|
||||
return oss.str();
|
||||
}
|
||||
|
||||
TEST_CASE( "XmlEncode", "[XML]" ) {
|
||||
SECTION( "normal string" ) {
|
||||
REQUIRE( encode( "normal string" ) == "normal string" );
|
||||
}
|
||||
SECTION( "empty string" ) {
|
||||
REQUIRE( encode( "" ) == "" );
|
||||
}
|
||||
SECTION( "string with ampersand" ) {
|
||||
REQUIRE( encode( "smith & jones" ) == "smith & jones" );
|
||||
}
|
||||
SECTION( "string with less-than" ) {
|
||||
REQUIRE( encode( "smith < jones" ) == "smith < jones" );
|
||||
}
|
||||
SECTION( "string with greater-than" ) {
|
||||
REQUIRE( encode( "smith > jones" ) == "smith > jones" );
|
||||
REQUIRE( encode( "smith ]]> jones" ) == "smith ]]> jones" );
|
||||
}
|
||||
SECTION( "string with quotes" ) {
|
||||
std::string stringWithQuotes = "don't \"quote\" me on that";
|
||||
REQUIRE( encode( stringWithQuotes ) == stringWithQuotes );
|
||||
REQUIRE( encode( stringWithQuotes, Catch::XmlEncode::ForAttributes ) == "don't "quote" me on that" );
|
||||
}
|
||||
SECTION( "string with control char (1)" ) {
|
||||
REQUIRE( encode( "[\x01]" ) == "[\\x01]" );
|
||||
}
|
||||
SECTION( "string with control char (x7F)" ) {
|
||||
REQUIRE( encode( "[\x7F]" ) == "[\\x7F]" );
|
||||
}
|
||||
}
|
||||
|
||||
// Thanks to Peter Bindels (dascandy) for some of the tests
|
||||
TEST_CASE("XmlEncode: UTF-8", "[XML][UTF-8][approvals]") {
|
||||
SECTION("Valid utf-8 strings") {
|
||||
CHECK(encode("Here be 👾") == "Here be 👾");
|
||||
CHECK(encode("šš") == "šš");
|
||||
|
||||
CHECK(encode("\xDF\xBF") == "\xDF\xBF"); // 0x7FF
|
||||
CHECK(encode("\xE0\xA0\x80") == "\xE0\xA0\x80"); // 0x800
|
||||
CHECK(encode("\xED\x9F\xBF") == "\xED\x9F\xBF"); // 0xD7FF
|
||||
CHECK(encode("\xEE\x80\x80") == "\xEE\x80\x80"); // 0xE000
|
||||
CHECK(encode("\xEF\xBF\xBF") == "\xEF\xBF\xBF"); // 0xFFFF
|
||||
CHECK(encode("\xF0\x90\x80\x80") == "\xF0\x90\x80\x80"); // 0x10000
|
||||
CHECK(encode("\xF4\x8F\xBF\xBF") == "\xF4\x8F\xBF\xBF"); // 0x10FFFF
|
||||
}
|
||||
SECTION("Invalid utf-8 strings") {
|
||||
SECTION("Various broken strings") {
|
||||
CHECK(encode("Here \xFF be \xF0\x9F\x91\xBE") == "Here \\xFF be 👾");
|
||||
CHECK(encode("\xFF") == "\\xFF");
|
||||
CHECK(encode("\xC5\xC5\xA0") == "\\xC5Š");
|
||||
CHECK(encode("\xF4\x90\x80\x80") == "\\xF4\\x90\\x80\\x80"); // 0x110000 -- out of unicode range
|
||||
}
|
||||
|
||||
SECTION("Overlong encodings") {
|
||||
CHECK(encode("\xC0\x80") == "\\xC0\\x80"); // \0
|
||||
CHECK(encode("\xF0\x80\x80\x80") == "\\xF0\\x80\\x80\\x80"); // Super-over-long \0
|
||||
CHECK(encode("\xC1\xBF") == "\\xC1\\xBF"); // ASCII char as UTF-8 (0x7F)
|
||||
CHECK(encode("\xE0\x9F\xBF") == "\\xE0\\x9F\\xBF"); // 0x7FF
|
||||
CHECK(encode("\xF0\x8F\xBF\xBF") == "\\xF0\\x8F\\xBF\\xBF"); // 0xFFFF
|
||||
}
|
||||
|
||||
// Note that we actually don't modify surrogate pairs, as we do not do strict checking
|
||||
SECTION("Surrogate pairs") {
|
||||
CHECK(encode("\xED\xA0\x80") == "\xED\xA0\x80"); // Invalid surrogate half 0xD800
|
||||
CHECK(encode("\xED\xAF\xBF") == "\xED\xAF\xBF"); // Invalid surrogate half 0xDBFF
|
||||
CHECK(encode("\xED\xB0\x80") == "\xED\xB0\x80"); // Invalid surrogate half 0xDC00
|
||||
CHECK(encode("\xED\xBF\xBF") == "\xED\xBF\xBF"); // Invalid surrogate half 0xDFFF
|
||||
}
|
||||
|
||||
SECTION("Invalid start byte") {
|
||||
CHECK(encode("\x80") == "\\x80");
|
||||
CHECK(encode("\x81") == "\\x81");
|
||||
CHECK(encode("\xBC") == "\\xBC");
|
||||
CHECK(encode("\xBF") == "\\xBF");
|
||||
// Out of range
|
||||
CHECK(encode("\xF5\x80\x80\x80") == "\\xF5\\x80\\x80\\x80");
|
||||
CHECK(encode("\xF6\x80\x80\x80") == "\\xF6\\x80\\x80\\x80");
|
||||
CHECK(encode("\xF7\x80\x80\x80") == "\\xF7\\x80\\x80\\x80");
|
||||
}
|
||||
|
||||
SECTION("Missing continuation byte(s)") {
|
||||
// Missing first continuation byte
|
||||
CHECK(encode("\xDE") == "\\xDE");
|
||||
CHECK(encode("\xDF") == "\\xDF");
|
||||
CHECK(encode("\xE0") == "\\xE0");
|
||||
CHECK(encode("\xEF") == "\\xEF");
|
||||
CHECK(encode("\xF0") == "\\xF0");
|
||||
CHECK(encode("\xF4") == "\\xF4");
|
||||
|
||||
// Missing second continuation byte
|
||||
CHECK(encode("\xE0\x80") == "\\xE0\\x80");
|
||||
CHECK(encode("\xE0\xBF") == "\\xE0\\xBF");
|
||||
CHECK(encode("\xE1\x80") == "\\xE1\\x80");
|
||||
CHECK(encode("\xF0\x80") == "\\xF0\\x80");
|
||||
CHECK(encode("\xF4\x80") == "\\xF4\\x80");
|
||||
|
||||
// Missing third continuation byte
|
||||
CHECK(encode("\xF0\x80\x80") == "\\xF0\\x80\\x80");
|
||||
CHECK(encode("\xF4\x80\x80") == "\\xF4\\x80\\x80");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("XmlWriter writes boolean attributes as true/false", "[XML][XmlWriter]") {
|
||||
using Catch::Matchers::ContainsSubstring;
|
||||
std::stringstream stream;
|
||||
{
|
||||
Catch::XmlWriter xml(stream);
|
||||
|
||||
xml.scopedElement("Element1")
|
||||
.writeAttribute("attr1", true)
|
||||
.writeAttribute("attr2", false);
|
||||
}
|
||||
|
||||
REQUIRE_THAT( stream.str(),
|
||||
ContainsSubstring(R"(attr1="true")") &&
|
||||
ContainsSubstring(R"(attr2="false")") );
|
||||
}
|
||||
|
||||
TEST_CASE("XmlWriter does not escape comments", "[XML][XmlWriter][approvals]") {
|
||||
using Catch::Matchers::ContainsSubstring;
|
||||
std::stringstream stream;
|
||||
{
|
||||
Catch::XmlWriter xml(stream);
|
||||
|
||||
xml.writeComment(R"(unescaped special chars: < > ' " &)");
|
||||
}
|
||||
REQUIRE_THAT( stream.str(),
|
||||
ContainsSubstring(R"(<!-- unescaped special chars: < > ' " & -->)"));
|
||||
}
|
||||
|
||||
TEST_CASE("XmlWriter errors out when writing text without enclosing element", "[XmlWriter][approvals]") {
|
||||
std::stringstream stream;
|
||||
Catch::XmlWriter xml(stream);
|
||||
REQUIRE_THROWS(xml.writeText("some text"));
|
||||
}
|
||||
|
||||
TEST_CASE("XmlWriter escapes text properly", "[XML][XmlWriter][approvals]") {
|
||||
using Catch::Matchers::ContainsSubstring;
|
||||
std::stringstream stream;
|
||||
{
|
||||
Catch::XmlWriter xml(stream);
|
||||
xml.scopedElement("root")
|
||||
.writeText(R"(Special chars need escaping: < > ' " &)");
|
||||
}
|
||||
|
||||
REQUIRE_THAT( stream.str(),
|
||||
ContainsSubstring(R"(Special chars need escaping: < > ' " &)"));
|
||||
}
|
||||
|
||||
TEST_CASE("XmlWriter escapes attributes properly", "[XML][XmlWriter][approvals]") {
|
||||
using Catch::Matchers::ContainsSubstring;
|
||||
std::stringstream stream;
|
||||
{
|
||||
Catch::XmlWriter xml(stream);
|
||||
xml.scopedElement("root")
|
||||
.writeAttribute("some-attribute", R"(Special chars need escaping: < > ' " &)");
|
||||
}
|
||||
|
||||
REQUIRE_THAT(stream.str(),
|
||||
ContainsSubstring(R"(some-attribute="Special chars need escaping: < > ' " &")"));
|
||||
}
|
||||
1
externals/catch2/tests/SelfTest/Misc/invalid-test-names.input
vendored
Normal file
1
externals/catch2/tests/SelfTest/Misc/invalid-test-names.input
vendored
Normal file
@@ -0,0 +1 @@
|
||||
Test with special, characters in \" name
|
||||
2
externals/catch2/tests/SelfTest/Misc/plain-old-tests.input
vendored
Normal file
2
externals/catch2/tests/SelfTest/Misc/plain-old-tests.input
vendored
Normal file
@@ -0,0 +1,2 @@
|
||||
random SECTION tests
|
||||
nested SECTION tests
|
||||
1
externals/catch2/tests/SelfTest/Misc/special-characters-in-file.input
vendored
Normal file
1
externals/catch2/tests/SelfTest/Misc/special-characters-in-file.input
vendored
Normal file
@@ -0,0 +1 @@
|
||||
Test with special\, characters \"in name
|
||||
181
externals/catch2/tests/SelfTest/TestRegistrations.cpp
vendored
Normal file
181
externals/catch2/tests/SelfTest/TestRegistrations.cpp
vendored
Normal file
@@ -0,0 +1,181 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_tag_alias_autoregistrar.hpp>
|
||||
#include <catch2/reporters/catch_reporter_event_listener.hpp>
|
||||
#include <catch2/internal/catch_enforce.hpp>
|
||||
#include <catch2/catch_test_case_info.hpp>
|
||||
#include <catch2/reporters/catch_reporter_registrars.hpp>
|
||||
|
||||
|
||||
// Some example tag aliases
|
||||
CATCH_REGISTER_TAG_ALIAS("[@nhf]", "[failing]~[.]")
|
||||
CATCH_REGISTER_TAG_ALIAS("[@tricky]", "[tricky]~[.]")
|
||||
|
||||
#ifdef __clang__
|
||||
# pragma clang diagnostic ignored "-Wpadded"
|
||||
# pragma clang diagnostic ignored "-Wweak-vtables"
|
||||
# pragma clang diagnostic ignored "-Wc++98-compat"
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Event listener that internally counts and validates received events.
|
||||
*
|
||||
* Currently only performs validation by counting received events, rather
|
||||
* than performing full matching. This means that it won't fail if the *Ended
|
||||
* events are provided in wrong order, as long as they come in the right amount
|
||||
* and with the right nesting.
|
||||
*/
|
||||
class ValidatingTestListener : public Catch::EventListenerBase {
|
||||
struct EventCounter {
|
||||
int starting = 0;
|
||||
int ended = 0;
|
||||
|
||||
bool hasActiveEvent() const {
|
||||
return starting > ended;
|
||||
}
|
||||
bool hasSingleActiveEvent() const {
|
||||
return starting - 1 == ended;
|
||||
}
|
||||
bool allEventsEnded() const {
|
||||
return starting == ended;
|
||||
}
|
||||
};
|
||||
|
||||
public:
|
||||
static std::string getDescription() {
|
||||
return "Validates ordering of Catch2's listener events";
|
||||
}
|
||||
|
||||
ValidatingTestListener(Catch::IConfig const* config) :
|
||||
EventListenerBase(config) {
|
||||
m_preferences.shouldReportAllAssertions = true;
|
||||
}
|
||||
|
||||
void testRunStarting( Catch::TestRunInfo const& ) override {
|
||||
CATCH_ENFORCE( m_testRunCounter.starting == 0,
|
||||
"Test run can only start once" );
|
||||
++m_testRunCounter.starting;
|
||||
}
|
||||
void testCaseStarting(Catch::TestCaseInfo const&) override {
|
||||
CATCH_ENFORCE( m_testRunCounter.hasActiveEvent(),
|
||||
"Test case can only be started if the test run has already started" );
|
||||
CATCH_ENFORCE( m_testCaseCounter.allEventsEnded(),
|
||||
"Test case cannot start if there is an unfinished one" );
|
||||
|
||||
++m_testCaseCounter.starting;
|
||||
|
||||
// Reset the part tracking for partial test case events
|
||||
m_lastSeenPartNumber = uint64_t(-1);
|
||||
}
|
||||
|
||||
void testCasePartialStarting(Catch::TestCaseInfo const&,
|
||||
uint64_t partNumber) override {
|
||||
CATCH_ENFORCE( m_testCaseCounter.hasSingleActiveEvent(),
|
||||
"Test case can only be partially started if the test case has fully started already" );
|
||||
CATCH_ENFORCE( m_lastSeenPartNumber + 1 == partNumber,
|
||||
"Partial test case started out of order" );
|
||||
|
||||
++m_testCasePartialCounter.starting;
|
||||
m_lastSeenPartNumber = partNumber;
|
||||
}
|
||||
|
||||
void sectionStarting(Catch::SectionInfo const&) override {
|
||||
CATCH_ENFORCE( m_testCaseCounter.hasSingleActiveEvent(),
|
||||
"Section can only start in a test case" );
|
||||
CATCH_ENFORCE( m_testCasePartialCounter.hasSingleActiveEvent(),
|
||||
"Section can only start in a test case" );
|
||||
|
||||
++m_sectionCounter.starting;
|
||||
}
|
||||
|
||||
void assertionStarting(Catch::AssertionInfo const&) override {
|
||||
CATCH_ENFORCE( m_testCaseCounter.hasSingleActiveEvent(),
|
||||
"Assertion can only start if test case is started" );
|
||||
|
||||
++m_assertionCounter.starting;
|
||||
}
|
||||
void assertionEnded(Catch::AssertionStats const&) override {
|
||||
// todo:
|
||||
// * Check that assertions are balanced
|
||||
// * Check that assertions has started
|
||||
++m_assertionCounter.ended;
|
||||
}
|
||||
|
||||
void sectionEnded(Catch::SectionStats const&) override {
|
||||
CATCH_ENFORCE( m_sectionCounter.hasActiveEvent(),
|
||||
"Section ended without corresponding start" );
|
||||
// TODO: Check that all assertions ended
|
||||
|
||||
++m_sectionCounter.ended;
|
||||
}
|
||||
|
||||
|
||||
void testCasePartialEnded(Catch::TestCaseStats const&,
|
||||
uint64_t partNumber) override {
|
||||
CATCH_ENFORCE( m_lastSeenPartNumber == partNumber,
|
||||
"Partial test case ended out of order" );
|
||||
CATCH_ENFORCE( m_testCasePartialCounter.hasSingleActiveEvent(),
|
||||
"Partial test case ended without corresponding start" );
|
||||
CATCH_ENFORCE( m_sectionCounter.allEventsEnded(),
|
||||
"Partial test case ended with unbalanced sections" );
|
||||
// TODO: Check that all assertions ended
|
||||
|
||||
++m_testCasePartialCounter.ended;
|
||||
}
|
||||
|
||||
|
||||
void testCaseEnded(Catch::TestCaseStats const&) override {
|
||||
CATCH_ENFORCE( m_testCaseCounter.hasSingleActiveEvent(),
|
||||
"Test case end is not matched with test case start" );
|
||||
CATCH_ENFORCE( m_testCasePartialCounter.allEventsEnded(),
|
||||
"A partial test case has not ended" );
|
||||
CATCH_ENFORCE( m_sectionCounter.allEventsEnded(),
|
||||
"Test case ended with unbalanced sections" );
|
||||
|
||||
// TODO: Check that all assertions ended
|
||||
|
||||
++m_testCaseCounter.ended;
|
||||
}
|
||||
void testRunEnded( Catch::TestRunStats const& ) override {
|
||||
CATCH_ENFORCE( m_testRunCounter.hasSingleActiveEvent(),
|
||||
"Test run end is not matched with test run start" );
|
||||
CATCH_ENFORCE( m_testRunCounter.ended == 0,
|
||||
"Test run can only end once" );
|
||||
|
||||
++m_testRunCounter.ended;
|
||||
}
|
||||
|
||||
~ValidatingTestListener() override;
|
||||
|
||||
private:
|
||||
EventCounter m_testRunCounter;
|
||||
EventCounter m_testCaseCounter;
|
||||
EventCounter m_testCasePartialCounter;
|
||||
uint64_t m_lastSeenPartNumber = 0;
|
||||
EventCounter m_sectionCounter;
|
||||
EventCounter m_assertionCounter;
|
||||
};
|
||||
|
||||
|
||||
ValidatingTestListener::~ValidatingTestListener() {
|
||||
// Throwing from noexcept destructor terminates, but we don't mind
|
||||
// because this is test-only check and we don't need to try and recover
|
||||
// from assumption violation here.
|
||||
|
||||
CATCH_ENFORCE( m_testRunCounter.ended < 2,
|
||||
"Test run should be started at most once" );
|
||||
CATCH_ENFORCE( m_testRunCounter.allEventsEnded(),
|
||||
"The test run has not finished" );
|
||||
CATCH_ENFORCE( m_testCaseCounter.allEventsEnded(),
|
||||
"A test case did not finish" );
|
||||
|
||||
// TODO: other counters being balanced?
|
||||
}
|
||||
|
||||
CATCH_REGISTER_LISTENER( ValidatingTestListener )
|
||||
24
externals/catch2/tests/SelfTest/TimingTests/Sleep.tests.cpp
vendored
Normal file
24
externals/catch2/tests/SelfTest/TimingTests/Sleep.tests.cpp
vendored
Normal file
@@ -0,0 +1,24 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
|
||||
#include <chrono>
|
||||
#include <thread>
|
||||
|
||||
TEST_CASE( "sleep_for_100ms", "[.min_duration_test][approvals]" )
|
||||
{
|
||||
std::this_thread::sleep_for( std::chrono::milliseconds( 100 ) );
|
||||
CHECK( true );
|
||||
}
|
||||
|
||||
TEST_CASE( "sleep_for_1000ms", "[.min_duration_test][approvals]" )
|
||||
{
|
||||
std::this_thread::sleep_for( std::chrono::milliseconds( 1'000 ) );
|
||||
CHECK( true );
|
||||
}
|
||||
218
externals/catch2/tests/SelfTest/UsageTests/Approx.tests.cpp
vendored
Normal file
218
externals/catch2/tests/SelfTest/UsageTests/Approx.tests.cpp
vendored
Normal file
@@ -0,0 +1,218 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/catch_approx.hpp>
|
||||
|
||||
#include <cmath>
|
||||
|
||||
using Catch::Approx;
|
||||
|
||||
namespace {
|
||||
static double divide(double a, double b) {
|
||||
return a / b;
|
||||
}
|
||||
|
||||
class StrongDoubleTypedef {
|
||||
double d_ = 0.0;
|
||||
|
||||
public:
|
||||
explicit StrongDoubleTypedef(double d) : d_(d) {}
|
||||
explicit operator double() const { return d_; }
|
||||
};
|
||||
|
||||
static std::ostream& operator<<(std::ostream& os, StrongDoubleTypedef td) {
|
||||
return os << "StrongDoubleTypedef(" << static_cast<double>(td) << ")";
|
||||
}
|
||||
} // end unnamed namespace
|
||||
|
||||
using namespace Catch::literals;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
TEST_CASE( "A comparison that uses literals instead of the normal constructor", "[Approx]" ) {
|
||||
double d = 1.23;
|
||||
|
||||
REQUIRE( d == 1.23_a );
|
||||
REQUIRE( d != 1.22_a );
|
||||
REQUIRE( -d == -1.23_a );
|
||||
|
||||
REQUIRE( d == 1.2_a .epsilon(.1) );
|
||||
REQUIRE( d != 1.2_a .epsilon(.001) );
|
||||
REQUIRE( d == 1_a .epsilon(.3) );
|
||||
}
|
||||
|
||||
TEST_CASE( "Some simple comparisons between doubles", "[Approx]" ) {
|
||||
double d = 1.23;
|
||||
|
||||
REQUIRE( d == Approx( 1.23 ) );
|
||||
REQUIRE( d != Approx( 1.22 ) );
|
||||
REQUIRE( d != Approx( 1.24 ) );
|
||||
|
||||
REQUIRE( d == 1.23_a );
|
||||
REQUIRE( d != 1.22_a );
|
||||
|
||||
REQUIRE( Approx( d ) == 1.23 );
|
||||
REQUIRE( Approx( d ) != 1.22 );
|
||||
REQUIRE( Approx( d ) != 1.24 );
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
TEST_CASE( "Approximate comparisons with different epsilons", "[Approx]" ) {
|
||||
double d = 1.23;
|
||||
|
||||
REQUIRE( d != Approx( 1.231 ) );
|
||||
REQUIRE( d == Approx( 1.231 ).epsilon( 0.1 ) );
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
TEST_CASE( "Less-than inequalities with different epsilons", "[Approx]" ) {
|
||||
double d = 1.23;
|
||||
|
||||
REQUIRE( d <= Approx( 1.24 ) );
|
||||
REQUIRE( d <= Approx( 1.23 ) );
|
||||
REQUIRE_FALSE( d <= Approx( 1.22 ) );
|
||||
REQUIRE( d <= Approx( 1.22 ).epsilon(0.1) );
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
TEST_CASE( "Greater-than inequalities with different epsilons", "[Approx]" ) {
|
||||
double d = 1.23;
|
||||
|
||||
REQUIRE( d >= Approx( 1.22 ) );
|
||||
REQUIRE( d >= Approx( 1.23 ) );
|
||||
REQUIRE_FALSE( d >= Approx( 1.24 ) );
|
||||
REQUIRE( d >= Approx( 1.24 ).epsilon(0.1) );
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
TEST_CASE( "Approximate comparisons with floats", "[Approx]" ) {
|
||||
REQUIRE( 1.23f == Approx( 1.23f ) );
|
||||
REQUIRE( 0.0f == Approx( 0.0f ) );
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
TEST_CASE( "Approximate comparisons with ints", "[Approx]" ) {
|
||||
REQUIRE( 1 == Approx( 1 ) );
|
||||
REQUIRE( 0 == Approx( 0 ) );
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
TEST_CASE( "Approximate comparisons with mixed numeric types", "[Approx]" ) {
|
||||
const double dZero = 0;
|
||||
const double dSmall = 0.00001;
|
||||
const double dMedium = 1.234;
|
||||
|
||||
REQUIRE( 1.0f == Approx( 1 ) );
|
||||
REQUIRE( 0 == Approx( dZero) );
|
||||
REQUIRE( 0 == Approx( dSmall ).margin( 0.001 ) );
|
||||
REQUIRE( 1.234f == Approx( dMedium ) );
|
||||
REQUIRE( dMedium == Approx( 1.234f ) );
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
TEST_CASE( "Use a custom approx", "[Approx][custom]" ) {
|
||||
double d = 1.23;
|
||||
|
||||
Approx approx = Approx::custom().epsilon( 0.01 );
|
||||
|
||||
REQUIRE( d == approx( 1.23 ) );
|
||||
REQUIRE( d == approx( 1.22 ) );
|
||||
REQUIRE( d == approx( 1.24 ) );
|
||||
REQUIRE( d != approx( 1.25 ) );
|
||||
|
||||
REQUIRE( approx( d ) == 1.23 );
|
||||
REQUIRE( approx( d ) == 1.22 );
|
||||
REQUIRE( approx( d ) == 1.24 );
|
||||
REQUIRE( approx( d ) != 1.25 );
|
||||
}
|
||||
|
||||
TEST_CASE( "Approximate PI", "[Approx][PI]" ) {
|
||||
REQUIRE( divide( 22, 7 ) == Approx( 3.141 ).epsilon( 0.001 ) );
|
||||
REQUIRE( divide( 22, 7 ) != Approx( 3.141 ).epsilon( 0.0001 ) );
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
TEST_CASE( "Absolute margin", "[Approx]" ) {
|
||||
REQUIRE( 104.0 != Approx(100.0) );
|
||||
REQUIRE( 104.0 == Approx(100.0).margin(5) );
|
||||
REQUIRE( 104.0 == Approx(100.0).margin(4) );
|
||||
REQUIRE( 104.0 != Approx(100.0).margin(3) );
|
||||
REQUIRE( 100.3 != Approx(100.0) );
|
||||
REQUIRE( 100.3 == Approx(100.0).margin(0.5) );
|
||||
}
|
||||
|
||||
TEST_CASE("Approx with exactly-representable margin", "[Approx]") {
|
||||
CHECK( 0.25f == Approx(0.0f).margin(0.25f) );
|
||||
|
||||
CHECK( 0.0f == Approx(0.25f).margin(0.25f) );
|
||||
CHECK( 0.5f == Approx(0.25f).margin(0.25f) );
|
||||
|
||||
CHECK( 245.0f == Approx(245.25f).margin(0.25f) );
|
||||
CHECK( 245.5f == Approx(245.25f).margin(0.25f) );
|
||||
}
|
||||
|
||||
TEST_CASE("Approx setters validate their arguments", "[Approx]") {
|
||||
REQUIRE_NOTHROW(Approx(0).margin(0));
|
||||
REQUIRE_NOTHROW(Approx(0).margin(1234656));
|
||||
|
||||
REQUIRE_THROWS_AS(Approx(0).margin(-2), std::domain_error);
|
||||
|
||||
REQUIRE_NOTHROW(Approx(0).epsilon(0));
|
||||
REQUIRE_NOTHROW(Approx(0).epsilon(1));
|
||||
|
||||
REQUIRE_THROWS_AS(Approx(0).epsilon(-0.001), std::domain_error);
|
||||
REQUIRE_THROWS_AS(Approx(0).epsilon(1.0001), std::domain_error);
|
||||
}
|
||||
|
||||
TEST_CASE("Default scale is invisible to comparison", "[Approx]") {
|
||||
REQUIRE(101.000001 != Approx(100).epsilon(0.01));
|
||||
REQUIRE(std::pow(10, -5) != Approx(std::pow(10, -7)));
|
||||
}
|
||||
|
||||
TEST_CASE("Epsilon only applies to Approx's value", "[Approx]") {
|
||||
REQUIRE(101.01 != Approx(100).epsilon(0.01));
|
||||
}
|
||||
|
||||
TEST_CASE("Assorted miscellaneous tests", "[Approx][approvals]") {
|
||||
REQUIRE(INFINITY == Approx(INFINITY));
|
||||
REQUIRE(-INFINITY != Approx(INFINITY));
|
||||
REQUIRE(1 != Approx(INFINITY));
|
||||
REQUIRE(INFINITY != Approx(1));
|
||||
REQUIRE(NAN != Approx(NAN));
|
||||
REQUIRE_FALSE(NAN == Approx(NAN));
|
||||
}
|
||||
|
||||
TEST_CASE( "Comparison with explicitly convertible types", "[Approx]" )
|
||||
{
|
||||
StrongDoubleTypedef td(10.0);
|
||||
|
||||
REQUIRE(td == Approx(10.0));
|
||||
REQUIRE(Approx(10.0) == td);
|
||||
|
||||
REQUIRE(td != Approx(11.0));
|
||||
REQUIRE(Approx(11.0) != td);
|
||||
|
||||
REQUIRE(td <= Approx(10.0));
|
||||
REQUIRE(td <= Approx(11.0));
|
||||
REQUIRE(Approx(10.0) <= td);
|
||||
REQUIRE(Approx(9.0) <= td);
|
||||
|
||||
REQUIRE(td >= Approx(9.0));
|
||||
REQUIRE(td >= Approx(td));
|
||||
REQUIRE(Approx(td) >= td);
|
||||
REQUIRE(Approx(11.0) >= td);
|
||||
|
||||
}
|
||||
|
||||
TEST_CASE("Approx::operator() is const correct", "[Approx][.approvals]") {
|
||||
const Approx ap = Approx(0.0).margin(0.01);
|
||||
|
||||
// As long as this compiles, the test should be considered passing
|
||||
REQUIRE(1.0 == ap(1.0));
|
||||
}
|
||||
106
externals/catch2/tests/SelfTest/UsageTests/BDD.tests.cpp
vendored
Normal file
106
externals/catch2/tests/SelfTest/UsageTests/BDD.tests.cpp
vendored
Normal file
@@ -0,0 +1,106 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
|
||||
namespace {
|
||||
|
||||
static bool itDoesThis() { return true; }
|
||||
|
||||
static bool itDoesThat() { return true; }
|
||||
|
||||
// a trivial fixture example to support SCENARIO_METHOD tests
|
||||
struct Fixture {
|
||||
Fixture(): d_counter( 0 ) {}
|
||||
|
||||
int counter() { return d_counter++; }
|
||||
|
||||
int d_counter;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
|
||||
SCENARIO("Do that thing with the thing", "[Tags]") {
|
||||
GIVEN("This stuff exists") {
|
||||
// make stuff exist
|
||||
AND_GIVEN("And some assumption") {
|
||||
// Validate assumption
|
||||
WHEN("I do this") {
|
||||
// do this
|
||||
THEN("it should do this") {
|
||||
REQUIRE(itDoesThis());
|
||||
AND_THEN("do that") {
|
||||
REQUIRE(itDoesThat());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SCENARIO( "Vector resizing affects size and capacity",
|
||||
"[vector][bdd][size][capacity]" ) {
|
||||
GIVEN( "an empty vector" ) {
|
||||
std::vector<int> v;
|
||||
REQUIRE( v.size() == 0 );
|
||||
|
||||
WHEN( "it is made larger" ) {
|
||||
v.resize( 10 );
|
||||
THEN( "the size and capacity go up" ) {
|
||||
REQUIRE( v.size() == 10 );
|
||||
REQUIRE( v.capacity() >= 10 );
|
||||
|
||||
AND_WHEN( "it is made smaller again" ) {
|
||||
v.resize( 5 );
|
||||
THEN(
|
||||
"the size goes down but the capacity stays the same" ) {
|
||||
REQUIRE( v.size() == 5 );
|
||||
REQUIRE( v.capacity() >= 10 );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
WHEN( "we reserve more space" ) {
|
||||
v.reserve( 10 );
|
||||
THEN( "The capacity is increased but the size remains the same" ) {
|
||||
REQUIRE( v.capacity() >= 10 );
|
||||
REQUIRE( v.size() == 0 );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SCENARIO("This is a really long scenario name to see how the list command deals with wrapping",
|
||||
"[very long tags][lots][long][tags][verbose]"
|
||||
"[one very long tag name that should cause line wrapping writing out using the list command]"
|
||||
"[anotherReallyLongTagNameButThisOneHasNoObviousWrapPointsSoShouldSplitWithinAWordUsingADashCharacter]") {
|
||||
GIVEN("A section name that is so long that it cannot fit in a single console width") {
|
||||
WHEN("The test headers are printed as part of the normal running of the scenario") {
|
||||
THEN("The, deliberately very long and overly verbose (you see what I did there?) section names must wrap, along with an indent") {
|
||||
SUCCEED("boo!");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SCENARIO_METHOD(Fixture,
|
||||
"BDD tests requiring Fixtures to provide commonly-accessed data or methods",
|
||||
"[bdd][fixtures]") {
|
||||
const int before(counter());
|
||||
GIVEN("No operations precede me") {
|
||||
REQUIRE(before == 0);
|
||||
WHEN("We get the count") {
|
||||
const int after(counter());
|
||||
THEN("Subsequently values are higher") {
|
||||
REQUIRE(after > before);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
173
externals/catch2/tests/SelfTest/UsageTests/Benchmark.tests.cpp
vendored
Normal file
173
externals/catch2/tests/SelfTest/UsageTests/Benchmark.tests.cpp
vendored
Normal file
@@ -0,0 +1,173 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
// Adapted from donated nonius code.
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/benchmark/catch_benchmark.hpp>
|
||||
#include <catch2/benchmark/catch_constructor.hpp>
|
||||
#include <catch2/generators/catch_generators_range.hpp>
|
||||
|
||||
#include <map>
|
||||
|
||||
namespace {
|
||||
std::uint64_t Fibonacci(std::uint64_t number) {
|
||||
return number < 2 ? number : Fibonacci(number - 1) + Fibonacci(number - 2);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("Benchmark Fibonacci", "[!benchmark]") {
|
||||
CHECK(Fibonacci(0) == 0);
|
||||
// some more asserts..
|
||||
CHECK(Fibonacci(5) == 5);
|
||||
// some more asserts..
|
||||
|
||||
REQUIRE( Fibonacci( 20 ) == 6'765 );
|
||||
BENCHMARK( "Fibonacci 20" ) {
|
||||
return Fibonacci(20);
|
||||
};
|
||||
|
||||
REQUIRE( Fibonacci( 25 ) == 75'025 );
|
||||
BENCHMARK( "Fibonacci 25" ) {
|
||||
return Fibonacci(25);
|
||||
};
|
||||
|
||||
BENCHMARK("Fibonacci 30") {
|
||||
return Fibonacci(30);
|
||||
};
|
||||
|
||||
BENCHMARK("Fibonacci 35") {
|
||||
return Fibonacci(35);
|
||||
};
|
||||
}
|
||||
|
||||
TEST_CASE("Benchmark containers", "[!benchmark]") {
|
||||
static const int size = 100;
|
||||
|
||||
std::vector<int> v;
|
||||
std::map<int, int> m;
|
||||
|
||||
SECTION("without generator") {
|
||||
BENCHMARK("Load up a vector") {
|
||||
v = std::vector<int>();
|
||||
for (int i = 0; i < size; ++i)
|
||||
v.push_back(i);
|
||||
};
|
||||
REQUIRE(v.size() == size);
|
||||
|
||||
// test optimizer control
|
||||
BENCHMARK("Add up a vector's content") {
|
||||
uint64_t add = 0;
|
||||
for (int i = 0; i < size; ++i)
|
||||
add += v[i];
|
||||
return add;
|
||||
};
|
||||
|
||||
BENCHMARK("Load up a map") {
|
||||
m = std::map<int, int>();
|
||||
for (int i = 0; i < size; ++i)
|
||||
m.insert({ i, i + 1 });
|
||||
};
|
||||
REQUIRE(m.size() == size);
|
||||
|
||||
BENCHMARK("Reserved vector") {
|
||||
v = std::vector<int>();
|
||||
v.reserve(size);
|
||||
for (int i = 0; i < size; ++i)
|
||||
v.push_back(i);
|
||||
};
|
||||
REQUIRE(v.size() == size);
|
||||
|
||||
BENCHMARK("Resized vector") {
|
||||
v = std::vector<int>();
|
||||
v.resize(size);
|
||||
for (int i = 0; i < size; ++i)
|
||||
v[i] = i;
|
||||
};
|
||||
REQUIRE(v.size() == size);
|
||||
|
||||
int array[size];
|
||||
BENCHMARK("A fixed size array that should require no allocations") {
|
||||
for (int i = 0; i < size; ++i)
|
||||
array[i] = i;
|
||||
};
|
||||
int sum = 0;
|
||||
for (int i = 0; i < size; ++i)
|
||||
sum += array[i];
|
||||
REQUIRE(sum > size);
|
||||
|
||||
SECTION("XYZ") {
|
||||
|
||||
BENCHMARK_ADVANCED("Load up vector with chronometer")(Catch::Benchmark::Chronometer meter) {
|
||||
std::vector<int> k;
|
||||
meter.measure([&](int idx) {
|
||||
k = std::vector<int>();
|
||||
for (int i = 0; i < size; ++i)
|
||||
k.push_back(idx);
|
||||
});
|
||||
REQUIRE(k.size() == size);
|
||||
};
|
||||
|
||||
int runs = 0;
|
||||
BENCHMARK("Fill vector indexed", benchmarkIndex) {
|
||||
v = std::vector<int>();
|
||||
v.resize(size);
|
||||
for (int i = 0; i < size; ++i)
|
||||
v[i] = benchmarkIndex;
|
||||
runs = benchmarkIndex;
|
||||
};
|
||||
|
||||
for (size_t i = 0; i < v.size(); ++i) {
|
||||
REQUIRE(v[i] == runs);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SECTION("with generator") {
|
||||
auto generated = GENERATE(range(0, 10));
|
||||
BENCHMARK("Fill vector generated") {
|
||||
v = std::vector<int>();
|
||||
v.resize(size);
|
||||
for (int i = 0; i < size; ++i)
|
||||
v[i] = generated;
|
||||
};
|
||||
for (size_t i = 0; i < v.size(); ++i) {
|
||||
REQUIRE(v[i] == generated);
|
||||
}
|
||||
}
|
||||
|
||||
SECTION("construct and destroy example") {
|
||||
BENCHMARK_ADVANCED("construct")(Catch::Benchmark::Chronometer meter) {
|
||||
std::vector<Catch::Benchmark::storage_for<std::string>> storage(meter.runs());
|
||||
meter.measure([&](int i) { storage[i].construct("thing"); });
|
||||
};
|
||||
|
||||
BENCHMARK_ADVANCED("destroy")(Catch::Benchmark::Chronometer meter) {
|
||||
std::vector<Catch::Benchmark::destructable_object<std::string>> storage(meter.runs());
|
||||
for(auto&& o : storage)
|
||||
o.construct("thing");
|
||||
meter.measure([&](int i) { storage[i].destruct(); });
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("Skip benchmark macros", "[!benchmark]") {
|
||||
std::vector<int> v;
|
||||
BENCHMARK("fill vector") {
|
||||
v.emplace_back(1);
|
||||
v.emplace_back(2);
|
||||
v.emplace_back(3);
|
||||
};
|
||||
REQUIRE(v.size() == 0);
|
||||
|
||||
std::size_t counter{0};
|
||||
BENCHMARK_ADVANCED("construct vector")(Catch::Benchmark::Chronometer meter) {
|
||||
std::vector<Catch::Benchmark::storage_for<std::string>> storage(meter.runs());
|
||||
meter.measure([&](int i) { storage[i].construct("thing"); counter++; });
|
||||
};
|
||||
REQUIRE(counter == 0);
|
||||
}
|
||||
133
externals/catch2/tests/SelfTest/UsageTests/Class.tests.cpp
vendored
Normal file
133
externals/catch2/tests/SelfTest/UsageTests/Class.tests.cpp
vendored
Normal file
@@ -0,0 +1,133 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#if defined( __GNUC__ ) || defined( __clang__ )
|
||||
# pragma GCC diagnostic ignored "-Wfloat-equal"
|
||||
#endif
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/catch_template_test_macros.hpp>
|
||||
#include <array>
|
||||
|
||||
namespace {
|
||||
|
||||
class TestClass {
|
||||
std::string s;
|
||||
|
||||
public:
|
||||
TestClass(): s( "hello" ) {}
|
||||
|
||||
void succeedingCase() { REQUIRE( s == "hello" ); }
|
||||
void failingCase() { REQUIRE( s == "world" ); }
|
||||
};
|
||||
|
||||
struct Fixture {
|
||||
Fixture(): m_a( 1 ) {}
|
||||
|
||||
int m_a;
|
||||
};
|
||||
|
||||
template <typename T> struct Template_Fixture {
|
||||
Template_Fixture(): m_a( 1 ) {}
|
||||
|
||||
T m_a;
|
||||
};
|
||||
|
||||
template <typename T> struct Template_Fixture_2 {
|
||||
Template_Fixture_2() {}
|
||||
|
||||
T m_a;
|
||||
};
|
||||
|
||||
template <typename T> struct Template_Foo {
|
||||
size_t size() { return 0; }
|
||||
};
|
||||
|
||||
template <typename T, size_t V> struct Template_Foo_2 {
|
||||
size_t size() { return V; }
|
||||
};
|
||||
|
||||
template <int V> struct Nttp_Fixture { int value = V; };
|
||||
|
||||
} // end unnamed namespace
|
||||
|
||||
METHOD_AS_TEST_CASE( TestClass::succeedingCase, "A METHOD_AS_TEST_CASE based test run that succeeds", "[class]" )
|
||||
METHOD_AS_TEST_CASE( TestClass::failingCase, "A METHOD_AS_TEST_CASE based test run that fails", "[.][class][failing]" )
|
||||
|
||||
TEST_CASE_METHOD( Fixture, "A TEST_CASE_METHOD based test run that succeeds", "[class]" )
|
||||
{
|
||||
REQUIRE( m_a == 1 );
|
||||
}
|
||||
|
||||
TEMPLATE_TEST_CASE_METHOD(Template_Fixture, "A TEMPLATE_TEST_CASE_METHOD based test run that succeeds", "[class][template]", int, float, double) {
|
||||
REQUIRE( Template_Fixture<TestType>::m_a == 1 );
|
||||
}
|
||||
|
||||
TEMPLATE_TEST_CASE_METHOD_SIG(Nttp_Fixture, "A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds", "[class][template][nttp]",((int V), V), 1, 3, 6) {
|
||||
REQUIRE(Nttp_Fixture<V>::value > 0);
|
||||
}
|
||||
|
||||
TEMPLATE_PRODUCT_TEST_CASE_METHOD(Template_Fixture_2, "A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds","[class][template][product]",(std::vector,Template_Foo),(int,float))
|
||||
{
|
||||
REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 0 );
|
||||
}
|
||||
|
||||
TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(Template_Fixture_2, "A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds", "[class][template][product][nttp]", ((typename T, size_t S), T, S),(std::array, Template_Foo_2), ((int,2), (float,6)))
|
||||
{
|
||||
REQUIRE(Template_Fixture_2<TestType>{}.m_a.size() >= 2);
|
||||
}
|
||||
|
||||
using MyTypes = std::tuple<int, char, double>;
|
||||
TEMPLATE_LIST_TEST_CASE_METHOD(Template_Fixture, "Template test case method with test types specified inside std::tuple", "[class][template][list]", MyTypes)
|
||||
{
|
||||
REQUIRE( Template_Fixture<TestType>::m_a == 1 );
|
||||
}
|
||||
|
||||
// We should be able to write our tests within a different namespace
|
||||
namespace Inner
|
||||
{
|
||||
TEST_CASE_METHOD( Fixture, "A TEST_CASE_METHOD based test run that fails", "[.][class][failing]" )
|
||||
{
|
||||
REQUIRE( m_a == 2 );
|
||||
}
|
||||
|
||||
TEMPLATE_TEST_CASE_METHOD(Template_Fixture,"A TEMPLATE_TEST_CASE_METHOD based test run that fails", "[.][class][template][failing]", int, float, double)
|
||||
{
|
||||
REQUIRE( Template_Fixture<TestType>::m_a == 2 );
|
||||
}
|
||||
|
||||
TEMPLATE_TEST_CASE_METHOD_SIG(Nttp_Fixture, "A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails", "[.][class][template][nttp][failing]", ((int V), V), 1, 3, 6) {
|
||||
REQUIRE(Nttp_Fixture<V>::value == 0);
|
||||
}
|
||||
|
||||
TEMPLATE_PRODUCT_TEST_CASE_METHOD(Template_Fixture_2, "A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails","[.][class][template][product][failing]",(std::vector,Template_Foo),(int,float))
|
||||
{
|
||||
REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 );
|
||||
}
|
||||
|
||||
TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(Template_Fixture_2, "A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails", "[.][class][template][product][nttp][failing]", ((typename T, size_t S), T, S), (std::array, Template_Foo_2), ((int, 2), (float, 6)))
|
||||
{
|
||||
REQUIRE(Template_Fixture_2<TestType>{}.m_a.size() < 2);
|
||||
}
|
||||
} // namespace
|
||||
|
||||
|
||||
// We want a class in nested namespace so we can test JUnit's classname normalization.
|
||||
namespace {
|
||||
namespace A {
|
||||
namespace B {
|
||||
class TestClass {};
|
||||
}
|
||||
}
|
||||
} // namespace
|
||||
|
||||
TEST_CASE_METHOD( A::B::TestClass,
|
||||
"A TEST_CASE_METHOD testing junit classname normalization",
|
||||
"[class][approvals]" ) {
|
||||
SUCCEED();
|
||||
}
|
||||
355
externals/catch2/tests/SelfTest/UsageTests/Compilation.tests.cpp
vendored
Normal file
355
externals/catch2/tests/SelfTest/UsageTests/Compilation.tests.cpp
vendored
Normal file
@@ -0,0 +1,355 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <helpers/type_with_lit_0_comparisons.hpp>
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
// Setup for #1403 -- look for global overloads of operator << for classes
|
||||
// in a different namespace.
|
||||
#include <ostream>
|
||||
|
||||
namespace foo {
|
||||
struct helper_1403 {
|
||||
bool operator==(helper_1403) const { return true; }
|
||||
};
|
||||
}
|
||||
|
||||
namespace bar {
|
||||
template <typename... Ts>
|
||||
struct TypeList {};
|
||||
}
|
||||
|
||||
#ifdef __GNUC__
|
||||
#pragma GCC diagnostic ignored "-Wmissing-declarations"
|
||||
#endif
|
||||
static std::ostream& operator<<(std::ostream& out, foo::helper_1403 const&) {
|
||||
return out << "[1403 helper]";
|
||||
}
|
||||
///////////////////////////////
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/matchers/catch_matchers_string.hpp>
|
||||
|
||||
#include <cstring>
|
||||
|
||||
// Comparison operators can return non-booleans.
|
||||
// This is unusual, but should be supported.
|
||||
struct logic_t {
|
||||
logic_t operator< (logic_t) const { return {}; }
|
||||
logic_t operator<=(logic_t) const { return {}; }
|
||||
logic_t operator> (logic_t) const { return {}; }
|
||||
logic_t operator>=(logic_t) const { return {}; }
|
||||
logic_t operator==(logic_t) const { return {}; }
|
||||
logic_t operator!=(logic_t) const { return {}; }
|
||||
explicit operator bool() const { return true; }
|
||||
};
|
||||
|
||||
|
||||
static void throws_int(bool b) {
|
||||
if (b) {
|
||||
throw 1;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool templated_tests(T t) {
|
||||
int a = 3;
|
||||
REQUIRE(a == t);
|
||||
CHECK(a == t);
|
||||
REQUIRE_THROWS(throws_int(true));
|
||||
CHECK_THROWS_AS(throws_int(true), int);
|
||||
REQUIRE_NOTHROW(throws_int(false));
|
||||
REQUIRE_THAT("aaa", Catch::Matchers::EndsWith("aaa"));
|
||||
return true;
|
||||
}
|
||||
|
||||
struct A {};
|
||||
|
||||
static std::ostream &operator<<(std::ostream &o, const A &) { return o << 0; }
|
||||
|
||||
struct B : private A {
|
||||
bool operator==(int) const { return true; }
|
||||
};
|
||||
|
||||
#ifdef __clang__
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wunused-function"
|
||||
#endif
|
||||
#ifdef __GNUC__
|
||||
// Note that because -~GCC~-, this warning cannot be silenced temporarily, by pushing diagnostic stack...
|
||||
// Luckily it is firing in test files and thus can be silenced for the whole file, without losing much.
|
||||
#pragma GCC diagnostic ignored "-Wunused-function"
|
||||
#endif
|
||||
|
||||
B f();
|
||||
|
||||
std::ostream g();
|
||||
|
||||
#ifdef __clang__
|
||||
#pragma clang diagnostic pop
|
||||
#endif
|
||||
|
||||
template <typename, typename>
|
||||
struct Fixture_1245 {};
|
||||
|
||||
// This is a minimal example for an issue we have found in 1.7.0
|
||||
struct dummy_809 {
|
||||
int i;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
bool operator==(const T& val, dummy_809 f) {
|
||||
return val == f.i;
|
||||
}
|
||||
|
||||
TEST_CASE("#809") {
|
||||
dummy_809 f;
|
||||
f.i = 42;
|
||||
REQUIRE(42 == f);
|
||||
}
|
||||
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// Changes to REQUIRE_THROWS_AS made it stop working in a template in
|
||||
// an unfixable way (as long as C++03 compatibility is being kept).
|
||||
// To prevent these from happening in the future, this needs to compile
|
||||
|
||||
TEST_CASE("#833") {
|
||||
REQUIRE(templated_tests<int>(3));
|
||||
}
|
||||
|
||||
|
||||
// Test containing example where original stream insertable check breaks compilation
|
||||
TEST_CASE("#872") {
|
||||
A dummy;
|
||||
CAPTURE(dummy);
|
||||
B x;
|
||||
REQUIRE (x == 4);
|
||||
}
|
||||
|
||||
TEST_CASE("#1027: Bitfields can be captured") {
|
||||
struct Y {
|
||||
uint32_t v : 1;
|
||||
};
|
||||
Y y{ 0 };
|
||||
REQUIRE(y.v == 0);
|
||||
REQUIRE(0 == y.v);
|
||||
}
|
||||
|
||||
// Comparison operators can return non-booleans.
|
||||
// This is unusual, but should be supported.
|
||||
TEST_CASE("#1147") {
|
||||
logic_t t1, t2;
|
||||
REQUIRE(t1 == t2);
|
||||
REQUIRE(t1 != t2);
|
||||
REQUIRE(t1 < t2);
|
||||
REQUIRE(t1 > t2);
|
||||
REQUIRE(t1 <= t2);
|
||||
REQUIRE(t1 >= t2);
|
||||
}
|
||||
|
||||
// unsigned array
|
||||
TEST_CASE("#1238") {
|
||||
unsigned char uarr[] = "123";
|
||||
CAPTURE(uarr);
|
||||
signed char sarr[] = "456";
|
||||
CAPTURE(sarr);
|
||||
|
||||
REQUIRE(std::memcmp(uarr, "123", sizeof(uarr)) == 0);
|
||||
REQUIRE(std::memcmp(sarr, "456", sizeof(sarr)) == 0);
|
||||
}
|
||||
|
||||
TEST_CASE_METHOD((Fixture_1245<int, int>), "#1245", "[compilation]") {
|
||||
SUCCEED();
|
||||
}
|
||||
|
||||
TEST_CASE("#1403", "[compilation]") {
|
||||
::foo::helper_1403 h1, h2;
|
||||
REQUIRE(h1 == h2);
|
||||
}
|
||||
|
||||
TEST_CASE("Optionally static assertions", "[compilation]") {
|
||||
STATIC_REQUIRE( std::is_void<void>::value );
|
||||
STATIC_REQUIRE_FALSE( std::is_void<int>::value );
|
||||
STATIC_CHECK( std::is_void<void>::value );
|
||||
STATIC_CHECK_FALSE( std::is_void<int>::value );
|
||||
}
|
||||
|
||||
TEST_CASE("#1548", "[compilation]") {
|
||||
using namespace bar;
|
||||
REQUIRE(std::is_same<TypeList<int>, TypeList<int>>::value);
|
||||
}
|
||||
|
||||
// #925
|
||||
using signal_t = void (*) (void*);
|
||||
|
||||
struct TestClass {
|
||||
signal_t testMethod_uponComplete_arg = nullptr;
|
||||
};
|
||||
|
||||
namespace utility {
|
||||
inline static void synchronizing_callback( void * ) { }
|
||||
}
|
||||
|
||||
#if defined (_MSC_VER)
|
||||
#pragma warning(push)
|
||||
// The function pointer comparison below triggers warning because of
|
||||
// calling conventions
|
||||
#pragma warning(disable:4244)
|
||||
#endif
|
||||
TEST_CASE("#925: comparing function pointer to function address failed to compile", "[!nonportable]" ) {
|
||||
TestClass test;
|
||||
REQUIRE(utility::synchronizing_callback != test.testMethod_uponComplete_arg);
|
||||
}
|
||||
#if defined (_MSC_VER)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
TEST_CASE( "#1319: Sections can have description (even if it is not saved",
|
||||
"[compilation]" ) {
|
||||
SECTION( "SectionName", "This is a long form section description" ) {
|
||||
SUCCEED();
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("Lambdas in assertions") {
|
||||
REQUIRE([]() { return true; }());
|
||||
}
|
||||
|
||||
namespace {
|
||||
struct HasBitOperators {
|
||||
int value;
|
||||
|
||||
friend HasBitOperators operator| (HasBitOperators lhs, HasBitOperators rhs) {
|
||||
return { lhs.value | rhs.value };
|
||||
}
|
||||
friend HasBitOperators operator& (HasBitOperators lhs, HasBitOperators rhs) {
|
||||
return { lhs.value & rhs.value };
|
||||
}
|
||||
friend HasBitOperators operator^ (HasBitOperators lhs, HasBitOperators rhs) {
|
||||
return { lhs.value ^ rhs.value };
|
||||
}
|
||||
explicit operator bool() const {
|
||||
return !!value;
|
||||
}
|
||||
|
||||
friend std::ostream& operator<<(std::ostream& out, HasBitOperators val) {
|
||||
out << "Val: " << val.value;
|
||||
return out;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
TEST_CASE("Assertion macros support bit operators and bool conversions", "[compilation][bitops]") {
|
||||
HasBitOperators lhs{ 1 }, rhs{ 2 };
|
||||
REQUIRE(lhs | rhs);
|
||||
REQUIRE_FALSE(lhs & rhs);
|
||||
REQUIRE(HasBitOperators{ 1 } & HasBitOperators{ 1 });
|
||||
REQUIRE(lhs ^ rhs);
|
||||
REQUIRE_FALSE(lhs ^ lhs);
|
||||
}
|
||||
|
||||
namespace {
|
||||
struct ImmovableType {
|
||||
ImmovableType() = default;
|
||||
|
||||
ImmovableType(ImmovableType const&) = delete;
|
||||
ImmovableType& operator=(ImmovableType const&) = delete;
|
||||
ImmovableType(ImmovableType&&) = delete;
|
||||
ImmovableType& operator=(ImmovableType&&) = delete;
|
||||
|
||||
friend bool operator==(ImmovableType const&, ImmovableType const&) {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
TEST_CASE("Immovable types are supported in basic assertions", "[compilation][.approvals]") {
|
||||
REQUIRE(ImmovableType{} == ImmovableType{});
|
||||
}
|
||||
|
||||
namespace adl {
|
||||
|
||||
struct always_true {
|
||||
explicit operator bool() const { return true; }
|
||||
};
|
||||
|
||||
#define COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR(op) \
|
||||
template <class T, class U> \
|
||||
auto operator op (T&&, U&&) { \
|
||||
return always_true{}; \
|
||||
}
|
||||
|
||||
COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR(==)
|
||||
COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR(!=)
|
||||
COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR(<)
|
||||
COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR(>)
|
||||
COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR(<=)
|
||||
COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR(>=)
|
||||
COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR(|)
|
||||
COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR(&)
|
||||
COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR(^)
|
||||
|
||||
#undef COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR
|
||||
|
||||
}
|
||||
|
||||
TEST_CASE("ADL universal operators don't hijack expression deconstruction", "[compilation][.approvals]") {
|
||||
REQUIRE(adl::always_true{});
|
||||
REQUIRE(0 == adl::always_true{});
|
||||
REQUIRE(0 != adl::always_true{});
|
||||
REQUIRE(0 < adl::always_true{});
|
||||
REQUIRE(0 > adl::always_true{});
|
||||
REQUIRE(0 <= adl::always_true{});
|
||||
REQUIRE(0 >= adl::always_true{});
|
||||
REQUIRE(0 | adl::always_true{});
|
||||
REQUIRE(0 & adl::always_true{});
|
||||
REQUIRE(0 ^ adl::always_true{});
|
||||
}
|
||||
|
||||
TEST_CASE( "#2555 - types that can only be compared with 0 literal (not int/long) are supported", "[compilation][approvals]" ) {
|
||||
REQUIRE( TypeWithLit0Comparisons{} < 0 );
|
||||
REQUIRE_FALSE( 0 < TypeWithLit0Comparisons{} );
|
||||
REQUIRE( TypeWithLit0Comparisons{} <= 0 );
|
||||
REQUIRE_FALSE( 0 > TypeWithLit0Comparisons{} );
|
||||
|
||||
REQUIRE( TypeWithLit0Comparisons{} > 0 );
|
||||
REQUIRE_FALSE( 0 > TypeWithLit0Comparisons{} );
|
||||
REQUIRE( TypeWithLit0Comparisons{} >= 0 );
|
||||
REQUIRE_FALSE( 0 >= TypeWithLit0Comparisons{} );
|
||||
|
||||
REQUIRE( TypeWithLit0Comparisons{} == 0 );
|
||||
REQUIRE_FALSE( 0 == TypeWithLit0Comparisons{} );
|
||||
REQUIRE( TypeWithLit0Comparisons{} != 0 );
|
||||
REQUIRE_FALSE( 0 != TypeWithLit0Comparisons{} );
|
||||
}
|
||||
|
||||
namespace {
|
||||
struct MultipleImplicitConstructors {
|
||||
MultipleImplicitConstructors( double ) {}
|
||||
MultipleImplicitConstructors( int64_t ) {}
|
||||
bool operator==( MultipleImplicitConstructors ) const { return true; }
|
||||
bool operator!=( MultipleImplicitConstructors ) const { return true; }
|
||||
bool operator<( MultipleImplicitConstructors ) const { return true; }
|
||||
bool operator<=( MultipleImplicitConstructors ) const { return true; }
|
||||
bool operator>( MultipleImplicitConstructors ) const { return true; }
|
||||
bool operator>=( MultipleImplicitConstructors ) const { return true; }
|
||||
};
|
||||
}
|
||||
TEST_CASE("#2571 - tests compile types that have multiple implicit constructors from lit 0",
|
||||
"[compilation][approvals]") {
|
||||
MultipleImplicitConstructors mic1( 0.0 );
|
||||
MultipleImplicitConstructors mic2( 0.0 );
|
||||
REQUIRE( mic1 == mic2 );
|
||||
REQUIRE( mic1 != mic2 );
|
||||
REQUIRE( mic1 < mic2 );
|
||||
REQUIRE( mic1 <= mic2 );
|
||||
REQUIRE( mic1 > mic2 );
|
||||
REQUIRE( mic1 >= mic2 );
|
||||
}
|
||||
334
externals/catch2/tests/SelfTest/UsageTests/Condition.tests.cpp
vendored
Normal file
334
externals/catch2/tests/SelfTest/UsageTests/Condition.tests.cpp
vendored
Normal file
@@ -0,0 +1,334 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#ifdef __clang__
|
||||
# pragma clang diagnostic push
|
||||
# pragma clang diagnostic ignored "-Wpadded"
|
||||
// Wdouble-promotion is not supported until 3.8
|
||||
# if (__clang_major__ > 3) || (__clang_major__ == 3 && __clang_minor__ > 7)
|
||||
# pragma clang diagnostic ignored "-Wdouble-promotion"
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#include <catch2/catch_approx.hpp>
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
|
||||
using Catch::Approx;
|
||||
|
||||
#include <string>
|
||||
#include <limits>
|
||||
#include <cstdint>
|
||||
|
||||
namespace {
|
||||
|
||||
struct TestData {
|
||||
int int_seven = 7;
|
||||
std::string str_hello = "hello";
|
||||
float float_nine_point_one = 9.1f;
|
||||
double double_pi = 3.1415926535;
|
||||
};
|
||||
|
||||
static const char* returnsConstNull() { return nullptr; }
|
||||
static char* returnsNull() { return nullptr; }
|
||||
|
||||
} // end unnamed namespace
|
||||
|
||||
// The "failing" tests all use the CHECK macro, which continues if the specific test fails.
|
||||
// This allows us to see all results, even if an earlier check fails
|
||||
|
||||
// Equality tests
|
||||
TEST_CASE( "Equality checks that should succeed" )
|
||||
{
|
||||
TestData data;
|
||||
|
||||
REQUIRE( data.int_seven == 7 );
|
||||
REQUIRE( data.float_nine_point_one == Approx( 9.1f ) );
|
||||
REQUIRE( data.double_pi == Approx( 3.1415926535 ) );
|
||||
REQUIRE( data.str_hello == "hello" );
|
||||
REQUIRE( "hello" == data.str_hello );
|
||||
REQUIRE( data.str_hello.size() == 5 );
|
||||
|
||||
double x = 1.1 + 0.1 + 0.1;
|
||||
REQUIRE( x == Approx( 1.3 ) );
|
||||
}
|
||||
|
||||
TEST_CASE( "Equality checks that should fail", "[.][failing][!mayfail]" )
|
||||
{
|
||||
TestData data;
|
||||
|
||||
CHECK( data.int_seven == 6 );
|
||||
CHECK( data.int_seven == 8 );
|
||||
CHECK( data.int_seven == 0 );
|
||||
CHECK( data.float_nine_point_one == Approx( 9.11f ) );
|
||||
CHECK( data.float_nine_point_one == Approx( 9.0f ) );
|
||||
CHECK( data.float_nine_point_one == Approx( 1 ) );
|
||||
CHECK( data.float_nine_point_one == Approx( 0 ) );
|
||||
CHECK( data.double_pi == Approx( 3.1415 ) );
|
||||
CHECK( data.str_hello == "goodbye" );
|
||||
CHECK( data.str_hello == "hell" );
|
||||
CHECK( data.str_hello == "hello1" );
|
||||
CHECK( data.str_hello.size() == 6 );
|
||||
|
||||
double x = 1.1 + 0.1 + 0.1;
|
||||
CHECK( x == Approx( 1.301 ) );
|
||||
}
|
||||
|
||||
// Needed to test junit reporter's handling of mayfail test cases and sections
|
||||
TEST_CASE("Mayfail test case with nested sections", "[!mayfail]") {
|
||||
SECTION("A") {
|
||||
SECTION("1") { FAIL(); }
|
||||
SECTION("2") { FAIL(); }
|
||||
}
|
||||
SECTION("B") {
|
||||
SECTION("1") { FAIL(); }
|
||||
SECTION("2") { FAIL(); }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
TEST_CASE( "Inequality checks that should succeed" )
|
||||
{
|
||||
TestData data;
|
||||
|
||||
REQUIRE( data.int_seven != 6 );
|
||||
REQUIRE( data.int_seven != 8 );
|
||||
REQUIRE( data.float_nine_point_one != Approx( 9.11f ) );
|
||||
REQUIRE( data.float_nine_point_one != Approx( 9.0f ) );
|
||||
REQUIRE( data.float_nine_point_one != Approx( 1 ) );
|
||||
REQUIRE( data.float_nine_point_one != Approx( 0 ) );
|
||||
REQUIRE( data.double_pi != Approx( 3.1415 ) );
|
||||
REQUIRE( data.str_hello != "goodbye" );
|
||||
REQUIRE( data.str_hello != "hell" );
|
||||
REQUIRE( data.str_hello != "hello1" );
|
||||
REQUIRE( data.str_hello.size() != 6 );
|
||||
}
|
||||
|
||||
TEST_CASE( "Inequality checks that should fail", "[.][failing][!shouldfail]" )
|
||||
{
|
||||
TestData data;
|
||||
|
||||
CHECK( data.int_seven != 7 );
|
||||
CHECK( data.float_nine_point_one != Approx( 9.1f ) );
|
||||
CHECK( data.double_pi != Approx( 3.1415926535 ) );
|
||||
CHECK( data.str_hello != "hello" );
|
||||
CHECK( data.str_hello.size() != 5 );
|
||||
}
|
||||
|
||||
// Ordering comparison tests
|
||||
TEST_CASE( "Ordering comparison checks that should succeed" )
|
||||
{
|
||||
TestData data;
|
||||
|
||||
REQUIRE( data.int_seven < 8 );
|
||||
REQUIRE( data.int_seven > 6 );
|
||||
REQUIRE( data.int_seven > 0 );
|
||||
REQUIRE( data.int_seven > -1 );
|
||||
|
||||
REQUIRE( data.int_seven >= 7 );
|
||||
REQUIRE( data.int_seven >= 6 );
|
||||
REQUIRE( data.int_seven <= 7 );
|
||||
REQUIRE( data.int_seven <= 8 );
|
||||
|
||||
REQUIRE( data.float_nine_point_one > 9 );
|
||||
REQUIRE( data.float_nine_point_one < 10 );
|
||||
REQUIRE( data.float_nine_point_one < 9.2 );
|
||||
|
||||
REQUIRE( data.str_hello <= "hello" );
|
||||
REQUIRE( data.str_hello >= "hello" );
|
||||
|
||||
REQUIRE( data.str_hello < "hellp" );
|
||||
REQUIRE( data.str_hello < "zebra" );
|
||||
REQUIRE( data.str_hello > "hellm" );
|
||||
REQUIRE( data.str_hello > "a" );
|
||||
}
|
||||
|
||||
TEST_CASE( "Ordering comparison checks that should fail", "[.][failing]" )
|
||||
{
|
||||
TestData data;
|
||||
|
||||
CHECK( data.int_seven > 7 );
|
||||
CHECK( data.int_seven < 7 );
|
||||
CHECK( data.int_seven > 8 );
|
||||
CHECK( data.int_seven < 6 );
|
||||
CHECK( data.int_seven < 0 );
|
||||
CHECK( data.int_seven < -1 );
|
||||
|
||||
CHECK( data.int_seven >= 8 );
|
||||
CHECK( data.int_seven <= 6 );
|
||||
|
||||
CHECK( data.float_nine_point_one < 9 );
|
||||
CHECK( data.float_nine_point_one > 10 );
|
||||
CHECK( data.float_nine_point_one > 9.2 );
|
||||
|
||||
CHECK( data.str_hello > "hello" );
|
||||
CHECK( data.str_hello < "hello" );
|
||||
CHECK( data.str_hello > "hellp" );
|
||||
CHECK( data.str_hello > "z" );
|
||||
CHECK( data.str_hello < "hellm" );
|
||||
CHECK( data.str_hello < "a" );
|
||||
|
||||
CHECK( data.str_hello >= "z" );
|
||||
CHECK( data.str_hello <= "a" );
|
||||
}
|
||||
|
||||
#ifdef __clang__
|
||||
# pragma clang diagnostic pop
|
||||
#endif
|
||||
|
||||
|
||||
// Comparisons with int literals
|
||||
TEST_CASE( "Comparisons with int literals don't warn when mixing signed/ unsigned" )
|
||||
{
|
||||
int i = 1;
|
||||
unsigned int ui = 2;
|
||||
long l = 3;
|
||||
unsigned long ul = 4;
|
||||
char c = 5;
|
||||
unsigned char uc = 6;
|
||||
|
||||
REQUIRE( i == 1 );
|
||||
REQUIRE( ui == 2 );
|
||||
REQUIRE( l == 3 );
|
||||
REQUIRE( ul == 4 );
|
||||
REQUIRE( c == 5 );
|
||||
REQUIRE( uc == 6 );
|
||||
|
||||
REQUIRE( 1 == i );
|
||||
REQUIRE( 2 == ui );
|
||||
REQUIRE( 3 == l );
|
||||
REQUIRE( 4 == ul );
|
||||
REQUIRE( 5 == c );
|
||||
REQUIRE( 6 == uc );
|
||||
|
||||
REQUIRE( (std::numeric_limits<uint32_t>::max)() > ul );
|
||||
}
|
||||
|
||||
// Disable warnings about sign conversions for the next two tests
|
||||
// (as we are deliberately invoking them)
|
||||
// - Currently only disabled for GCC/ LLVM. Should add VC++ too
|
||||
#ifdef __GNUC__
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wsign-compare"
|
||||
#pragma GCC diagnostic ignored "-Wsign-conversion"
|
||||
#endif
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
|
||||
#endif
|
||||
|
||||
TEST_CASE( "comparisons between int variables" )
|
||||
{
|
||||
long long_var = 1L;
|
||||
unsigned char unsigned_char_var = 1;
|
||||
unsigned short unsigned_short_var = 1;
|
||||
unsigned int unsigned_int_var = 1;
|
||||
unsigned long unsigned_long_var = 1L;
|
||||
|
||||
REQUIRE( long_var == unsigned_char_var );
|
||||
REQUIRE( long_var == unsigned_short_var );
|
||||
REQUIRE( long_var == unsigned_int_var );
|
||||
REQUIRE( long_var == unsigned_long_var );
|
||||
}
|
||||
|
||||
TEST_CASE( "comparisons between const int variables" )
|
||||
{
|
||||
const unsigned char unsigned_char_var = 1;
|
||||
const unsigned short unsigned_short_var = 1;
|
||||
const unsigned int unsigned_int_var = 1;
|
||||
const unsigned long unsigned_long_var = 1L;
|
||||
|
||||
REQUIRE( unsigned_char_var == 1 );
|
||||
REQUIRE( unsigned_short_var == 1 );
|
||||
REQUIRE( unsigned_int_var == 1 );
|
||||
REQUIRE( unsigned_long_var == 1 );
|
||||
}
|
||||
|
||||
TEST_CASE( "Comparisons between unsigned ints and negative signed ints match c++ standard behaviour" )
|
||||
{
|
||||
CHECK( ( -1 > 2u ) );
|
||||
CHECK( -1 > 2u );
|
||||
|
||||
CHECK( ( 2u < -1 ) );
|
||||
CHECK( 2u < -1 );
|
||||
|
||||
const int minInt = (std::numeric_limits<int>::min)();
|
||||
CHECK( ( minInt > 2u ) );
|
||||
CHECK( minInt > 2u );
|
||||
}
|
||||
|
||||
TEST_CASE( "Comparisons between ints where one side is computed" )
|
||||
{
|
||||
CHECK( 54 == 6*9 );
|
||||
}
|
||||
|
||||
#ifdef __GNUC__
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
|
||||
TEST_CASE( "Pointers can be compared to null" )
|
||||
{
|
||||
TestData* p = nullptr;
|
||||
TestData* pNULL = nullptr;
|
||||
|
||||
REQUIRE( p == nullptr );
|
||||
REQUIRE( p == pNULL );
|
||||
|
||||
TestData data;
|
||||
p = &data;
|
||||
|
||||
REQUIRE( p != nullptr );
|
||||
|
||||
const TestData* cp = p;
|
||||
REQUIRE( cp != nullptr );
|
||||
|
||||
const TestData* const cpc = p;
|
||||
REQUIRE( cpc != nullptr );
|
||||
|
||||
REQUIRE( returnsNull() == nullptr );
|
||||
REQUIRE( returnsConstNull() == nullptr );
|
||||
|
||||
REQUIRE( nullptr != p );
|
||||
}
|
||||
|
||||
// Not (!) tests
|
||||
// The problem with the ! operator is that it has right-to-left associativity.
|
||||
// This means we can't isolate it when we decompose. The simple REQUIRE( !false ) form, therefore,
|
||||
// cannot have the operand value extracted. The test will work correctly, and the situation
|
||||
// is detected and a warning issued.
|
||||
// An alternative form of the macros (CHECK_FALSE and REQUIRE_FALSE) can be used instead to capture
|
||||
// the operand value.
|
||||
TEST_CASE( "'Not' checks that should succeed" )
|
||||
{
|
||||
bool falseValue = false;
|
||||
|
||||
REQUIRE( false == false );
|
||||
REQUIRE( true == true );
|
||||
REQUIRE( !false );
|
||||
REQUIRE_FALSE( false );
|
||||
|
||||
REQUIRE( !falseValue );
|
||||
REQUIRE_FALSE( falseValue );
|
||||
|
||||
REQUIRE( !(1 == 2) );
|
||||
REQUIRE_FALSE( 1 == 2 );
|
||||
}
|
||||
|
||||
TEST_CASE( "'Not' checks that should fail", "[.][failing]" )
|
||||
{
|
||||
bool trueValue = true;
|
||||
|
||||
CHECK( false != false );
|
||||
CHECK( true != true );
|
||||
CHECK( !true );
|
||||
CHECK_FALSE( true );
|
||||
|
||||
CHECK( !trueValue );
|
||||
CHECK_FALSE( trueValue );
|
||||
|
||||
CHECK( !(1 == 1) );
|
||||
CHECK_FALSE( 1 == 1 );
|
||||
}
|
||||
41
externals/catch2/tests/SelfTest/UsageTests/Decomposition.tests.cpp
vendored
Normal file
41
externals/catch2/tests/SelfTest/UsageTests/Decomposition.tests.cpp
vendored
Normal file
@@ -0,0 +1,41 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <iostream>
|
||||
#include <cstdio>
|
||||
|
||||
namespace {
|
||||
|
||||
struct truthy {
|
||||
truthy(bool b):m_value(b){}
|
||||
operator bool() const {
|
||||
return false;
|
||||
}
|
||||
bool m_value;
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& o, truthy) {
|
||||
o << "Hey, its truthy!";
|
||||
return o;
|
||||
}
|
||||
|
||||
} // end anonymous namespace
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
|
||||
TEST_CASE( "Reconstruction should be based on stringification: #914" , "[Decomposition][failing][.]") {
|
||||
CHECK(truthy(false));
|
||||
}
|
||||
|
||||
TEST_CASE("#1005: Comparing pointer to int and long (NULL can be either on various systems)", "[Decomposition][approvals]") {
|
||||
FILE* fptr = nullptr;
|
||||
REQUIRE( fptr == 0 );
|
||||
REQUIRE_FALSE( fptr != 0 );
|
||||
REQUIRE( fptr == 0l );
|
||||
REQUIRE_FALSE( fptr != 0l );
|
||||
}
|
||||
108
externals/catch2/tests/SelfTest/UsageTests/EnumToString.tests.cpp
vendored
Normal file
108
externals/catch2/tests/SelfTest/UsageTests/EnumToString.tests.cpp
vendored
Normal file
@@ -0,0 +1,108 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/internal/catch_enum_values_registry.hpp>
|
||||
|
||||
|
||||
namespace {
|
||||
// Enum without user-provided stream operator
|
||||
enum Enum1 { Enum1Value0, Enum1Value1 };
|
||||
|
||||
// Enum with user-provided stream operator
|
||||
enum Enum2 { Enum2Value0, Enum2Value1 };
|
||||
|
||||
std::ostream& operator<<( std::ostream& os, Enum2 v ) {
|
||||
return os << "E2{" << static_cast<int>(v) << "}";
|
||||
}
|
||||
} // end anonymous namespace
|
||||
|
||||
TEST_CASE( "toString(enum)", "[toString][enum]" ) {
|
||||
Enum1 e0 = Enum1Value0;
|
||||
CHECK( ::Catch::Detail::stringify(e0) == "0" );
|
||||
Enum1 e1 = Enum1Value1;
|
||||
CHECK( ::Catch::Detail::stringify(e1) == "1" );
|
||||
}
|
||||
|
||||
TEST_CASE( "toString(enum w/operator<<)", "[toString][enum]" ) {
|
||||
Enum2 e0 = Enum2Value0;
|
||||
CHECK( ::Catch::Detail::stringify(e0) == "E2{0}" );
|
||||
Enum2 e1 = Enum2Value1;
|
||||
CHECK( ::Catch::Detail::stringify(e1) == "E2{1}" );
|
||||
}
|
||||
|
||||
// Enum class without user-provided stream operator
|
||||
namespace {
|
||||
enum class EnumClass1 { EnumClass1Value0, EnumClass1Value1 };
|
||||
|
||||
// Enum class with user-provided stream operator
|
||||
enum class EnumClass2 { EnumClass2Value0, EnumClass2Value1 };
|
||||
|
||||
std::ostream& operator<<( std::ostream& os, EnumClass2 e2 ) {
|
||||
switch( static_cast<int>( e2 ) ) {
|
||||
case static_cast<int>( EnumClass2::EnumClass2Value0 ):
|
||||
return os << "E2/V0";
|
||||
case static_cast<int>( EnumClass2::EnumClass2Value1 ):
|
||||
return os << "E2/V1";
|
||||
default:
|
||||
return os << "Unknown enum value " << static_cast<int>( e2 );
|
||||
}
|
||||
}
|
||||
|
||||
} // end anonymous namespace
|
||||
|
||||
TEST_CASE( "toString(enum class)", "[toString][enum][enumClass]" ) {
|
||||
EnumClass1 e0 = EnumClass1::EnumClass1Value0;
|
||||
CHECK( ::Catch::Detail::stringify(e0) == "0" );
|
||||
EnumClass1 e1 = EnumClass1::EnumClass1Value1;
|
||||
CHECK( ::Catch::Detail::stringify(e1) == "1" );
|
||||
}
|
||||
|
||||
|
||||
TEST_CASE( "toString(enum class w/operator<<)", "[toString][enum][enumClass]" ) {
|
||||
EnumClass2 e0 = EnumClass2::EnumClass2Value0;
|
||||
CHECK( ::Catch::Detail::stringify(e0) == "E2/V0" );
|
||||
EnumClass2 e1 = EnumClass2::EnumClass2Value1;
|
||||
CHECK( ::Catch::Detail::stringify(e1) == "E2/V1" );
|
||||
|
||||
auto e3 = static_cast<EnumClass2>(10);
|
||||
CHECK( ::Catch::Detail::stringify(e3) == "Unknown enum value 10" );
|
||||
}
|
||||
|
||||
enum class EnumClass3 { Value1, Value2, Value3, Value4 };
|
||||
|
||||
CATCH_REGISTER_ENUM( EnumClass3, EnumClass3::Value1, EnumClass3::Value2, EnumClass3::Value3 )
|
||||
|
||||
|
||||
TEST_CASE( "Enums can quickly have stringification enabled using REGISTER_ENUM" ) {
|
||||
using Catch::Detail::stringify;
|
||||
REQUIRE( stringify( EnumClass3::Value1 ) == "Value1" );
|
||||
REQUIRE( stringify( EnumClass3::Value2 ) == "Value2" );
|
||||
REQUIRE( stringify( EnumClass3::Value3 ) == "Value3" );
|
||||
REQUIRE( stringify( EnumClass3::Value4 ) == "{** unexpected enum value **}" );
|
||||
|
||||
EnumClass3 ec3 = EnumClass3::Value2;
|
||||
REQUIRE( stringify( ec3 ) == "Value2" );
|
||||
}
|
||||
|
||||
namespace Bikeshed {
|
||||
enum class Colours { Red, Green, Blue };
|
||||
}
|
||||
|
||||
// Important!: This macro must appear at top level scope - not inside a namespace
|
||||
// You can fully qualify the names, or use a using if you prefer
|
||||
CATCH_REGISTER_ENUM( Bikeshed::Colours,
|
||||
Bikeshed::Colours::Red,
|
||||
Bikeshed::Colours::Green,
|
||||
Bikeshed::Colours::Blue )
|
||||
|
||||
TEST_CASE( "Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM" ) {
|
||||
using Catch::Detail::stringify;
|
||||
REQUIRE( stringify( Bikeshed::Colours::Red ) == "Red" );
|
||||
REQUIRE( stringify( Bikeshed::Colours::Blue ) == "Blue" );
|
||||
}
|
||||
204
externals/catch2/tests/SelfTest/UsageTests/Exception.tests.cpp
vendored
Normal file
204
externals/catch2/tests/SelfTest/UsageTests/Exception.tests.cpp
vendored
Normal file
@@ -0,0 +1,204 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/catch_translate_exception.hpp>
|
||||
#include <catch2/matchers/catch_matchers_string.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <stdexcept>
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning(disable:4702) // Unreachable code -- unconditional throws and so on
|
||||
#endif
|
||||
#ifdef __clang__
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wweak-vtables"
|
||||
#pragma clang diagnostic ignored "-Wmissing-noreturn"
|
||||
#pragma clang diagnostic ignored "-Wunreachable-code"
|
||||
#endif
|
||||
|
||||
namespace {
|
||||
|
||||
int thisThrows() {
|
||||
throw std::domain_error("expected exception");
|
||||
return 1;
|
||||
}
|
||||
|
||||
int thisDoesntThrow() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
class CustomException {
|
||||
public:
|
||||
explicit CustomException(const std::string& msg)
|
||||
: m_msg(msg) {}
|
||||
|
||||
std::string const& getMessage() const {
|
||||
return m_msg;
|
||||
}
|
||||
|
||||
private:
|
||||
std::string m_msg;
|
||||
};
|
||||
|
||||
class CustomStdException : public std::exception {
|
||||
public:
|
||||
explicit CustomStdException(const std::string& msg)
|
||||
: m_msg(msg) {}
|
||||
~CustomStdException() noexcept override = default;
|
||||
|
||||
CustomStdException( CustomStdException const& ) = default;
|
||||
CustomStdException& operator=( CustomStdException const& ) = default;
|
||||
|
||||
std::string const& getMessage() const {
|
||||
return m_msg;
|
||||
}
|
||||
|
||||
private:
|
||||
std::string m_msg;
|
||||
};
|
||||
|
||||
[[noreturn]] void throwCustom() {
|
||||
throw CustomException("custom exception - not std");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
TEST_CASE( "When checked exceptions are thrown they can be expected or unexpected", "[!throws]" ) {
|
||||
REQUIRE_THROWS_AS( thisThrows(), std::domain_error );
|
||||
REQUIRE_NOTHROW( thisDoesntThrow() );
|
||||
REQUIRE_THROWS( thisThrows() );
|
||||
}
|
||||
|
||||
TEST_CASE( "Expected exceptions that don't throw or unexpected exceptions fail the test", "[.][failing][!throws]" ) {
|
||||
CHECK_THROWS_AS( thisThrows(), std::string );
|
||||
CHECK_THROWS_AS( thisDoesntThrow(), std::domain_error );
|
||||
CHECK_NOTHROW( thisThrows() );
|
||||
}
|
||||
|
||||
TEST_CASE( "When unchecked exceptions are thrown directly they are always failures", "[.][failing][!throws]" ) {
|
||||
throw std::domain_error( "unexpected exception" );
|
||||
}
|
||||
|
||||
TEST_CASE( "An unchecked exception reports the line of the last assertion", "[.][failing][!throws]" ) {
|
||||
CHECK( 1 == 1 );
|
||||
throw std::domain_error( "unexpected exception" );
|
||||
}
|
||||
|
||||
TEST_CASE( "When unchecked exceptions are thrown from sections they are always failures", "[.][failing][!throws]" ) {
|
||||
SECTION( "section name" ) {
|
||||
throw std::domain_error("unexpected exception");
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "When unchecked exceptions are thrown from functions they are always failures", "[.][failing][!throws]" ) {
|
||||
CHECK( thisThrows() == 0 );
|
||||
}
|
||||
|
||||
TEST_CASE( "When unchecked exceptions are thrown during a REQUIRE the test should abort fail", "[.][failing][!throws]" ) {
|
||||
REQUIRE( thisThrows() == 0 );
|
||||
FAIL( "This should never happen" );
|
||||
}
|
||||
|
||||
TEST_CASE( "When unchecked exceptions are thrown during a CHECK the test should continue", "[.][failing][!throws]" ) {
|
||||
try {
|
||||
CHECK(thisThrows() == 0);
|
||||
}
|
||||
catch(...) {
|
||||
FAIL( "This should never happen" );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "When unchecked exceptions are thrown, but caught, they do not affect the test", "[!throws]" ) {
|
||||
try {
|
||||
throw std::domain_error( "unexpected exception" );
|
||||
}
|
||||
catch(...) {}
|
||||
}
|
||||
|
||||
|
||||
CATCH_TRANSLATE_EXCEPTION( CustomException const& ex ) {
|
||||
return ex.getMessage();
|
||||
}
|
||||
|
||||
CATCH_TRANSLATE_EXCEPTION( CustomStdException const& ex ) {
|
||||
return ex.getMessage();
|
||||
}
|
||||
|
||||
CATCH_TRANSLATE_EXCEPTION( double const& ex ) {
|
||||
return Catch::Detail::stringify( ex );
|
||||
}
|
||||
|
||||
TEST_CASE("Non-std exceptions can be translated", "[.][failing][!throws]" ) {
|
||||
throw CustomException( "custom exception" );
|
||||
}
|
||||
|
||||
TEST_CASE("Custom std-exceptions can be custom translated", "[.][failing][!throws]" ) {
|
||||
throw CustomStdException( "custom std exception" );
|
||||
}
|
||||
|
||||
TEST_CASE( "Custom exceptions can be translated when testing for nothrow", "[.][failing][!throws]" ) {
|
||||
REQUIRE_NOTHROW( throwCustom() );
|
||||
}
|
||||
|
||||
TEST_CASE( "Custom exceptions can be translated when testing for throwing as something else", "[.][failing][!throws]" ) {
|
||||
REQUIRE_THROWS_AS( throwCustom(), std::exception );
|
||||
}
|
||||
|
||||
TEST_CASE( "Unexpected exceptions can be translated", "[.][failing][!throws]" ) {
|
||||
throw double( 3.14 );
|
||||
}
|
||||
|
||||
TEST_CASE("Thrown string literals are translated", "[.][failing][!throws]") {
|
||||
throw "For some reason someone is throwing a string literal!";
|
||||
}
|
||||
|
||||
TEST_CASE("thrown std::strings are translated", "[.][failing][!throws]") {
|
||||
throw std::string{ "Why would you throw a std::string?" };
|
||||
}
|
||||
|
||||
|
||||
TEST_CASE( "Exception messages can be tested for", "[!throws]" ) {
|
||||
using namespace Catch::Matchers;
|
||||
SECTION( "exact match" )
|
||||
REQUIRE_THROWS_WITH( thisThrows(), "expected exception" );
|
||||
SECTION( "different case" )
|
||||
REQUIRE_THROWS_WITH( thisThrows(), Equals( "expecteD Exception", Catch::CaseSensitive::No ) );
|
||||
SECTION( "wildcarded" ) {
|
||||
REQUIRE_THROWS_WITH( thisThrows(), StartsWith( "expected" ) );
|
||||
REQUIRE_THROWS_WITH( thisThrows(), EndsWith( "exception" ) );
|
||||
REQUIRE_THROWS_WITH( thisThrows(), ContainsSubstring( "except" ) );
|
||||
REQUIRE_THROWS_WITH( thisThrows(), ContainsSubstring( "exCept", Catch::CaseSensitive::No ) );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "Mismatching exception messages failing the test", "[.][failing][!throws]" ) {
|
||||
REQUIRE_THROWS_WITH( thisThrows(), "expected exception" );
|
||||
REQUIRE_THROWS_WITH( thisThrows(), "should fail" );
|
||||
REQUIRE_THROWS_WITH( thisThrows(), "expected exception" );
|
||||
}
|
||||
|
||||
TEST_CASE( "#748 - captures with unexpected exceptions", "[.][failing][!throws][!shouldfail]" ) {
|
||||
int answer = 42;
|
||||
CAPTURE( answer );
|
||||
// the message should be printed on the first two sections but not on the third
|
||||
SECTION( "outside assertions" ) {
|
||||
thisThrows();
|
||||
}
|
||||
SECTION( "inside REQUIRE_NOTHROW" ) {
|
||||
REQUIRE_NOTHROW( thisThrows() );
|
||||
}
|
||||
SECTION( "inside REQUIRE_THROWS" ) {
|
||||
REQUIRE_THROWS( thisThrows() );
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef __clang__
|
||||
#pragma clang diagnostic pop
|
||||
#endif
|
||||
313
externals/catch2/tests/SelfTest/UsageTests/Generators.tests.cpp
vendored
Normal file
313
externals/catch2/tests/SelfTest/UsageTests/Generators.tests.cpp
vendored
Normal file
@@ -0,0 +1,313 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/generators/catch_generator_exception.hpp>
|
||||
#include <catch2/generators/catch_generators_adapters.hpp>
|
||||
#include <catch2/generators/catch_generators_random.hpp>
|
||||
#include <catch2/generators/catch_generators_range.hpp>
|
||||
|
||||
#include <cstring>
|
||||
|
||||
|
||||
// Generators and sections can be nested freely
|
||||
TEST_CASE("Generators -- simple", "[generators]") {
|
||||
auto i = GENERATE(1, 2, 3);
|
||||
SECTION("one") {
|
||||
auto j = GENERATE(values({ -3, -2, -1 }));
|
||||
REQUIRE(j < i);
|
||||
}
|
||||
|
||||
SECTION("two") {
|
||||
// You can also explicitly set type for generators via Catch::Generators::as
|
||||
auto str = GENERATE(as<std::string>{}, "a", "bb", "ccc");
|
||||
REQUIRE(4u * i > str.size());
|
||||
}
|
||||
}
|
||||
|
||||
// You can create a cartesian-product of generators by creating multiple ones
|
||||
TEST_CASE("3x3x3 ints", "[generators]") {
|
||||
auto x = GENERATE(1, 2, 3);
|
||||
auto y = GENERATE(4, 5, 6);
|
||||
auto z = GENERATE(7, 8, 9);
|
||||
// These assertions will be run 27 times (3x3x3)
|
||||
CHECK(x < y);
|
||||
CHECK(y < z);
|
||||
REQUIRE(x < z);
|
||||
}
|
||||
|
||||
// You can also create data tuples
|
||||
TEST_CASE("tables", "[generators]") {
|
||||
// Note that this will not compile with libstdc++ older than libstdc++6
|
||||
// See https://stackoverflow.com/questions/12436586/tuple-vector-and-initializer-list
|
||||
// for possible workarounds
|
||||
// auto data = GENERATE(table<char const*, int>({
|
||||
// {"first", 5},
|
||||
// {"second", 6},
|
||||
// {"third", 5},
|
||||
// {"etc...", 6}
|
||||
// }));
|
||||
|
||||
// Workaround for the libstdc++ bug mentioned above
|
||||
using tuple_type = std::tuple<char const*, int>;
|
||||
auto data = GENERATE(table<char const*, int>({
|
||||
tuple_type{"first", 5},
|
||||
tuple_type{"second", 6},
|
||||
tuple_type{"third", 5},
|
||||
tuple_type{"etc...", 6}
|
||||
}));
|
||||
|
||||
REQUIRE(strlen(std::get<0>(data)) == static_cast<size_t>(std::get<1>(data)));
|
||||
}
|
||||
|
||||
|
||||
#ifdef __cpp_structured_bindings
|
||||
|
||||
// Structured bindings make the table utility much nicer to use
|
||||
TEST_CASE( "strlen2", "[approvals][generators]" ) {
|
||||
using tuple_type = std::tuple<std::string, int>; // see above workaround
|
||||
auto [test_input, expected] =
|
||||
GENERATE( table<std::string, size_t>( { tuple_type{ "one", 3 },
|
||||
tuple_type{ "two", 3 },
|
||||
tuple_type{ "three", 5 },
|
||||
tuple_type{ "four", 4 } } ) );
|
||||
|
||||
REQUIRE( test_input.size() == expected );
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
// An alternate way of doing data tables without structured bindings
|
||||
struct Data { std::string str; size_t len; };
|
||||
|
||||
TEST_CASE( "strlen3", "[generators]" ) {
|
||||
auto data = GENERATE( values<Data>({
|
||||
{"one", 3},
|
||||
{"two", 3},
|
||||
{"three", 5},
|
||||
{"four", 4}
|
||||
}));
|
||||
|
||||
REQUIRE( data.str.size() == data.len );
|
||||
}
|
||||
|
||||
|
||||
|
||||
#ifdef __cpp_structured_bindings
|
||||
|
||||
// Based on example from https://docs.cucumber.io/gherkin/reference/#scenario-outline
|
||||
// (thanks to https://github.com/catchorg/Catch2/issues/850#issuecomment-399504851)
|
||||
|
||||
// Note that GIVEN, WHEN, and THEN now forward onto DYNAMIC_SECTION instead of SECTION.
|
||||
// DYNAMIC_SECTION takes its name as a stringstream-style expression, so can be formatted using
|
||||
// variables in scope - such as the generated variables here. This reads quite nicely in the
|
||||
// test name output (the full scenario description).
|
||||
|
||||
static auto eatCucumbers( int start, int eat ) -> int { return start-eat; }
|
||||
|
||||
SCENARIO("Eating cucumbers", "[generators][approvals]") {
|
||||
using tuple_type = std::tuple<int, int, int>;
|
||||
auto [start, eat, left] = GENERATE( table<int, int, int>(
|
||||
{ tuple_type{ 12, 5, 7 }, tuple_type{ 20, 5, 15 } } ) );
|
||||
|
||||
GIVEN( "there are " << start << " cucumbers" )
|
||||
WHEN( "I eat " << eat << " cucumbers" )
|
||||
THEN( "I should have " << left << " cucumbers" ) {
|
||||
REQUIRE( eatCucumbers( start, eat ) == left );
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
// There are also some generic generator manipulators
|
||||
TEST_CASE("Generators -- adapters", "[generators][generic]") {
|
||||
// TODO: This won't work yet, introduce GENERATE_VAR?
|
||||
//auto numbers = Catch::Generators::values({ 1, 2, 3, 4, 5, 6 });
|
||||
SECTION("Filtering by predicate") {
|
||||
SECTION("Basic usage") {
|
||||
// This filters out all odd (false) numbers, giving [2, 4, 6]
|
||||
auto i = GENERATE(filter([] (int val) { return val % 2 == 0; }, values({ 1, 2, 3, 4, 5, 6 })));
|
||||
REQUIRE(i % 2 == 0);
|
||||
}
|
||||
SECTION("Throws if there are no matching values") {
|
||||
using namespace Catch::Generators;
|
||||
REQUIRE_THROWS_AS(filter([] (int) {return false; }, value(1)), Catch::GeneratorException);
|
||||
}
|
||||
}
|
||||
SECTION("Shortening a range") {
|
||||
// This takes the first 3 elements from the values, giving back [1, 2, 3]
|
||||
auto i = GENERATE(take(3, values({ 1, 2, 3, 4, 5, 6 })));
|
||||
REQUIRE(i < 4);
|
||||
}
|
||||
SECTION("Transforming elements") {
|
||||
SECTION("Same type") {
|
||||
// This doubles values [1, 2, 3] into [2, 4, 6]
|
||||
auto i = GENERATE(map([] (int val) { return val * 2; }, values({ 1, 2, 3 })));
|
||||
REQUIRE(i % 2 == 0);
|
||||
}
|
||||
SECTION("Different type") {
|
||||
// This takes a generator that returns ints and maps them into strings
|
||||
auto i = GENERATE(map<std::string>([] (int val) { return std::to_string(val); }, values({ 1, 2, 3 })));
|
||||
REQUIRE(i.size() == 1);
|
||||
}
|
||||
SECTION("Different deduced type") {
|
||||
// This takes a generator that returns ints and maps them into strings
|
||||
auto i = GENERATE(map([] (int val) { return std::to_string(val); }, values({ 1, 2, 3 })));
|
||||
REQUIRE(i.size() == 1);
|
||||
}
|
||||
}
|
||||
SECTION("Repeating a generator") {
|
||||
// This will return values [1, 2, 3, 1, 2, 3]
|
||||
auto j = GENERATE(repeat(2, values({ 1, 2, 3 })));
|
||||
REQUIRE(j > 0);
|
||||
}
|
||||
SECTION("Chunking a generator into sized pieces") {
|
||||
SECTION("Number of elements in source is divisible by chunk size") {
|
||||
auto chunk2 = GENERATE(chunk(2, values({ 1, 1, 2, 2, 3, 3 })));
|
||||
REQUIRE(chunk2.size() == 2);
|
||||
REQUIRE(chunk2.front() == chunk2.back());
|
||||
}
|
||||
SECTION("Number of elements in source is not divisible by chunk size") {
|
||||
auto chunk2 = GENERATE(chunk(2, values({ 1, 1, 2, 2, 3 })));
|
||||
REQUIRE(chunk2.size() == 2);
|
||||
REQUIRE(chunk2.front() == chunk2.back());
|
||||
REQUIRE(chunk2.front() < 3);
|
||||
}
|
||||
SECTION("Chunk size of zero") {
|
||||
auto chunk2 = GENERATE(take(3, chunk(0, value(1))));
|
||||
REQUIRE(chunk2.size() == 0);
|
||||
}
|
||||
SECTION("Throws on too small generators") {
|
||||
using namespace Catch::Generators;
|
||||
REQUIRE_THROWS_AS(chunk(2, value(1)), Catch::GeneratorException);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Note that because of the non-reproducibility of distributions,
|
||||
// anything involving the random generators cannot be part of approvals
|
||||
TEST_CASE("Random generator", "[generators][approvals]") {
|
||||
SECTION("Infer int from integral arguments") {
|
||||
auto val = GENERATE(take(4, random(0, 1)));
|
||||
STATIC_REQUIRE(std::is_same<decltype(val), int>::value);
|
||||
REQUIRE(0 <= val);
|
||||
REQUIRE(val <= 1);
|
||||
}
|
||||
SECTION("Infer double from double arguments") {
|
||||
auto val = GENERATE(take(4, random(0., 1.)));
|
||||
STATIC_REQUIRE(std::is_same<decltype(val), double>::value);
|
||||
REQUIRE(0. <= val);
|
||||
REQUIRE(val < 1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
TEST_CASE("Nested generators and captured variables", "[generators]") {
|
||||
// Workaround for old libstdc++
|
||||
using record = std::tuple<int, int>;
|
||||
// Set up 3 ranges to generate numbers from
|
||||
auto extent = GENERATE(table<int, int>({
|
||||
record{3, 7},
|
||||
record{-5, -3},
|
||||
record{90, 100}
|
||||
}));
|
||||
|
||||
auto from = std::get<0>(extent);
|
||||
auto to = std::get<1>(extent);
|
||||
|
||||
auto values = GENERATE_COPY(range(from, to));
|
||||
REQUIRE(values > -6);
|
||||
}
|
||||
|
||||
namespace {
|
||||
size_t call_count = 0;
|
||||
size_t test_count = 0;
|
||||
std::vector<int> make_data() {
|
||||
return { 1, 3, 5, 7, 9, 11 };
|
||||
}
|
||||
std::vector<int> make_data_counted() {
|
||||
++call_count;
|
||||
return make_data();
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(__clang__)
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wexit-time-destructors"
|
||||
#endif
|
||||
|
||||
TEST_CASE("Copy and then generate a range", "[generators]") {
|
||||
SECTION("from var and iterators") {
|
||||
static auto data = make_data();
|
||||
|
||||
// It is important to notice that a generator is only initialized
|
||||
// **once** per run. What this means is that modifying data will not
|
||||
// modify the underlying generator.
|
||||
auto elem = GENERATE_REF(from_range(data.begin(), data.end()));
|
||||
REQUIRE(elem % 2 == 1);
|
||||
}
|
||||
SECTION("From a temporary container") {
|
||||
auto elem = GENERATE(from_range(make_data_counted()));
|
||||
++test_count;
|
||||
REQUIRE(elem % 2 == 1);
|
||||
}
|
||||
SECTION("Final validation") {
|
||||
REQUIRE(call_count == 1);
|
||||
REQUIRE(make_data().size() == test_count);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("#1913 - GENERATE inside a for loop should not keep recreating the generator", "[regression][generators]") {
|
||||
static int counter = 0;
|
||||
for (int i = 0; i < 3; ++i) {
|
||||
int _ = GENERATE(1, 2);
|
||||
(void)_;
|
||||
++counter;
|
||||
}
|
||||
// There should be at most 6 (3 * 2) counter increments
|
||||
REQUIRE(counter < 7);
|
||||
}
|
||||
|
||||
TEST_CASE("#1913 - GENERATEs can share a line", "[regression][generators]") {
|
||||
int i = GENERATE(1, 2); int j = GENERATE(3, 4);
|
||||
REQUIRE(i != j);
|
||||
}
|
||||
|
||||
namespace {
|
||||
class test_generator : public Catch::Generators::IGenerator<int> {
|
||||
public:
|
||||
[[noreturn]] explicit test_generator() {
|
||||
// removing the following line will cause the program to terminate
|
||||
// gracefully.
|
||||
throw Catch::GeneratorException( "failure to init" );
|
||||
}
|
||||
|
||||
auto get() const -> int const& override {
|
||||
static constexpr int value = 1;
|
||||
return value;
|
||||
}
|
||||
|
||||
auto next() -> bool override { return false; }
|
||||
};
|
||||
|
||||
static auto make_test_generator()
|
||||
-> Catch::Generators::GeneratorWrapper<int> {
|
||||
return { new test_generator() };
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
TEST_CASE( "#2615 - Throwing in constructor generator fails test case but does not abort", "[!shouldfail]" ) {
|
||||
// this should fail the test case, but not abort the application
|
||||
auto sample = GENERATE( make_test_generator() );
|
||||
// this assertion shouldn't trigger
|
||||
REQUIRE( sample == 0U );
|
||||
}
|
||||
|
||||
#if defined( __clang__ )
|
||||
# pragma clang diagnostic pop
|
||||
#endif
|
||||
1125
externals/catch2/tests/SelfTest/UsageTests/Matchers.tests.cpp
vendored
Normal file
1125
externals/catch2/tests/SelfTest/UsageTests/Matchers.tests.cpp
vendored
Normal file
File diff suppressed because it is too large
Load Diff
917
externals/catch2/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp
vendored
Normal file
917
externals/catch2/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp
vendored
Normal file
@@ -0,0 +1,917 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/matchers/catch_matchers_container_properties.hpp>
|
||||
#include <catch2/matchers/catch_matchers_contains.hpp>
|
||||
#include <catch2/matchers/catch_matchers_range_equals.hpp>
|
||||
#include <catch2/matchers/catch_matchers_floating_point.hpp>
|
||||
#include <catch2/matchers/catch_matchers_quantifiers.hpp>
|
||||
#include <catch2/matchers/catch_matchers_predicate.hpp>
|
||||
#include <catch2/matchers/catch_matchers_string.hpp>
|
||||
|
||||
#include <helpers/range_test_helpers.hpp>
|
||||
|
||||
#include <cmath>
|
||||
#include <list>
|
||||
#include <map>
|
||||
#include <type_traits>
|
||||
#include <vector>
|
||||
#include <memory>
|
||||
|
||||
struct MoveOnlyTestElement {
|
||||
int num = 0;
|
||||
MoveOnlyTestElement(int n) :num(n) {}
|
||||
|
||||
MoveOnlyTestElement(MoveOnlyTestElement&& rhs) = default;
|
||||
MoveOnlyTestElement& operator=(MoveOnlyTestElement&& rhs) = default;
|
||||
|
||||
friend bool operator==(MoveOnlyTestElement const& lhs, MoveOnlyTestElement const& rhs) {
|
||||
return lhs.num == rhs.num;
|
||||
}
|
||||
|
||||
friend std::ostream& operator<<(std::ostream& out, MoveOnlyTestElement const& elem) {
|
||||
out << elem.num;
|
||||
return out;
|
||||
}
|
||||
};
|
||||
|
||||
TEST_CASE("Basic use of the Contains range matcher", "[matchers][templated][contains]") {
|
||||
using Catch::Matchers::Contains;
|
||||
|
||||
SECTION("Different argument ranges, same element type, default comparison") {
|
||||
std::array<int, 3> a{ { 1,2,3 } };
|
||||
std::vector<int> b{ 0,1,2 };
|
||||
std::list<int> c{ 4,5,6 };
|
||||
|
||||
// A contains 1
|
||||
REQUIRE_THAT(a, Contains(1));
|
||||
// B contains 1
|
||||
REQUIRE_THAT(b, Contains(1));
|
||||
// C does not contain 1
|
||||
REQUIRE_THAT(c, !Contains(1));
|
||||
}
|
||||
|
||||
SECTION("Different argument ranges, same element type, custom comparison") {
|
||||
std::array<int, 3> a{ { 1,2,3 } };
|
||||
std::vector<int> b{ 0,1,2 };
|
||||
std::list<int> c{ 4,5,6 };
|
||||
|
||||
auto close_enough = [](int lhs, int rhs) { return std::abs(lhs - rhs) <= 1; };
|
||||
|
||||
// A contains 1, which is "close enough" to 0
|
||||
REQUIRE_THAT(a, Contains(0, close_enough));
|
||||
// B contains 0 directly
|
||||
REQUIRE_THAT(b, Contains(0, close_enough));
|
||||
// C does not contain anything "close enough" to 0
|
||||
REQUIRE_THAT(c, !Contains(0, close_enough));
|
||||
}
|
||||
|
||||
SECTION("Different element type, custom comparisons") {
|
||||
std::array<std::string, 3> a{ { "abc", "abcd" , "abcde" } };
|
||||
|
||||
REQUIRE_THAT(a, Contains(4, [](auto&& lhs, size_t sz) {
|
||||
return lhs.size() == sz;
|
||||
}));
|
||||
}
|
||||
|
||||
SECTION("Can handle type that requires ADL-found free function begin and end") {
|
||||
unrelated::needs_ADL_begin<int> in{1, 2, 3, 4, 5};
|
||||
|
||||
REQUIRE_THAT(in, Contains(1));
|
||||
REQUIRE_THAT(in, !Contains(8));
|
||||
}
|
||||
|
||||
SECTION("Initialization with move only types") {
|
||||
std::array<MoveOnlyTestElement, 3> in{ { MoveOnlyTestElement{ 1 }, MoveOnlyTestElement{ 2 }, MoveOnlyTestElement{ 3 } } };
|
||||
|
||||
REQUIRE_THAT(in, Contains(MoveOnlyTestElement{ 2 }));
|
||||
REQUIRE_THAT(in, !Contains(MoveOnlyTestElement{ 9 }));
|
||||
}
|
||||
|
||||
SECTION("Matching using matcher") {
|
||||
std::array<double, 4> in{ {1, 2, 3} };
|
||||
|
||||
REQUIRE_THAT(in, Contains(Catch::Matchers::WithinAbs(0.5, 0.5)));
|
||||
}
|
||||
}
|
||||
|
||||
namespace {
|
||||
|
||||
struct has_empty {
|
||||
bool empty() const { return false; }
|
||||
};
|
||||
|
||||
} // end unnamed namespace
|
||||
|
||||
TEST_CASE("Basic use of the Empty range matcher", "[matchers][templated][empty]") {
|
||||
using Catch::Matchers::IsEmpty;
|
||||
SECTION("Simple, std-provided containers") {
|
||||
std::array<int, 0> empty_array{};
|
||||
std::array<double, 1> non_empty_array{};
|
||||
REQUIRE_THAT(empty_array, IsEmpty());
|
||||
REQUIRE_THAT(non_empty_array, !IsEmpty());
|
||||
|
||||
std::vector<std::string> empty_vec;
|
||||
std::vector<char> non_empty_vec{ 'a', 'b', 'c' };
|
||||
REQUIRE_THAT(empty_vec, IsEmpty());
|
||||
REQUIRE_THAT(non_empty_vec, !IsEmpty());
|
||||
|
||||
std::list<std::list<std::list<int>>> inner_lists_are_empty;
|
||||
inner_lists_are_empty.push_back({});
|
||||
REQUIRE_THAT(inner_lists_are_empty, !IsEmpty());
|
||||
REQUIRE_THAT(inner_lists_are_empty.front(), IsEmpty());
|
||||
}
|
||||
SECTION("Type with empty") {
|
||||
REQUIRE_THAT(has_empty{}, !IsEmpty());
|
||||
}
|
||||
SECTION("Type requires ADL found empty free function") {
|
||||
REQUIRE_THAT(unrelated::ADL_empty{}, IsEmpty());
|
||||
}
|
||||
}
|
||||
|
||||
namespace {
|
||||
class LessThanMatcher final : public Catch::Matchers::MatcherBase<size_t> {
|
||||
size_t m_target;
|
||||
public:
|
||||
explicit LessThanMatcher(size_t target):
|
||||
m_target(target)
|
||||
{}
|
||||
|
||||
bool match(size_t const& size) const override {
|
||||
return size < m_target;
|
||||
}
|
||||
|
||||
std::string describe() const override {
|
||||
return "is less than " + std::to_string(m_target);
|
||||
}
|
||||
};
|
||||
|
||||
LessThanMatcher Lt(size_t sz) {
|
||||
return LessThanMatcher{ sz };
|
||||
}
|
||||
|
||||
struct has_size {
|
||||
size_t size() const {
|
||||
return 13;
|
||||
}
|
||||
};
|
||||
|
||||
} // end unnamed namespace
|
||||
|
||||
TEST_CASE("Usage of the SizeIs range matcher", "[matchers][templated][size]") {
|
||||
using Catch::Matchers::SizeIs;
|
||||
SECTION("Some with stdlib containers") {
|
||||
std::vector<int> empty_vec;
|
||||
REQUIRE_THAT(empty_vec, SizeIs(0));
|
||||
REQUIRE_THAT(empty_vec, !SizeIs(2));
|
||||
REQUIRE_THAT(empty_vec, SizeIs(Lt(2)));
|
||||
|
||||
std::array<int, 2> arr{};
|
||||
REQUIRE_THAT(arr, SizeIs(2));
|
||||
REQUIRE_THAT(arr, SizeIs( Lt(3)));
|
||||
REQUIRE_THAT(arr, !SizeIs(!Lt(3)));
|
||||
|
||||
std::map<int, int> map{ {1, 1}, {2, 2}, {3, 3} };
|
||||
REQUIRE_THAT(map, SizeIs(3));
|
||||
}
|
||||
SECTION("Type requires ADL found size free function") {
|
||||
REQUIRE_THAT(unrelated::ADL_size{}, SizeIs(12));
|
||||
}
|
||||
SECTION("Type has size member") {
|
||||
REQUIRE_THAT(has_size{}, SizeIs(13));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
TEST_CASE("Usage of AllMatch range matcher", "[matchers][templated][quantifiers]") {
|
||||
using Catch::Matchers::AllMatch;
|
||||
using Catch::Matchers::Predicate;
|
||||
|
||||
SECTION("Basic usage") {
|
||||
using Catch::Matchers::Contains;
|
||||
using Catch::Matchers::SizeIs;
|
||||
|
||||
std::array<std::array<int, 5>, 5> data{{
|
||||
{{ 0, 1, 2, 3, 5 }},
|
||||
{{ 4,-3,-2, 5, 0 }},
|
||||
{{ 0, 0, 0, 5, 0 }},
|
||||
{{ 0,-5, 0, 5, 0 }},
|
||||
{{ 1, 0, 0,-1, 5 }}
|
||||
}};
|
||||
|
||||
REQUIRE_THAT(data, AllMatch(SizeIs(5)));
|
||||
REQUIRE_THAT(data, !AllMatch(Contains(0) && Contains(1)));
|
||||
}
|
||||
|
||||
SECTION("Type requires ADL found begin and end") {
|
||||
unrelated::needs_ADL_begin<int> needs_adl{ 1, 2, 3, 4, 5 };
|
||||
REQUIRE_THAT( needs_adl, AllMatch( Predicate<int>( []( int elem ) {
|
||||
return elem < 6;
|
||||
} ) ) );
|
||||
}
|
||||
|
||||
SECTION("Shortcircuiting") {
|
||||
with_mocked_iterator_access<int> mocked{ 1, 2, 3, 4, 5 };
|
||||
SECTION("All are read") {
|
||||
auto allMatch = AllMatch(Predicate<int>([](int elem) {
|
||||
return elem < 10;
|
||||
}));
|
||||
REQUIRE_THAT(mocked, allMatch);
|
||||
REQUIRE(mocked.m_derefed[0]);
|
||||
REQUIRE(mocked.m_derefed[1]);
|
||||
REQUIRE(mocked.m_derefed[2]);
|
||||
REQUIRE(mocked.m_derefed[3]);
|
||||
REQUIRE(mocked.m_derefed[4]);
|
||||
}
|
||||
SECTION("Short-circuited") {
|
||||
auto allMatch = AllMatch(Predicate<int>([](int elem) {
|
||||
return elem < 3;
|
||||
}));
|
||||
REQUIRE_THAT(mocked, !allMatch);
|
||||
REQUIRE(mocked.m_derefed[0]);
|
||||
REQUIRE(mocked.m_derefed[1]);
|
||||
REQUIRE(mocked.m_derefed[2]);
|
||||
REQUIRE_FALSE(mocked.m_derefed[3]);
|
||||
REQUIRE_FALSE(mocked.m_derefed[4]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("Usage of AnyMatch range matcher", "[matchers][templated][quantifiers]") {
|
||||
using Catch::Matchers::AnyMatch;
|
||||
using Catch::Matchers::Predicate;
|
||||
|
||||
SECTION("Basic usage") {
|
||||
using Catch::Matchers::Contains;
|
||||
using Catch::Matchers::SizeIs;
|
||||
|
||||
std::array<std::array<int, 5>, 5> data{ {
|
||||
{{ 0, 1, 2, 3, 5 }},
|
||||
{{ 4,-3,-2, 5, 0 }},
|
||||
{{ 0, 0, 0, 5, 0 }},
|
||||
{{ 0,-5, 0, 5, 0 }},
|
||||
{{ 1, 0, 0,-1, 5 }}
|
||||
} };
|
||||
|
||||
REQUIRE_THAT(data, AnyMatch(SizeIs(5)));
|
||||
REQUIRE_THAT(data, !AnyMatch(Contains(0) && Contains(10)));
|
||||
}
|
||||
|
||||
SECTION( "Type requires ADL found begin and end" ) {
|
||||
unrelated::needs_ADL_begin<int> needs_adl{ 1, 2, 3, 4, 5 };
|
||||
REQUIRE_THAT( needs_adl, AnyMatch( Predicate<int>( []( int elem ) {
|
||||
return elem < 3;
|
||||
} ) ) );
|
||||
}
|
||||
|
||||
SECTION("Shortcircuiting") {
|
||||
with_mocked_iterator_access<int> mocked{ 1, 2, 3, 4, 5 };
|
||||
SECTION("All are read") {
|
||||
auto anyMatch = AnyMatch(
|
||||
Predicate<int>( []( int elem ) { return elem > 10; } ) );
|
||||
REQUIRE_THAT( mocked, !anyMatch );
|
||||
REQUIRE( mocked.m_derefed[0] );
|
||||
REQUIRE( mocked.m_derefed[1] );
|
||||
REQUIRE( mocked.m_derefed[2] );
|
||||
REQUIRE( mocked.m_derefed[3] );
|
||||
REQUIRE( mocked.m_derefed[4] );
|
||||
}
|
||||
SECTION("Short-circuited") {
|
||||
auto anyMatch = AnyMatch(
|
||||
Predicate<int>( []( int elem ) { return elem < 3; } ) );
|
||||
REQUIRE_THAT( mocked, anyMatch );
|
||||
REQUIRE( mocked.m_derefed[0] );
|
||||
REQUIRE_FALSE( mocked.m_derefed[1] );
|
||||
REQUIRE_FALSE( mocked.m_derefed[2] );
|
||||
REQUIRE_FALSE( mocked.m_derefed[3] );
|
||||
REQUIRE_FALSE( mocked.m_derefed[4] );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("Usage of NoneMatch range matcher", "[matchers][templated][quantifiers]") {
|
||||
using Catch::Matchers::NoneMatch;
|
||||
using Catch::Matchers::Predicate;
|
||||
|
||||
SECTION("Basic usage") {
|
||||
using Catch::Matchers::Contains;
|
||||
using Catch::Matchers::SizeIs;
|
||||
|
||||
std::array<std::array<int, 5>, 5> data{ {
|
||||
{{ 0, 1, 2, 3, 5 }},
|
||||
{{ 4,-3,-2, 5, 0 }},
|
||||
{{ 0, 0, 0, 5, 0 }},
|
||||
{{ 0,-5, 0, 5, 0 }},
|
||||
{{ 1, 0, 0,-1, 5 }}
|
||||
} };
|
||||
|
||||
REQUIRE_THAT(data, NoneMatch(SizeIs(6)));
|
||||
REQUIRE_THAT(data, !NoneMatch(Contains(0) && Contains(1)));
|
||||
}
|
||||
|
||||
SECTION( "Type requires ADL found begin and end" ) {
|
||||
unrelated::needs_ADL_begin<int> needs_adl{ 1, 2, 3, 4, 5 };
|
||||
REQUIRE_THAT( needs_adl, NoneMatch( Predicate<int>( []( int elem ) {
|
||||
return elem > 6;
|
||||
} ) ) );
|
||||
}
|
||||
|
||||
SECTION("Shortcircuiting") {
|
||||
with_mocked_iterator_access<int> mocked{ 1, 2, 3, 4, 5 };
|
||||
SECTION("All are read") {
|
||||
auto noneMatch = NoneMatch(
|
||||
Predicate<int>([](int elem) { return elem > 10; }));
|
||||
REQUIRE_THAT(mocked, noneMatch);
|
||||
REQUIRE(mocked.m_derefed[0]);
|
||||
REQUIRE(mocked.m_derefed[1]);
|
||||
REQUIRE(mocked.m_derefed[2]);
|
||||
REQUIRE(mocked.m_derefed[3]);
|
||||
REQUIRE(mocked.m_derefed[4]);
|
||||
}
|
||||
SECTION("Short-circuited") {
|
||||
auto noneMatch = NoneMatch(
|
||||
Predicate<int>([](int elem) { return elem < 3; }));
|
||||
REQUIRE_THAT(mocked, !noneMatch);
|
||||
REQUIRE(mocked.m_derefed[0]);
|
||||
REQUIRE_FALSE(mocked.m_derefed[1]);
|
||||
REQUIRE_FALSE(mocked.m_derefed[2]);
|
||||
REQUIRE_FALSE(mocked.m_derefed[3]);
|
||||
REQUIRE_FALSE(mocked.m_derefed[4]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
namespace {
|
||||
struct ConvertibleToBool
|
||||
{
|
||||
bool v;
|
||||
|
||||
explicit operator bool() const
|
||||
{
|
||||
return v;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
namespace Catch {
|
||||
template <>
|
||||
struct StringMaker<ConvertibleToBool> {
|
||||
static std::string
|
||||
convert( ConvertibleToBool const& convertible_to_bool ) {
|
||||
return ::Catch::Detail::stringify( convertible_to_bool.v );
|
||||
}
|
||||
};
|
||||
} // namespace Catch
|
||||
|
||||
TEST_CASE("Usage of AllTrue range matcher", "[matchers][templated][quantifiers]") {
|
||||
using Catch::Matchers::AllTrue;
|
||||
|
||||
SECTION( "Basic usage" ) {
|
||||
SECTION( "All true evaluates to true" ) {
|
||||
std::array<bool, 5> const data{ { true, true, true, true, true } };
|
||||
REQUIRE_THAT( data, AllTrue() );
|
||||
}
|
||||
SECTION( "Empty evaluates to true" ) {
|
||||
std::array<bool, 0> const data{};
|
||||
REQUIRE_THAT( data, AllTrue() );
|
||||
}
|
||||
SECTION( "One false evalutes to false" ) {
|
||||
std::array<bool, 5> const data{ { true, true, false, true, true } };
|
||||
REQUIRE_THAT( data, !AllTrue() );
|
||||
}
|
||||
SECTION( "All false evaluates to false" ) {
|
||||
std::array<bool, 5> const data{
|
||||
{ false, false, false, false, false } };
|
||||
REQUIRE_THAT( data, !AllTrue() );
|
||||
}
|
||||
}
|
||||
|
||||
SECTION( "Contained type is convertible to bool" ) {
|
||||
SECTION( "All true evaluates to true" ) {
|
||||
std::array<ConvertibleToBool, 5> const data{
|
||||
{ { true }, { true }, { true }, { true }, { true } } };
|
||||
REQUIRE_THAT( data, AllTrue() );
|
||||
}
|
||||
SECTION( "One false evalutes to false" ) {
|
||||
std::array<ConvertibleToBool, 5> const data{
|
||||
{ { true }, { true }, { false }, { true }, { true } } };
|
||||
REQUIRE_THAT( data, !AllTrue() );
|
||||
}
|
||||
SECTION( "All false evaluates to false" ) {
|
||||
std::array<ConvertibleToBool, 5> const data{
|
||||
{ { false }, { false }, { false }, { false }, { false } } };
|
||||
REQUIRE_THAT( data, !AllTrue() );
|
||||
}
|
||||
}
|
||||
|
||||
SECTION( "Shortcircuiting" ) {
|
||||
SECTION( "All are read" ) {
|
||||
with_mocked_iterator_access<bool> const mocked{
|
||||
true, true, true, true, true };
|
||||
REQUIRE_THAT( mocked, AllTrue() );
|
||||
REQUIRE( mocked.m_derefed[0] );
|
||||
REQUIRE( mocked.m_derefed[1] );
|
||||
REQUIRE( mocked.m_derefed[2] );
|
||||
REQUIRE( mocked.m_derefed[3] );
|
||||
REQUIRE( mocked.m_derefed[4] );
|
||||
}
|
||||
SECTION( "Short-circuited" ) {
|
||||
with_mocked_iterator_access<bool> const mocked{
|
||||
true, true, false, true, true };
|
||||
REQUIRE_THAT( mocked, !AllTrue() );
|
||||
REQUIRE( mocked.m_derefed[0] );
|
||||
REQUIRE( mocked.m_derefed[1] );
|
||||
REQUIRE( mocked.m_derefed[2] );
|
||||
REQUIRE_FALSE( mocked.m_derefed[3] );
|
||||
REQUIRE_FALSE( mocked.m_derefed[4] );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "Usage of NoneTrue range matcher", "[matchers][templated][quantifiers]" ) {
|
||||
using Catch::Matchers::NoneTrue;
|
||||
|
||||
SECTION( "Basic usage" ) {
|
||||
SECTION( "All true evaluates to false" ) {
|
||||
std::array<bool, 5> const data{ { true, true, true, true, true } };
|
||||
REQUIRE_THAT( data, !NoneTrue() );
|
||||
}
|
||||
SECTION( "Empty evaluates to true" ) {
|
||||
std::array<bool, 0> const data{};
|
||||
REQUIRE_THAT( data, NoneTrue() );
|
||||
}
|
||||
SECTION( "One true evalutes to false" ) {
|
||||
std::array<bool, 5> const data{
|
||||
{ false, false, true, false, false } };
|
||||
REQUIRE_THAT( data, !NoneTrue() );
|
||||
}
|
||||
SECTION( "All false evaluates to true" ) {
|
||||
std::array<bool, 5> const data{
|
||||
{ false, false, false, false, false } };
|
||||
REQUIRE_THAT( data, NoneTrue() );
|
||||
}
|
||||
}
|
||||
|
||||
SECTION( "Contained type is convertible to bool" ) {
|
||||
SECTION( "All true evaluates to false" ) {
|
||||
std::array<ConvertibleToBool, 5> const data{
|
||||
{ { true }, { true }, { true }, { true }, { true } } };
|
||||
REQUIRE_THAT( data, !NoneTrue() );
|
||||
}
|
||||
SECTION( "One true evalutes to false" ) {
|
||||
std::array<ConvertibleToBool, 5> const data{
|
||||
{ { false }, { false }, { true }, { false }, { false } } };
|
||||
REQUIRE_THAT( data, !NoneTrue() );
|
||||
}
|
||||
SECTION( "All false evaluates to true" ) {
|
||||
std::array<ConvertibleToBool, 5> const data{
|
||||
{ { false }, { false }, { false }, { false }, { false } } };
|
||||
REQUIRE_THAT( data, NoneTrue() );
|
||||
}
|
||||
}
|
||||
|
||||
SECTION( "Shortcircuiting" ) {
|
||||
SECTION( "All are read" ) {
|
||||
with_mocked_iterator_access<bool> const mocked{
|
||||
false, false, false, false, false };
|
||||
REQUIRE_THAT( mocked, NoneTrue() );
|
||||
REQUIRE( mocked.m_derefed[0] );
|
||||
REQUIRE( mocked.m_derefed[1] );
|
||||
REQUIRE( mocked.m_derefed[2] );
|
||||
REQUIRE( mocked.m_derefed[3] );
|
||||
REQUIRE( mocked.m_derefed[4] );
|
||||
}
|
||||
SECTION( "Short-circuited" ) {
|
||||
with_mocked_iterator_access<bool> const mocked{
|
||||
false, false, true, true, true };
|
||||
REQUIRE_THAT( mocked, !NoneTrue() );
|
||||
REQUIRE( mocked.m_derefed[0] );
|
||||
REQUIRE( mocked.m_derefed[1] );
|
||||
REQUIRE( mocked.m_derefed[2] );
|
||||
REQUIRE_FALSE( mocked.m_derefed[3] );
|
||||
REQUIRE_FALSE( mocked.m_derefed[4] );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "Usage of AnyTrue range matcher", "[matchers][templated][quantifiers]" ) {
|
||||
using Catch::Matchers::AnyTrue;
|
||||
|
||||
SECTION( "Basic usage" ) {
|
||||
SECTION( "All true evaluates to true" ) {
|
||||
std::array<bool, 5> const data{ { true, true, true, true, true } };
|
||||
REQUIRE_THAT( data, AnyTrue() );
|
||||
}
|
||||
SECTION( "Empty evaluates to false" ) {
|
||||
std::array<bool, 0> const data{};
|
||||
REQUIRE_THAT( data, !AnyTrue() );
|
||||
}
|
||||
SECTION( "One true evalutes to true" ) {
|
||||
std::array<bool, 5> const data{
|
||||
{ false, false, true, false, false } };
|
||||
REQUIRE_THAT( data, AnyTrue() );
|
||||
}
|
||||
SECTION( "All false evaluates to false" ) {
|
||||
std::array<bool, 5> const data{
|
||||
{ false, false, false, false, false } };
|
||||
REQUIRE_THAT( data, !AnyTrue() );
|
||||
}
|
||||
}
|
||||
|
||||
SECTION( "Contained type is convertible to bool" ) {
|
||||
SECTION( "All true evaluates to true" ) {
|
||||
std::array<ConvertibleToBool, 5> const data{
|
||||
{ { true }, { true }, { true }, { true }, { true } } };
|
||||
REQUIRE_THAT( data, AnyTrue() );
|
||||
}
|
||||
SECTION( "One true evalutes to true" ) {
|
||||
std::array<ConvertibleToBool, 5> const data{
|
||||
{ { false }, { false }, { true }, { false }, { false } } };
|
||||
REQUIRE_THAT( data, AnyTrue() );
|
||||
}
|
||||
SECTION( "All false evaluates to false" ) {
|
||||
std::array<ConvertibleToBool, 5> const data{
|
||||
{ { false }, { false }, { false }, { false }, { false } } };
|
||||
REQUIRE_THAT( data, !AnyTrue() );
|
||||
}
|
||||
}
|
||||
|
||||
SECTION( "Shortcircuiting" ) {
|
||||
SECTION( "All are read" ) {
|
||||
with_mocked_iterator_access<bool> const mocked{
|
||||
false, false, false, false, true };
|
||||
REQUIRE_THAT( mocked, AnyTrue() );
|
||||
REQUIRE( mocked.m_derefed[0] );
|
||||
REQUIRE( mocked.m_derefed[1] );
|
||||
REQUIRE( mocked.m_derefed[2] );
|
||||
REQUIRE( mocked.m_derefed[3] );
|
||||
REQUIRE( mocked.m_derefed[4] );
|
||||
}
|
||||
SECTION( "Short-circuited" ) {
|
||||
with_mocked_iterator_access<bool> const mocked{
|
||||
false, false, true, true, true };
|
||||
REQUIRE_THAT( mocked, AnyTrue() );
|
||||
REQUIRE( mocked.m_derefed[0] );
|
||||
REQUIRE( mocked.m_derefed[1] );
|
||||
REQUIRE( mocked.m_derefed[2] );
|
||||
REQUIRE_FALSE( mocked.m_derefed[3] );
|
||||
REQUIRE_FALSE( mocked.m_derefed[4] );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("All/Any/None True matchers support types with ADL begin",
|
||||
"[approvals][matchers][quantifiers][templated]") {
|
||||
using Catch::Matchers::AllTrue;
|
||||
using Catch::Matchers::NoneTrue;
|
||||
using Catch::Matchers::AnyTrue;
|
||||
|
||||
|
||||
SECTION( "Type requires ADL found begin and end" ) {
|
||||
unrelated::needs_ADL_begin<bool> const needs_adl{
|
||||
true, true, true, true, true };
|
||||
REQUIRE_THAT( needs_adl, AllTrue() );
|
||||
}
|
||||
|
||||
SECTION( "Type requires ADL found begin and end" ) {
|
||||
unrelated::needs_ADL_begin<bool> const needs_adl{
|
||||
false, false, false, false, false };
|
||||
REQUIRE_THAT( needs_adl, NoneTrue() );
|
||||
}
|
||||
|
||||
SECTION( "Type requires ADL found begin and end" ) {
|
||||
unrelated::needs_ADL_begin<bool> const needs_adl{
|
||||
false, false, true, false, false };
|
||||
REQUIRE_THAT( needs_adl, AnyTrue() );
|
||||
}
|
||||
}
|
||||
|
||||
// Range loop iterating over range with different types for begin and end is a
|
||||
// C++17 feature, and GCC refuses to compile such code unless the lang mode is
|
||||
// set to C++17 or later.
|
||||
#if defined(CATCH_CPP17_OR_GREATER)
|
||||
|
||||
TEST_CASE( "The quantifier range matchers support types with different types returned from begin and end",
|
||||
"[matchers][templated][quantifiers][approvals]" ) {
|
||||
using Catch::Matchers::AllMatch;
|
||||
using Catch::Matchers::AllTrue;
|
||||
using Catch::Matchers::AnyMatch;
|
||||
using Catch::Matchers::AnyTrue;
|
||||
using Catch::Matchers::NoneMatch;
|
||||
using Catch::Matchers::NoneTrue;
|
||||
|
||||
using Catch::Matchers::Predicate;
|
||||
|
||||
SECTION( "AllAnyNoneMatch" ) {
|
||||
has_different_begin_end_types<int> diff_types{ 1, 2, 3, 4, 5 };
|
||||
REQUIRE_THAT( diff_types, !AllMatch( Predicate<int>( []( int elem ) {
|
||||
return elem < 3;
|
||||
} ) ) );
|
||||
|
||||
REQUIRE_THAT( diff_types, AnyMatch( Predicate<int>( []( int elem ) {
|
||||
return elem < 2;
|
||||
} ) ) );
|
||||
|
||||
REQUIRE_THAT( diff_types, !NoneMatch( Predicate<int>( []( int elem ) {
|
||||
return elem < 3;
|
||||
} ) ) );
|
||||
}
|
||||
SECTION( "AllAnyNoneTrue" ) {
|
||||
has_different_begin_end_types<bool> diff_types{ false, false, true, false, false };
|
||||
|
||||
REQUIRE_THAT( diff_types, !AllTrue() );
|
||||
REQUIRE_THAT( diff_types, AnyTrue() );
|
||||
REQUIRE_THAT( diff_types, !NoneTrue() );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "RangeEquals supports ranges with different types returned from begin and end",
|
||||
"[matchers][templated][range][approvals] ") {
|
||||
using Catch::Matchers::RangeEquals;
|
||||
using Catch::Matchers::UnorderedRangeEquals;
|
||||
|
||||
has_different_begin_end_types<int> diff_types{ 1, 2, 3, 4, 5 };
|
||||
std::array<int, 5> arr1{ { 1, 2, 3, 4, 5 } }, arr2{ { 2, 3, 4, 5, 6 } };
|
||||
|
||||
REQUIRE_THAT( diff_types, RangeEquals( arr1 ) );
|
||||
REQUIRE_THAT( diff_types, RangeEquals( arr2, []( int l, int r ) {
|
||||
return l + 1 == r;
|
||||
} ) );
|
||||
REQUIRE_THAT( diff_types, UnorderedRangeEquals( diff_types ) );
|
||||
}
|
||||
|
||||
TEST_CASE( "RangeContains supports ranges with different types returned from "
|
||||
"begin and end",
|
||||
"[matchers][templated][range][approvals]" ) {
|
||||
using Catch::Matchers::Contains;
|
||||
|
||||
has_different_begin_end_types<size_t> diff_types{ 1, 2, 3, 4, 5 };
|
||||
REQUIRE_THAT( diff_types, Contains( size_t( 3 ) ) );
|
||||
REQUIRE_THAT( diff_types, Contains( LessThanMatcher( size_t( 4 ) ) ) );
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
TEST_CASE( "Usage of RangeEquals range matcher", "[matchers][templated][quantifiers]" ) {
|
||||
using Catch::Matchers::RangeEquals;
|
||||
|
||||
// In these tests, the types are always the same - type conversion is in the next section
|
||||
SECTION( "Basic usage" ) {
|
||||
SECTION( "Empty container matches empty container" ) {
|
||||
const std::vector<int> empty_vector;
|
||||
CHECK_THAT( empty_vector, RangeEquals( empty_vector ) );
|
||||
}
|
||||
SECTION( "Empty container does not match non-empty container" ) {
|
||||
const std::vector<int> empty_vector;
|
||||
const std::vector<int> non_empty_vector{ 1 };
|
||||
CHECK_THAT( empty_vector, !RangeEquals( non_empty_vector ) );
|
||||
// ...and in reverse
|
||||
CHECK_THAT( non_empty_vector, !RangeEquals( empty_vector ) );
|
||||
}
|
||||
SECTION( "Two equal 1-length non-empty containers" ) {
|
||||
const std::array<int, 1> non_empty_array{ { 1 } };
|
||||
CHECK_THAT( non_empty_array, RangeEquals( non_empty_array ) );
|
||||
}
|
||||
SECTION( "Two equal-sized, equal, non-empty containers" ) {
|
||||
const std::array<int, 3> array_a{ { 1, 2, 3 } };
|
||||
CHECK_THAT( array_a, RangeEquals( array_a ) );
|
||||
}
|
||||
SECTION( "Two equal-sized, non-equal, non-empty containers" ) {
|
||||
const std::array<int, 3> array_a{ { 1, 2, 3 } };
|
||||
const std::array<int, 3> array_b{ { 2, 2, 3 } };
|
||||
const std::array<int, 3> array_c{ { 1, 2, 2 } };
|
||||
CHECK_THAT( array_a, !RangeEquals( array_b ) );
|
||||
CHECK_THAT( array_a, !RangeEquals( array_c ) );
|
||||
}
|
||||
SECTION( "Two non-equal-sized, non-empty containers (with same first "
|
||||
"elements)" ) {
|
||||
const std::vector<int> vector_a{ 1, 2, 3 };
|
||||
const std::vector<int> vector_b{ 1, 2, 3, 4 };
|
||||
CHECK_THAT( vector_a, !RangeEquals( vector_b ) );
|
||||
}
|
||||
}
|
||||
|
||||
SECTION( "Custom predicate" ) {
|
||||
|
||||
auto close_enough = []( int lhs, int rhs ) {
|
||||
return std::abs( lhs - rhs ) <= 1;
|
||||
};
|
||||
|
||||
SECTION( "Two equal non-empty containers (close enough)" ) {
|
||||
const std::vector<int> vector_a{ { 1, 2, 3 } };
|
||||
const std::vector<int> vector_a_plus_1{ { 2, 3, 4 } };
|
||||
CHECK_THAT( vector_a, RangeEquals( vector_a_plus_1, close_enough ) );
|
||||
}
|
||||
SECTION( "Two non-equal non-empty containers (close enough)" ) {
|
||||
const std::vector<int> vector_a{ { 1, 2, 3 } };
|
||||
const std::vector<int> vector_b{ { 3, 3, 4 } };
|
||||
CHECK_THAT( vector_a, !RangeEquals( vector_b, close_enough ) );
|
||||
}
|
||||
}
|
||||
|
||||
SECTION( "Ranges that need ADL begin/end" ) {
|
||||
unrelated::needs_ADL_begin<int> const
|
||||
needs_adl1{ 1, 2, 3, 4, 5 },
|
||||
needs_adl2{ 1, 2, 3, 4, 5 },
|
||||
needs_adl3{ 2, 3, 4, 5, 6 };
|
||||
|
||||
REQUIRE_THAT( needs_adl1, RangeEquals( needs_adl2 ) );
|
||||
REQUIRE_THAT( needs_adl1, RangeEquals( needs_adl3, []( int l, int r ) {
|
||||
return l + 1 == r;
|
||||
} ) );
|
||||
}
|
||||
|
||||
SECTION("Check short-circuiting behaviour") {
|
||||
with_mocked_iterator_access<int> const mocked1{ 1, 2, 3, 4 };
|
||||
|
||||
SECTION( "Check short-circuits on failure" ) {
|
||||
std::array<int, 4> arr{ { 1, 2, 4, 4 } };
|
||||
|
||||
REQUIRE_THAT( mocked1, !RangeEquals( arr ) );
|
||||
REQUIRE( mocked1.m_derefed[0] );
|
||||
REQUIRE( mocked1.m_derefed[1] );
|
||||
REQUIRE( mocked1.m_derefed[2] );
|
||||
REQUIRE_FALSE( mocked1.m_derefed[3] );
|
||||
}
|
||||
SECTION("All elements are checked on success") {
|
||||
std::array<int, 4> arr{ { 1, 2, 3, 4 } };
|
||||
|
||||
REQUIRE_THAT( mocked1, RangeEquals( arr ) );
|
||||
REQUIRE( mocked1.m_derefed[0] );
|
||||
REQUIRE( mocked1.m_derefed[1] );
|
||||
REQUIRE( mocked1.m_derefed[2] );
|
||||
REQUIRE( mocked1.m_derefed[3] );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "Usage of UnorderedRangeEquals range matcher",
|
||||
"[matchers][templated][quantifiers]" ) {
|
||||
using Catch::Matchers::UnorderedRangeEquals;
|
||||
|
||||
// In these tests, the types are always the same - type conversion is in the
|
||||
// next section
|
||||
SECTION( "Basic usage" ) {
|
||||
SECTION( "Empty container matches empty container" ) {
|
||||
const std::vector<int> empty_vector;
|
||||
CHECK_THAT( empty_vector, UnorderedRangeEquals( empty_vector ) );
|
||||
}
|
||||
SECTION( "Empty container does not match non-empty container" ) {
|
||||
const std::vector<int> empty_vector;
|
||||
const std::vector<int> non_empty_vector{ 1 };
|
||||
CHECK_THAT( empty_vector,
|
||||
!UnorderedRangeEquals( non_empty_vector ) );
|
||||
// ...and in reverse
|
||||
CHECK_THAT( non_empty_vector,
|
||||
!UnorderedRangeEquals( empty_vector ) );
|
||||
}
|
||||
SECTION( "Two equal 1-length non-empty containers" ) {
|
||||
const std::array<int, 1> non_empty_array{ { 1 } };
|
||||
CHECK_THAT( non_empty_array,
|
||||
UnorderedRangeEquals( non_empty_array ) );
|
||||
}
|
||||
SECTION( "Two equal-sized, equal, non-empty containers" ) {
|
||||
const std::array<int, 3> array_a{ { 1, 2, 3 } };
|
||||
CHECK_THAT( array_a, UnorderedRangeEquals( array_a ) );
|
||||
}
|
||||
SECTION( "Two equal-sized, non-equal, non-empty containers" ) {
|
||||
const std::array<int, 3> array_a{ { 1, 2, 3 } };
|
||||
const std::array<int, 3> array_b{ { 2, 2, 3 } };
|
||||
CHECK_THAT( array_a, !UnorderedRangeEquals( array_b ) );
|
||||
}
|
||||
SECTION( "Two non-equal-sized, non-empty containers" ) {
|
||||
const std::vector<int> vector_a{ 1, 2, 3 };
|
||||
const std::vector<int> vector_b{ 1, 2, 3, 4 };
|
||||
CHECK_THAT( vector_a, !UnorderedRangeEquals( vector_b ) );
|
||||
}
|
||||
}
|
||||
|
||||
SECTION( "Custom predicate" ) {
|
||||
|
||||
auto close_enough = []( int lhs, int rhs ) {
|
||||
return std::abs( lhs - rhs ) <= 1;
|
||||
};
|
||||
|
||||
SECTION( "Two equal non-empty containers (close enough)" ) {
|
||||
const std::vector<int> vector_a{ { 1, 10, 20 } };
|
||||
const std::vector<int> vector_a_plus_1{ { 11, 21, 2 } };
|
||||
CHECK_THAT( vector_a,
|
||||
UnorderedRangeEquals( vector_a_plus_1, close_enough ) );
|
||||
}
|
||||
SECTION( "Two non-equal non-empty containers (close enough)" ) {
|
||||
const std::vector<int> vector_a{ { 1, 10, 21 } };
|
||||
const std::vector<int> vector_b{ { 11, 21, 3 } };
|
||||
CHECK_THAT( vector_a,
|
||||
!UnorderedRangeEquals( vector_b, close_enough ) );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
SECTION( "Ranges that need ADL begin/end" ) {
|
||||
unrelated::needs_ADL_begin<int> const
|
||||
needs_adl1{ 1, 2, 3, 4, 5 },
|
||||
needs_adl2{ 1, 2, 3, 4, 5 };
|
||||
|
||||
REQUIRE_THAT( needs_adl1, UnorderedRangeEquals( needs_adl2 ) );
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Return true if the type given has a random access iterator type.
|
||||
*/
|
||||
template <typename Container>
|
||||
static constexpr bool ContainerIsRandomAccess( const Container& ) {
|
||||
using array_iter_category = typename std::iterator_traits<
|
||||
typename Container::iterator>::iterator_category;
|
||||
|
||||
return std::is_base_of<std::random_access_iterator_tag,
|
||||
array_iter_category>::value;
|
||||
}
|
||||
|
||||
TEST_CASE( "Type conversions of RangeEquals and similar",
|
||||
"[matchers][templated][quantifiers]" ) {
|
||||
using Catch::Matchers::RangeEquals;
|
||||
using Catch::Matchers::UnorderedRangeEquals;
|
||||
|
||||
// In these test, we can always test RangeEquals and
|
||||
// UnorderedRangeEquals in the same way, since we're mostly
|
||||
// testing the template type deductions (and RangeEquals
|
||||
// implies UnorderedRangeEquals)
|
||||
|
||||
SECTION( "Container conversions" ) {
|
||||
SECTION( "Two equal containers of different container types" ) {
|
||||
const std::array<int, 3> array_int_a{ { 1, 2, 3 } };
|
||||
const int c_array[3] = { 1, 2, 3 };
|
||||
CHECK_THAT( array_int_a, RangeEquals( c_array ) );
|
||||
CHECK_THAT( array_int_a, UnorderedRangeEquals( c_array ) );
|
||||
}
|
||||
SECTION( "Two equal containers of different container types "
|
||||
"(differ in array N)" ) {
|
||||
const std::array<int, 3> array_int_3{ { 1, 2, 3 } };
|
||||
const std::array<int, 4> array_int_4{ { 1, 2, 3, 4 } };
|
||||
CHECK_THAT( array_int_3, !RangeEquals( array_int_4 ) );
|
||||
CHECK_THAT( array_int_3, !UnorderedRangeEquals( array_int_4 ) );
|
||||
}
|
||||
SECTION( "Two equal containers of different container types and value "
|
||||
"types" ) {
|
||||
const std::array<int, 3> array_int_a{ { 1, 2, 3 } };
|
||||
const std::vector<int> vector_char_a{ 1, 2, 3 };
|
||||
CHECK_THAT( array_int_a, RangeEquals( vector_char_a ) );
|
||||
CHECK_THAT( array_int_a, UnorderedRangeEquals( vector_char_a ) );
|
||||
}
|
||||
SECTION( "Two equal containers, one random access, one not" ) {
|
||||
const std::array<int, 3> array_int_a{ { 1, 2, 3 } };
|
||||
const std::list<int> list_char_a{ 1, 2, 3 };
|
||||
|
||||
// Verify these types really are different in random access nature
|
||||
STATIC_REQUIRE( ContainerIsRandomAccess( array_int_a ) !=
|
||||
ContainerIsRandomAccess( list_char_a ) );
|
||||
|
||||
CHECK_THAT( array_int_a, RangeEquals( list_char_a ) );
|
||||
CHECK_THAT( array_int_a, UnorderedRangeEquals( list_char_a ) );
|
||||
}
|
||||
}
|
||||
|
||||
SECTION( "Value type" ) {
|
||||
SECTION( "Two equal containers of different value types" ) {
|
||||
const std::vector<int> vector_int_a{ 1, 2, 3 };
|
||||
const std::vector<char> vector_char_a{ 1, 2, 3 };
|
||||
CHECK_THAT( vector_int_a, RangeEquals( vector_char_a ) );
|
||||
CHECK_THAT( vector_int_a, UnorderedRangeEquals( vector_char_a ) );
|
||||
}
|
||||
SECTION( "Two non-equal containers of different value types" ) {
|
||||
const std::vector<int> vector_int_a{ 1, 2, 3 };
|
||||
const std::vector<char> vector_char_b{ 1, 2, 2 };
|
||||
CHECK_THAT( vector_int_a, !RangeEquals( vector_char_b ) );
|
||||
CHECK_THAT( vector_int_a, !UnorderedRangeEquals( vector_char_b ) );
|
||||
}
|
||||
}
|
||||
|
||||
SECTION( "Ranges with begin that needs ADL" ) {
|
||||
unrelated::needs_ADL_begin<int> a{ 1, 2, 3 }, b{ 3, 2, 1 };
|
||||
REQUIRE_THAT( a, !RangeEquals( b ) );
|
||||
REQUIRE_THAT( a, UnorderedRangeEquals( b ) );
|
||||
}
|
||||
|
||||
SECTION( "Custom predicate" ) {
|
||||
|
||||
auto close_enough = []( int lhs, int rhs ) {
|
||||
return std::abs( lhs - rhs ) <= 1;
|
||||
};
|
||||
|
||||
SECTION( "Two equal non-empty containers (close enough)" ) {
|
||||
const std::vector<int> vector_a{ { 1, 2, 3 } };
|
||||
const std::array<char, 3> array_a_plus_1{ { 2, 3, 4 } };
|
||||
CHECK_THAT( vector_a,
|
||||
RangeEquals( array_a_plus_1, close_enough ) );
|
||||
CHECK_THAT( vector_a,
|
||||
UnorderedRangeEquals( array_a_plus_1, close_enough ) );
|
||||
}
|
||||
}
|
||||
}
|
||||
287
externals/catch2/tests/SelfTest/UsageTests/Message.tests.cpp
vendored
Normal file
287
externals/catch2/tests/SelfTest/UsageTests/Message.tests.cpp
vendored
Normal file
@@ -0,0 +1,287 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <iostream>
|
||||
|
||||
TEST_CASE( "INFO and WARN do not abort tests", "[messages][.]" ) {
|
||||
INFO( "this is a " << "message" ); // This should output the message if a failure occurs
|
||||
WARN( "this is a " << "warning" ); // This should always output the message but then continue
|
||||
}
|
||||
|
||||
TEST_CASE( "#1455 - INFO and WARN can start with a linebreak", "[messages][.]" ) {
|
||||
// Previously these would be hidden from the console reporter output,
|
||||
// because it would fail at properly reflowing the text
|
||||
INFO( "\nThis info message starts with a linebreak" );
|
||||
WARN( "\nThis warning message starts with a linebreak" );
|
||||
}
|
||||
|
||||
TEST_CASE( "SUCCEED counts as a test pass", "[messages]" ) {
|
||||
SUCCEED( "this is a " << "success" );
|
||||
}
|
||||
|
||||
TEST_CASE( "INFO gets logged on failure", "[failing][messages][.]" ) {
|
||||
INFO( "this message should be logged" );
|
||||
INFO( "so should this" );
|
||||
int a = 2;
|
||||
REQUIRE( a == 1 );
|
||||
}
|
||||
|
||||
TEST_CASE( "INFO gets logged on failure, even if captured before successful assertions", "[failing][messages][.]" ) {
|
||||
INFO( "this message may be logged later" );
|
||||
int a = 2;
|
||||
CHECK( a == 2 );
|
||||
|
||||
INFO( "this message should be logged" );
|
||||
|
||||
CHECK( a == 1 );
|
||||
|
||||
INFO( "and this, but later" );
|
||||
|
||||
CHECK( a == 0 );
|
||||
|
||||
INFO( "but not this" );
|
||||
|
||||
CHECK( a == 2 );
|
||||
}
|
||||
|
||||
TEST_CASE( "FAIL aborts the test", "[failing][messages][.]" ) {
|
||||
FAIL( "This is a " << "failure" ); // This should output the message and abort
|
||||
WARN( "We should never see this");
|
||||
}
|
||||
|
||||
TEST_CASE( "FAIL_CHECK does not abort the test", "[failing][messages][.]" ) {
|
||||
FAIL_CHECK( "This is a " << "failure" ); // This should output the message then continue
|
||||
WARN( "This message appears in the output");
|
||||
}
|
||||
|
||||
TEST_CASE( "FAIL does not require an argument", "[failing][messages][.]" ) {
|
||||
FAIL();
|
||||
}
|
||||
|
||||
TEST_CASE( "SUCCEED does not require an argument", "[messages][.]" ) {
|
||||
SUCCEED();
|
||||
}
|
||||
|
||||
TEST_CASE( "Output from all sections is reported", "[failing][messages][.]" ) {
|
||||
SECTION( "one" ) {
|
||||
FAIL( "Message from section one" );
|
||||
}
|
||||
|
||||
SECTION( "two" ) {
|
||||
FAIL( "Message from section two" );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "Standard output from all sections is reported", "[messages][.]" ) {
|
||||
SECTION( "one" ) {
|
||||
std::cout << "Message from section one" << std::endl;
|
||||
}
|
||||
|
||||
SECTION( "two" ) {
|
||||
std::cout << "Message from section two" << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "Standard error is reported and redirected", "[messages][.][approvals]" ) {
|
||||
SECTION( "std::cerr" ) {
|
||||
std::cerr << "Write to std::cerr" << std::endl;
|
||||
}
|
||||
SECTION( "std::clog" ) {
|
||||
std::clog << "Write to std::clog" << std::endl;
|
||||
}
|
||||
SECTION( "Interleaved writes to cerr and clog" ) {
|
||||
std::cerr << "Inter";
|
||||
std::clog << "leaved";
|
||||
std::cerr << ' ';
|
||||
std::clog << "writes";
|
||||
std::cerr << " to error";
|
||||
std::clog << " streams" << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "INFO is reset for each loop", "[messages][failing][.]" ) {
|
||||
for( int i=0; i<100; i++ )
|
||||
{
|
||||
INFO( "current counter " << i );
|
||||
CAPTURE( i );
|
||||
REQUIRE( i < 10 );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "The NO_FAIL macro reports a failure but does not fail the test", "[messages]" ) {
|
||||
CHECK_NOFAIL( 1 == 2 );
|
||||
}
|
||||
|
||||
TEST_CASE( "just info", "[info][isolated info][messages]" ) {
|
||||
INFO( "this should never be seen" );
|
||||
}
|
||||
TEST_CASE( "just failure", "[fail][isolated info][.][messages]" ) {
|
||||
FAIL( "Previous info should not be seen" );
|
||||
}
|
||||
|
||||
|
||||
TEST_CASE( "sends information to INFO", "[.][failing]" ) {
|
||||
INFO( "hi" );
|
||||
int i = 7;
|
||||
CAPTURE( i );
|
||||
REQUIRE( false );
|
||||
}
|
||||
|
||||
TEST_CASE( "Pointers can be converted to strings", "[messages][.][approvals]" ) {
|
||||
int p;
|
||||
WARN( "actual address of p: " << &p );
|
||||
WARN( "toString(p): " << ::Catch::Detail::stringify( &p ) );
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
static void unscoped_info( T msg ) {
|
||||
UNSCOPED_INFO( msg );
|
||||
}
|
||||
|
||||
TEST_CASE( "just unscoped info", "[unscoped][info]" ) {
|
||||
unscoped_info( "this should NOT be seen" );
|
||||
unscoped_info( "this also should NOT be seen" );
|
||||
}
|
||||
|
||||
TEST_CASE( "just failure after unscoped info", "[failing][.][unscoped][info]" ) {
|
||||
FAIL( "previous unscoped info SHOULD not be seen" );
|
||||
}
|
||||
|
||||
TEST_CASE( "print unscoped info if passing unscoped info is printed", "[unscoped][info]" ) {
|
||||
unscoped_info( "this MAY be seen IF info is printed for passing assertions" );
|
||||
REQUIRE( true );
|
||||
}
|
||||
|
||||
TEST_CASE( "prints unscoped info on failure", "[failing][.][unscoped][info]" ) {
|
||||
unscoped_info( "this SHOULD be seen" );
|
||||
unscoped_info( "this SHOULD also be seen" );
|
||||
REQUIRE( false );
|
||||
unscoped_info( "but this should NOT be seen" );
|
||||
}
|
||||
|
||||
TEST_CASE( "not prints unscoped info from previous failures", "[failing][.][unscoped][info]" ) {
|
||||
unscoped_info( "this MAY be seen only for the FIRST assertion IF info is printed for passing assertions" );
|
||||
REQUIRE( true );
|
||||
unscoped_info( "this MAY be seen only for the SECOND assertion IF info is printed for passing assertions" );
|
||||
REQUIRE( true );
|
||||
unscoped_info( "this SHOULD be seen" );
|
||||
REQUIRE( false );
|
||||
}
|
||||
|
||||
TEST_CASE( "prints unscoped info only for the first assertion", "[failing][.][unscoped][info]" ) {
|
||||
unscoped_info( "this SHOULD be seen only ONCE" );
|
||||
CHECK( false );
|
||||
CHECK( true );
|
||||
unscoped_info( "this MAY also be seen only ONCE IF info is printed for passing assertions" );
|
||||
CHECK( true );
|
||||
CHECK( true );
|
||||
}
|
||||
|
||||
TEST_CASE( "stacks unscoped info in loops", "[failing][.][unscoped][info]" ) {
|
||||
UNSCOPED_INFO("Count 1 to 3...");
|
||||
for (int i = 1; i <= 3; i++) {
|
||||
unscoped_info(i);
|
||||
}
|
||||
CHECK( false );
|
||||
|
||||
UNSCOPED_INFO("Count 4 to 6...");
|
||||
for (int i = 4; i <= 6; i++) {
|
||||
unscoped_info(i);
|
||||
}
|
||||
CHECK( false );
|
||||
}
|
||||
|
||||
TEST_CASE( "mix info, unscoped info and warning", "[unscoped][info]" ) {
|
||||
INFO("info");
|
||||
unscoped_info("unscoped info");
|
||||
WARN("and warn may mix");
|
||||
WARN("they are not cleared after warnings");
|
||||
}
|
||||
|
||||
TEST_CASE( "CAPTURE can deal with complex expressions", "[messages][capture]" ) {
|
||||
int a = 1;
|
||||
int b = 2;
|
||||
int c = 3;
|
||||
CAPTURE( a, b, c, a + b, a+b, c > b, a == 1 );
|
||||
SUCCEED();
|
||||
}
|
||||
|
||||
#ifdef __clang__
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wunused-value" // In (1, 2), the "1" is unused ...
|
||||
#endif
|
||||
#ifdef __GNUC__
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wunused-value" // All the comma operators are side-effect free
|
||||
#endif
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable:4709) // comma in indexing operator
|
||||
#endif
|
||||
|
||||
template <typename T1, typename T2>
|
||||
struct helper_1436 {
|
||||
helper_1436(T1 t1_, T2 t2_):
|
||||
t1{ t1_ },
|
||||
t2{ t2_ }
|
||||
{}
|
||||
T1 t1;
|
||||
T2 t2;
|
||||
};
|
||||
|
||||
template <typename T1, typename T2>
|
||||
std::ostream& operator<<(std::ostream& out, helper_1436<T1, T2> const& helper) {
|
||||
out << "{ " << helper.t1 << ", " << helper.t2 << " }";
|
||||
return out;
|
||||
}
|
||||
|
||||
// Clang and gcc have different names for this warning, and clang also
|
||||
// warns about an unused value. This warning must be disabled for C++20.
|
||||
#if defined(__GNUG__) && !defined(__clang__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wpragmas"
|
||||
#pragma GCC diagnostic ignored "-Wcomma-subscript"
|
||||
#elif defined(__clang__)
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wunknown-pragmas"
|
||||
#pragma clang diagnostic ignored "-Wunknown-warning-option"
|
||||
#pragma clang diagnostic ignored "-Wdeprecated-comma-subscript"
|
||||
#pragma clang diagnostic ignored "-Wunused-value"
|
||||
#endif
|
||||
|
||||
TEST_CASE("CAPTURE can deal with complex expressions involving commas", "[messages][capture]") {
|
||||
CAPTURE(std::vector<int>{1, 2, 3}[0, 1, 2],
|
||||
std::vector<int>{1, 2, 3}[(0, 1)],
|
||||
std::vector<int>{1, 2, 3}[0]);
|
||||
CAPTURE((helper_1436<int, int>{12, -12}),
|
||||
(helper_1436<int, int>(-12, 12)));
|
||||
CAPTURE( (1, 2), (2, 3) );
|
||||
SUCCEED();
|
||||
}
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
|
||||
TEST_CASE("CAPTURE parses string and character constants", "[messages][capture]") {
|
||||
CAPTURE(("comma, in string", "escaped, \", "), "single quote in string,',", "some escapes, \\,\\\\");
|
||||
CAPTURE("some, ), unmatched, } prenheses {[<");
|
||||
CAPTURE('"', '\'', ',', '}', ')', '(', '{');
|
||||
SUCCEED();
|
||||
}
|
||||
|
||||
#ifdef __clang__
|
||||
#pragma clang diagnostic pop
|
||||
#endif
|
||||
#ifdef __GNUC__
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
553
externals/catch2/tests/SelfTest/UsageTests/Misc.tests.cpp
vendored
Normal file
553
externals/catch2/tests/SelfTest/UsageTests/Misc.tests.cpp
vendored
Normal file
@@ -0,0 +1,553 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/catch_template_test_macros.hpp>
|
||||
#include <catch2/internal/catch_config_wchar.hpp>
|
||||
#include <catch2/internal/catch_windows_h_proxy.hpp>
|
||||
|
||||
#ifdef __clang__
|
||||
# pragma clang diagnostic ignored "-Wc++98-compat"
|
||||
# pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
|
||||
#endif
|
||||
|
||||
|
||||
#include <iostream>
|
||||
#include <cerrno>
|
||||
#include <limits>
|
||||
#include <array>
|
||||
#include <tuple>
|
||||
|
||||
namespace {
|
||||
|
||||
static const char* makeString(bool makeNull) {
|
||||
return makeNull ? nullptr : "valid string";
|
||||
}
|
||||
static bool testCheckedIf(bool flag) {
|
||||
CHECKED_IF(flag)
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
static bool testCheckedElse(bool flag) {
|
||||
CHECKED_ELSE(flag)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static unsigned int Factorial(unsigned int number) {
|
||||
return number > 1 ? Factorial(number - 1) * number : 1;
|
||||
}
|
||||
|
||||
static int f() {
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void manuallyRegisteredTestFunction() {
|
||||
SUCCEED("was called");
|
||||
}
|
||||
|
||||
struct AutoTestReg {
|
||||
AutoTestReg() {
|
||||
REGISTER_TEST_CASE(manuallyRegisteredTestFunction, "ManuallyRegistered");
|
||||
}
|
||||
};
|
||||
|
||||
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
|
||||
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
|
||||
static AutoTestReg autoTestReg;
|
||||
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
|
||||
|
||||
template<typename T>
|
||||
struct Foo {
|
||||
size_t size() { return 0; }
|
||||
};
|
||||
|
||||
template<typename T, size_t S>
|
||||
struct Bar {
|
||||
size_t size() { return S; }
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
TEST_CASE( "random SECTION tests", "[.][sections][failing]" ) {
|
||||
int a = 1;
|
||||
int b = 2;
|
||||
|
||||
SECTION( "doesn't equal" ) {
|
||||
REQUIRE( a != b );
|
||||
REQUIRE( b != a );
|
||||
}
|
||||
|
||||
SECTION( "not equal" ) {
|
||||
REQUIRE( a != b);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "nested SECTION tests", "[.][sections][failing]" ) {
|
||||
int a = 1;
|
||||
int b = 2;
|
||||
|
||||
SECTION( "doesn't equal" ) {
|
||||
REQUIRE( a != b );
|
||||
REQUIRE( b != a );
|
||||
|
||||
SECTION( "not equal" ) {
|
||||
REQUIRE( a != b);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "more nested SECTION tests", "[sections][failing][.]" ) {
|
||||
int a = 1;
|
||||
int b = 2;
|
||||
|
||||
SECTION( "doesn't equal" ) {
|
||||
SECTION( "equal" ) {
|
||||
REQUIRE( a == b );
|
||||
}
|
||||
|
||||
SECTION( "not equal" ) {
|
||||
REQUIRE( a != b );
|
||||
}
|
||||
SECTION( "less than" ) {
|
||||
REQUIRE( a < b );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "even more nested SECTION tests", "[sections]" ) {
|
||||
SECTION( "c" ) {
|
||||
SECTION( "d (leaf)" ) {
|
||||
SUCCEED(); // avoid failing due to no tests
|
||||
}
|
||||
|
||||
SECTION( "e (leaf)" ) {
|
||||
SUCCEED(); // avoid failing due to no tests
|
||||
}
|
||||
}
|
||||
|
||||
SECTION( "f (leaf)" ) {
|
||||
SUCCEED(); // avoid failing due to no tests
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "looped SECTION tests", "[.][failing][sections]" ) {
|
||||
int a = 1;
|
||||
|
||||
for( int b = 0; b < 10; ++b ) {
|
||||
DYNAMIC_SECTION( "b is currently: " << b ) {
|
||||
CHECK( b > a );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "looped tests", "[.][failing]" ) {
|
||||
static const int fib[] = { 1, 1, 2, 3, 5, 8, 13, 21 };
|
||||
|
||||
for( std::size_t i=0; i < sizeof(fib)/sizeof(int); ++i ) {
|
||||
INFO( "Testing if fib[" << i << "] (" << fib[i] << ") is even" );
|
||||
CHECK( ( fib[i] % 2 ) == 0 );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "Sends stuff to stdout and stderr", "[.]" ) {
|
||||
std::cout << "A string sent directly to stdout" << std::endl;
|
||||
std::cerr << "A string sent directly to stderr" << std::endl;
|
||||
std::clog << "A string sent to stderr via clog" << std::endl;
|
||||
}
|
||||
|
||||
TEST_CASE( "null strings" ) {
|
||||
REQUIRE( makeString( false ) != static_cast<char*>(nullptr));
|
||||
REQUIRE( makeString( true ) == static_cast<char*>(nullptr));
|
||||
}
|
||||
|
||||
TEST_CASE( "checkedIf" ) {
|
||||
REQUIRE( testCheckedIf( true ) );
|
||||
}
|
||||
|
||||
TEST_CASE( "checkedIf, failing", "[failing][.]" ) {
|
||||
REQUIRE( testCheckedIf( false ) );
|
||||
}
|
||||
|
||||
TEST_CASE( "checkedElse" ) {
|
||||
REQUIRE( testCheckedElse( true ) );
|
||||
}
|
||||
|
||||
TEST_CASE( "checkedElse, failing", "[failing][.]" ) {
|
||||
REQUIRE( testCheckedElse( false ) );
|
||||
}
|
||||
|
||||
TEST_CASE("Testing checked-if", "[checked-if]") {
|
||||
CHECKED_IF(true) {
|
||||
SUCCEED();
|
||||
}
|
||||
CHECKED_IF(false) {
|
||||
FAIL();
|
||||
}
|
||||
CHECKED_ELSE(true) {
|
||||
FAIL();
|
||||
}
|
||||
CHECKED_ELSE(false) {
|
||||
SUCCEED();
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("Testing checked-if 2", "[checked-if][!shouldfail]") {
|
||||
CHECKED_IF(true) {
|
||||
FAIL();
|
||||
}
|
||||
// If the checked if is not entered, this passes and the test
|
||||
// fails, because of the [!shouldfail] tag.
|
||||
SUCCEED();
|
||||
}
|
||||
|
||||
TEST_CASE("Testing checked-if 3", "[checked-if][!shouldfail]") {
|
||||
CHECKED_ELSE(false) {
|
||||
FAIL();
|
||||
}
|
||||
// If the checked false is not entered, this passes and the test
|
||||
// fails, because of the [!shouldfail] tag.
|
||||
SUCCEED();
|
||||
}
|
||||
|
||||
TEST_CASE( "xmlentitycheck" ) {
|
||||
SECTION( "embedded xml: <test>it should be possible to embed xml characters, such as <, \" or &, or even whole <xml>documents</xml> within an attribute</test>" ) {
|
||||
SUCCEED(); // We need this here to stop it failing due to no tests
|
||||
}
|
||||
SECTION( "encoded chars: these should all be encoded: &&&\"\"\"<<<&\"<<&\"" ) {
|
||||
SUCCEED(); // We need this here to stop it failing due to no tests
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "send a single char to INFO", "[failing][.]" ) {
|
||||
INFO(3);
|
||||
REQUIRE(false);
|
||||
}
|
||||
|
||||
TEST_CASE( "Factorials are computed", "[factorial]" ) {
|
||||
REQUIRE( Factorial(0) == 1 );
|
||||
REQUIRE( Factorial(1) == 1 );
|
||||
REQUIRE( Factorial(2) == 2 );
|
||||
REQUIRE( Factorial(3) == 6 );
|
||||
REQUIRE( Factorial(10) == 3628800 );
|
||||
}
|
||||
|
||||
TEST_CASE( "An empty test with no assertions", "[empty]" ) {}
|
||||
|
||||
TEST_CASE( "Nice descriptive name", "[tag1][tag2][tag3][.]" ) {
|
||||
WARN( "This one ran" );
|
||||
}
|
||||
TEST_CASE( "first tag", "[tag1]" ) {}
|
||||
TEST_CASE( "second tag", "[tag2]" ) {}
|
||||
|
||||
TEST_CASE( "vectors can be sized and resized", "[vector]" ) {
|
||||
|
||||
std::vector<int> v( 5 );
|
||||
|
||||
REQUIRE( v.size() == 5 );
|
||||
REQUIRE( v.capacity() >= 5 );
|
||||
|
||||
SECTION( "resizing bigger changes size and capacity" ) {
|
||||
v.resize( 10 );
|
||||
|
||||
REQUIRE( v.size() == 10 );
|
||||
REQUIRE( v.capacity() >= 10 );
|
||||
}
|
||||
SECTION( "resizing smaller changes size but not capacity" ) {
|
||||
v.resize( 0 );
|
||||
|
||||
REQUIRE( v.size() == 0 );
|
||||
REQUIRE( v.capacity() >= 5 );
|
||||
|
||||
SECTION( "We can use the 'swap trick' to reset the capacity" ) {
|
||||
std::vector<int> empty;
|
||||
empty.swap( v );
|
||||
|
||||
REQUIRE( v.capacity() == 0 );
|
||||
}
|
||||
}
|
||||
SECTION( "reserving bigger changes capacity but not size" ) {
|
||||
v.reserve( 10 );
|
||||
|
||||
REQUIRE( v.size() == 5 );
|
||||
REQUIRE( v.capacity() >= 10 );
|
||||
}
|
||||
SECTION( "reserving smaller does not change size or capacity" ) {
|
||||
v.reserve( 0 );
|
||||
|
||||
REQUIRE( v.size() == 5 );
|
||||
REQUIRE( v.capacity() >= 5 );
|
||||
}
|
||||
}
|
||||
|
||||
TEMPLATE_TEST_CASE( "TemplateTest: vectors can be sized and resized", "[vector][template]", int, float, std::string, (std::tuple<int,float>) ) {
|
||||
|
||||
std::vector<TestType> v( 5 );
|
||||
|
||||
REQUIRE( v.size() == 5 );
|
||||
REQUIRE( v.capacity() >= 5 );
|
||||
|
||||
SECTION( "resizing bigger changes size and capacity" ) {
|
||||
v.resize( 10 );
|
||||
|
||||
REQUIRE( v.size() == 10 );
|
||||
REQUIRE( v.capacity() >= 10 );
|
||||
}
|
||||
SECTION( "resizing smaller changes size but not capacity" ) {
|
||||
v.resize( 0 );
|
||||
|
||||
REQUIRE( v.size() == 0 );
|
||||
REQUIRE( v.capacity() >= 5 );
|
||||
|
||||
SECTION( "We can use the 'swap trick' to reset the capacity" ) {
|
||||
std::vector<TestType> empty;
|
||||
empty.swap( v );
|
||||
|
||||
REQUIRE( v.capacity() == 0 );
|
||||
}
|
||||
}
|
||||
SECTION( "reserving bigger changes capacity but not size" ) {
|
||||
v.reserve( 10 );
|
||||
|
||||
REQUIRE( v.size() == 5 );
|
||||
REQUIRE( v.capacity() >= 10 );
|
||||
}
|
||||
SECTION( "reserving smaller does not change size or capacity" ) {
|
||||
v.reserve( 0 );
|
||||
|
||||
REQUIRE( v.size() == 5 );
|
||||
REQUIRE( v.capacity() >= 5 );
|
||||
}
|
||||
}
|
||||
|
||||
TEMPLATE_TEST_CASE_SIG("TemplateTestSig: vectors can be sized and resized", "[vector][template][nttp]", ((typename TestType, int V), TestType, V), (int,5), (float,4), (std::string,15), ((std::tuple<int, float>), 6)) {
|
||||
|
||||
std::vector<TestType> v(V);
|
||||
|
||||
REQUIRE(v.size() == V);
|
||||
REQUIRE(v.capacity() >= V);
|
||||
|
||||
SECTION("resizing bigger changes size and capacity") {
|
||||
v.resize(2 * V);
|
||||
|
||||
REQUIRE(v.size() == 2 * V);
|
||||
REQUIRE(v.capacity() >= 2 * V);
|
||||
}
|
||||
SECTION("resizing smaller changes size but not capacity") {
|
||||
v.resize(0);
|
||||
|
||||
REQUIRE(v.size() == 0);
|
||||
REQUIRE(v.capacity() >= V);
|
||||
|
||||
SECTION("We can use the 'swap trick' to reset the capacity") {
|
||||
std::vector<TestType> empty;
|
||||
empty.swap(v);
|
||||
|
||||
REQUIRE(v.capacity() == 0);
|
||||
}
|
||||
}
|
||||
SECTION("reserving bigger changes capacity but not size") {
|
||||
v.reserve(2 * V);
|
||||
|
||||
REQUIRE(v.size() == V);
|
||||
REQUIRE(v.capacity() >= 2 * V);
|
||||
}
|
||||
SECTION("reserving smaller does not change size or capacity") {
|
||||
v.reserve(0);
|
||||
|
||||
REQUIRE(v.size() == V);
|
||||
REQUIRE(v.capacity() >= V);
|
||||
}
|
||||
}
|
||||
|
||||
TEMPLATE_PRODUCT_TEST_CASE("A Template product test case", "[template][product]", (std::vector, Foo), (int, float)) {
|
||||
TestType x;
|
||||
REQUIRE(x.size() == 0);
|
||||
}
|
||||
|
||||
TEMPLATE_PRODUCT_TEST_CASE_SIG("A Template product test case with array signature", "[template][product][nttp]", ((typename T, size_t S), T, S), (std::array, Bar), ((int, 9), (float, 42))) {
|
||||
TestType x;
|
||||
REQUIRE(x.size() > 0);
|
||||
}
|
||||
|
||||
TEMPLATE_PRODUCT_TEST_CASE("Product with differing arities", "[template][product]", std::tuple, (int, (int, double), (int, double, float))) {
|
||||
REQUIRE(std::tuple_size<TestType>::value >= 1);
|
||||
}
|
||||
|
||||
using MyTypes = std::tuple<int, char, float>;
|
||||
TEMPLATE_LIST_TEST_CASE("Template test case with test types specified inside std::tuple", "[template][list]", MyTypes)
|
||||
{
|
||||
REQUIRE(sizeof(TestType) > 0);
|
||||
}
|
||||
|
||||
struct NonDefaultConstructibleType {
|
||||
NonDefaultConstructibleType() = delete;
|
||||
};
|
||||
|
||||
using MyNonDefaultConstructibleTypes = std::tuple<NonDefaultConstructibleType, float>;
|
||||
TEMPLATE_LIST_TEST_CASE("Template test case with test types specified inside non-default-constructible std::tuple", "[template][list]", MyNonDefaultConstructibleTypes)
|
||||
{
|
||||
REQUIRE(sizeof(TestType) > 0);
|
||||
}
|
||||
|
||||
struct NonCopyableAndNonMovableType {
|
||||
NonCopyableAndNonMovableType() = default;
|
||||
|
||||
NonCopyableAndNonMovableType(NonCopyableAndNonMovableType const &) = delete;
|
||||
NonCopyableAndNonMovableType(NonCopyableAndNonMovableType &&) = delete;
|
||||
auto operator=(NonCopyableAndNonMovableType const &) -> NonCopyableAndNonMovableType & = delete;
|
||||
auto operator=(NonCopyableAndNonMovableType &&) -> NonCopyableAndNonMovableType & = delete;
|
||||
};
|
||||
|
||||
using NonCopyableAndNonMovableTypes = std::tuple<NonCopyableAndNonMovableType, float>;
|
||||
TEMPLATE_LIST_TEST_CASE("Template test case with test types specified inside non-copyable and non-movable std::tuple", "[template][list]", NonCopyableAndNonMovableTypes)
|
||||
{
|
||||
REQUIRE(sizeof(TestType) > 0);
|
||||
}
|
||||
|
||||
// https://github.com/philsquared/Catch/issues/166
|
||||
TEST_CASE("A couple of nested sections followed by a failure", "[failing][.]") {
|
||||
SECTION("Outer")
|
||||
SECTION("Inner")
|
||||
SUCCEED("that's not flying - that's failing in style");
|
||||
|
||||
FAIL("to infinity and beyond");
|
||||
}
|
||||
|
||||
TEST_CASE("not allowed", "[!throws]") {
|
||||
// This test case should not be included if you run with -e on the command line
|
||||
SUCCEED();
|
||||
}
|
||||
|
||||
TEST_CASE( "Tabs and newlines show in output", "[.][whitespace][failing]" ) {
|
||||
|
||||
// Based on issue #242
|
||||
std::string s1 = "if ($b == 10) {\n\t\t$a\t= 20;\n}";
|
||||
std::string s2 = "if ($b == 10) {\n\t$a = 20;\n}\n";
|
||||
CHECK( s1 == s2 );
|
||||
}
|
||||
|
||||
|
||||
#if defined(CATCH_CONFIG_WCHAR)
|
||||
TEST_CASE( "toString on const wchar_t const pointer returns the string contents", "[toString]" ) {
|
||||
const wchar_t * const s = L"wide load";
|
||||
std::string result = ::Catch::Detail::stringify( s );
|
||||
CHECK( result == "\"wide load\"" );
|
||||
}
|
||||
|
||||
TEST_CASE( "toString on const wchar_t pointer returns the string contents", "[toString]" ) {
|
||||
const wchar_t * s = L"wide load";
|
||||
std::string result = ::Catch::Detail::stringify( s );
|
||||
CHECK( result == "\"wide load\"" );
|
||||
}
|
||||
|
||||
TEST_CASE( "toString on wchar_t const pointer returns the string contents", "[toString]" ) {
|
||||
auto const s = const_cast<wchar_t*>( L"wide load" );
|
||||
std::string result = ::Catch::Detail::stringify( s );
|
||||
CHECK( result == "\"wide load\"" );
|
||||
}
|
||||
|
||||
TEST_CASE( "toString on wchar_t returns the string contents", "[toString]" ) {
|
||||
auto s = const_cast<wchar_t*>( L"wide load" );
|
||||
std::string result = ::Catch::Detail::stringify( s );
|
||||
CHECK( result == "\"wide load\"" );
|
||||
}
|
||||
#endif // CATCH_CONFIG_WCHAR
|
||||
|
||||
TEST_CASE( "long long" ) {
|
||||
constexpr long long l = std::numeric_limits<long long>::max();
|
||||
|
||||
REQUIRE( l == std::numeric_limits<long long>::max() );
|
||||
}
|
||||
|
||||
TEST_CASE( "This test 'should' fail but doesn't", "[.][failing][!shouldfail]" ) {
|
||||
SUCCEED( "oops!" );
|
||||
}
|
||||
|
||||
TEST_CASE( "# A test name that starts with a #" ) {
|
||||
SUCCEED( "yay" );
|
||||
}
|
||||
|
||||
TEST_CASE( "#835 -- errno should not be touched by Catch2", "[.][failing][!shouldfail]" ) {
|
||||
errno = 1;
|
||||
// Check that reporting failed test doesn't change errno.
|
||||
CHECK(f() == 0);
|
||||
// We want to avoid expanding `errno` macro in assertion, because
|
||||
// we capture the expression after macro expansion, and would have
|
||||
// to normalize the ways different platforms spell `errno`.
|
||||
const auto errno_after = errno;
|
||||
REQUIRE(errno_after == 1);
|
||||
}
|
||||
|
||||
TEST_CASE( "#961 -- Dynamically created sections should all be reported", "[.]" ) {
|
||||
for (char i = '0'; i < '5'; ++i) {
|
||||
SECTION(std::string("Looped section ") + i) {
|
||||
SUCCEED( "Everything is OK" );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "#1175 - Hidden Test", "[.]" ) {
|
||||
// Just for checking that hidden test is not listed by default
|
||||
SUCCEED();
|
||||
}
|
||||
|
||||
TEMPLATE_TEST_CASE_SIG("#1954 - 7 arg template test case sig compiles", "[regression][.compilation]",
|
||||
((int Tnx, int Tnu, int Tny, int Tph, int Tch, int Tineq, int Teq), Tnx, Tnu, Tny, Tph, Tch, Tineq, Teq),
|
||||
(1, 1, 1, 1, 1, 0, 0), (5, 1, 1, 1, 1, 0, 0), (5, 3, 1, 1, 1, 0, 0)) {
|
||||
SUCCEED();
|
||||
}
|
||||
|
||||
TEST_CASE("Same test name but with different tags is fine", "[.approvals][some-tag]") {}
|
||||
TEST_CASE("Same test name but with different tags is fine", "[.approvals][other-tag]") {}
|
||||
|
||||
// MinGW doesn't support __try, and Clang has only very partial support
|
||||
#if defined(_MSC_VER)
|
||||
void throw_and_catch()
|
||||
{
|
||||
__try {
|
||||
RaiseException(0xC0000005, 0, 0, NULL);
|
||||
}
|
||||
__except (1)
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
TEST_CASE("Validate SEH behavior - handled", "[approvals][FatalConditionHandler][CATCH_PLATFORM_WINDOWS]")
|
||||
{
|
||||
// Validate that Catch2 framework correctly handles tests raising and handling SEH exceptions.
|
||||
throw_and_catch();
|
||||
}
|
||||
|
||||
void throw_no_catch()
|
||||
{
|
||||
RaiseException(0xC0000005, 0, 0, NULL);
|
||||
}
|
||||
|
||||
TEST_CASE("Validate SEH behavior - unhandled", "[.approvals][FatalConditionHandler][CATCH_PLATFORM_WINDOWS]")
|
||||
{
|
||||
// Validate that Catch2 framework correctly handles tests raising and not handling SEH exceptions.
|
||||
throw_no_catch();
|
||||
}
|
||||
|
||||
static LONG CALLBACK dummyExceptionFilter(PEXCEPTION_POINTERS ExceptionInfo) {
|
||||
return EXCEPTION_CONTINUE_SEARCH;
|
||||
}
|
||||
|
||||
TEST_CASE("Validate SEH behavior - no crash for stack unwinding", "[approvals][!throws][!shouldfail][FatalConditionHandler][CATCH_PLATFORM_WINDOWS]")
|
||||
{
|
||||
// Trigger stack unwinding with SEH top-level filter changed and validate the test fails expectedly with no application crash
|
||||
SetUnhandledExceptionFilter(dummyExceptionFilter);
|
||||
throw 1;
|
||||
}
|
||||
|
||||
#endif // _MSC_VER
|
||||
73
externals/catch2/tests/SelfTest/UsageTests/Skip.tests.cpp
vendored
Normal file
73
externals/catch2/tests/SelfTest/UsageTests/Skip.tests.cpp
vendored
Normal file
@@ -0,0 +1,73 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/generators/catch_generators_range.hpp>
|
||||
|
||||
#include <iostream>
|
||||
|
||||
TEST_CASE( "tests can be skipped dynamically at runtime", "[skipping]" ) {
|
||||
SKIP();
|
||||
FAIL( "this is not reached" );
|
||||
}
|
||||
|
||||
TEST_CASE( "skipped tests can optionally provide a reason", "[skipping]" ) {
|
||||
const int answer = 43;
|
||||
SKIP( "skipping because answer = " << answer );
|
||||
FAIL( "this is not reached" );
|
||||
}
|
||||
|
||||
TEST_CASE( "sections can be skipped dynamically at runtime", "[skipping]" ) {
|
||||
SECTION( "not skipped" ) { SUCCEED(); }
|
||||
SECTION( "skipped" ) { SKIP(); }
|
||||
SECTION( "also not skipped" ) { SUCCEED(); }
|
||||
}
|
||||
|
||||
TEST_CASE( "nested sections can be skipped dynamically at runtime",
|
||||
"[skipping]" ) {
|
||||
SECTION( "A" ) { std::cout << "a"; }
|
||||
SECTION( "B" ) {
|
||||
SECTION( "B1" ) { std::cout << "b1"; }
|
||||
SECTION( "B2" ) { SKIP(); }
|
||||
}
|
||||
std::cout << "!\n";
|
||||
}
|
||||
|
||||
TEST_CASE( "dynamic skipping works with generators", "[skipping]" ) {
|
||||
const int answer = GENERATE( 41, 42, 43 );
|
||||
if ( answer != 42 ) { SKIP( "skipping because answer = " << answer ); }
|
||||
SUCCEED();
|
||||
}
|
||||
|
||||
TEST_CASE( "failed assertions before SKIP cause test case to fail",
|
||||
"[skipping][!shouldfail]" ) {
|
||||
CHECK( 3 == 4 );
|
||||
SKIP();
|
||||
}
|
||||
|
||||
TEST_CASE( "a succeeding test can still be skipped",
|
||||
"[skipping][!shouldfail]" ) {
|
||||
SUCCEED();
|
||||
SKIP();
|
||||
}
|
||||
|
||||
TEST_CASE( "failing in some unskipped sections causes entire test case to fail",
|
||||
"[skipping][!shouldfail]" ) {
|
||||
SECTION( "skipped" ) { SKIP(); }
|
||||
SECTION( "not skipped" ) { FAIL(); }
|
||||
}
|
||||
|
||||
TEST_CASE( "failing for some generator values causes entire test case to fail",
|
||||
"[skipping][!shouldfail]" ) {
|
||||
int i = GENERATE( 1, 2, 3, 4 );
|
||||
if ( i % 2 == 0 ) {
|
||||
SKIP();
|
||||
} else {
|
||||
FAIL();
|
||||
}
|
||||
}
|
||||
23
externals/catch2/tests/SelfTest/UsageTests/ToStringByte.tests.cpp
vendored
Normal file
23
externals/catch2/tests/SelfTest/UsageTests/ToStringByte.tests.cpp
vendored
Normal file
@@ -0,0 +1,23 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
|
||||
#if defined(CATCH_CONFIG_CPP17_BYTE)
|
||||
|
||||
TEST_CASE( "std::byte -> toString", "[toString][byte][approvals]" ) {
|
||||
using type = std::byte;
|
||||
REQUIRE( "0" == ::Catch::Detail::stringify( type{ 0 } ) );
|
||||
}
|
||||
|
||||
TEST_CASE( "std::vector<std::byte> -> toString", "[toString][byte][approvals]" ) {
|
||||
using type = std::vector<std::byte>;
|
||||
REQUIRE( "{ 0, 1, 2 }" == ::Catch::Detail::stringify( type{ std::byte{0}, std::byte{1}, std::byte{2} } ) );
|
||||
}
|
||||
|
||||
#endif // CATCH_INTERNAL_CONFIG_CPP17_BYTE
|
||||
51
externals/catch2/tests/SelfTest/UsageTests/ToStringChrono.tests.cpp
vendored
Normal file
51
externals/catch2/tests/SelfTest/UsageTests/ToStringChrono.tests.cpp
vendored
Normal file
@@ -0,0 +1,51 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
|
||||
#include <chrono>
|
||||
#include <cstdint>
|
||||
|
||||
TEST_CASE("Stringifying std::chrono::duration helpers", "[toString][chrono]") {
|
||||
// No literals because we still support c++11
|
||||
auto hour = std::chrono::hours(1);
|
||||
auto minute = std::chrono::minutes(1);
|
||||
auto seconds = std::chrono::seconds(60);
|
||||
auto micro = std::chrono::microseconds(1);
|
||||
auto milli = std::chrono::milliseconds(1);
|
||||
auto nano = std::chrono::nanoseconds(1);
|
||||
REQUIRE(minute == seconds);
|
||||
REQUIRE(hour != seconds);
|
||||
REQUIRE(micro != milli);
|
||||
REQUIRE(nano != micro);
|
||||
}
|
||||
|
||||
TEST_CASE("Stringifying std::chrono::duration with weird ratios", "[toString][chrono]") {
|
||||
std::chrono::duration<int64_t, std::ratio<30>> half_minute(1);
|
||||
std::chrono::duration<int64_t, std::ratio<1, 1000000000000>> pico_second(1);
|
||||
std::chrono::duration<int64_t, std::ratio<1, 1000000000000000>> femto_second(1);
|
||||
std::chrono::duration<int64_t, std::ratio<1, 1000000000000000000>> atto_second(1);
|
||||
REQUIRE(half_minute != femto_second);
|
||||
REQUIRE(pico_second != atto_second);
|
||||
}
|
||||
|
||||
TEST_CASE("Stringifying std::chrono::time_point<system_clock>", "[toString][chrono]") {
|
||||
auto now = std::chrono::system_clock::now();
|
||||
auto later = now + std::chrono::minutes(2);
|
||||
REQUIRE(now != later);
|
||||
}
|
||||
|
||||
TEST_CASE("Stringifying std::chrono::time_point<Clock>", "[toString][chrono][!nonportable]") {
|
||||
auto now = std::chrono::high_resolution_clock::now();
|
||||
auto later = now + std::chrono::minutes(2);
|
||||
REQUIRE(now != later);
|
||||
|
||||
auto now2 = std::chrono::steady_clock::now();
|
||||
auto later2 = now2 + std::chrono::minutes(2);
|
||||
REQUIRE(now2 != later2);
|
||||
}
|
||||
211
externals/catch2/tests/SelfTest/UsageTests/ToStringGeneral.tests.cpp
vendored
Normal file
211
externals/catch2/tests/SelfTest/UsageTests/ToStringGeneral.tests.cpp
vendored
Normal file
@@ -0,0 +1,211 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
|
||||
#include <map>
|
||||
#include <set>
|
||||
|
||||
TEST_CASE( "Character pretty printing" ){
|
||||
SECTION("Specifically escaped"){
|
||||
char tab = '\t';
|
||||
char newline = '\n';
|
||||
char carr_return = '\r';
|
||||
char form_feed = '\f';
|
||||
CHECK(tab == '\t');
|
||||
CHECK(newline == '\n');
|
||||
CHECK(carr_return == '\r');
|
||||
CHECK(form_feed == '\f');
|
||||
}
|
||||
SECTION("General chars"){
|
||||
char space = ' ';
|
||||
CHECK(space == ' ');
|
||||
char chars[] = {'a', 'z', 'A', 'Z'};
|
||||
for (int i = 0; i < 4; ++i){
|
||||
char c = chars[i];
|
||||
REQUIRE(c == chars[i]);
|
||||
}
|
||||
}
|
||||
SECTION("Low ASCII"){
|
||||
char null_terminator = '\0';
|
||||
CHECK(null_terminator == '\0');
|
||||
for (int i = 2; i < 6; ++i){
|
||||
char c = static_cast<char>(i);
|
||||
REQUIRE(c == i);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
TEST_CASE( "Capture and info messages" ) {
|
||||
SECTION("Capture should stringify like assertions") {
|
||||
int i = 2;
|
||||
CAPTURE(i);
|
||||
REQUIRE(true);
|
||||
}
|
||||
SECTION("Info should NOT stringify the way assertions do") {
|
||||
int i = 3;
|
||||
INFO(i);
|
||||
REQUIRE(true);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "std::map is convertible string", "[toString]" ) {
|
||||
|
||||
SECTION( "empty" ) {
|
||||
std::map<std::string, int> emptyMap;
|
||||
|
||||
REQUIRE( Catch::Detail::stringify( emptyMap ) == "{ }" );
|
||||
}
|
||||
|
||||
SECTION( "single item" ) {
|
||||
std::map<std::string, int> map = { { "one", 1 } };
|
||||
|
||||
REQUIRE( Catch::Detail::stringify( map ) == "{ { \"one\", 1 } }" );
|
||||
}
|
||||
|
||||
SECTION( "several items" ) {
|
||||
std::map<std::string, int> map = {
|
||||
{ "abc", 1 },
|
||||
{ "def", 2 },
|
||||
{ "ghi", 3 }
|
||||
};
|
||||
|
||||
REQUIRE( Catch::Detail::stringify( map ) == "{ { \"abc\", 1 }, { \"def\", 2 }, { \"ghi\", 3 } }" );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "std::set is convertible string", "[toString]" ) {
|
||||
|
||||
SECTION( "empty" ) {
|
||||
std::set<std::string> emptySet;
|
||||
|
||||
REQUIRE( Catch::Detail::stringify( emptySet ) == "{ }" );
|
||||
}
|
||||
|
||||
SECTION( "single item" ) {
|
||||
std::set<std::string> set = { "one" };
|
||||
|
||||
REQUIRE( Catch::Detail::stringify( set ) == "{ \"one\" }" );
|
||||
}
|
||||
|
||||
SECTION( "several items" ) {
|
||||
std::set<std::string> set = { "abc", "def", "ghi" };
|
||||
|
||||
REQUIRE( Catch::Detail::stringify( set ) == "{ \"abc\", \"def\", \"ghi\" }" );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("Static arrays are convertible to string", "[toString]") {
|
||||
SECTION("Single item") {
|
||||
int singular[1] = { 1 };
|
||||
REQUIRE(Catch::Detail::stringify(singular) == "{ 1 }");
|
||||
}
|
||||
SECTION("Multiple") {
|
||||
int arr[3] = { 3, 2, 1 };
|
||||
REQUIRE(Catch::Detail::stringify(arr) == "{ 3, 2, 1 }");
|
||||
}
|
||||
SECTION("Non-trivial inner items") {
|
||||
std::vector<std::string> arr[2] = { {"1:1", "1:2", "1:3"}, {"2:1", "2:2"} };
|
||||
REQUIRE(Catch::Detail::stringify(arr) == R"({ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } })");
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
|
||||
|
||||
TEST_CASE("String views are stringified like other strings", "[toString][approvals]") {
|
||||
std::string_view view{"abc"};
|
||||
CHECK(Catch::Detail::stringify(view) == R"("abc")");
|
||||
|
||||
std::string_view arr[] { view };
|
||||
CHECK(Catch::Detail::stringify(arr) == R"({ "abc" })");
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
TEST_CASE("Precision of floating point stringification can be set", "[toString][floatingPoint]") {
|
||||
SECTION("Floats") {
|
||||
using sm = Catch::StringMaker<float>;
|
||||
const auto oldPrecision = sm::precision;
|
||||
|
||||
const float testFloat = 1.12345678901234567899f;
|
||||
auto str1 = sm::convert(testFloat);
|
||||
sm::precision = 5;
|
||||
// "1." prefix = 2 chars, f suffix is another char
|
||||
CHECK(str1.size() == 3 + 5);
|
||||
|
||||
sm::precision = 10;
|
||||
auto str2 = sm::convert(testFloat);
|
||||
REQUIRE(str2.size() == 3 + 10);
|
||||
sm::precision = oldPrecision;
|
||||
}
|
||||
SECTION("Double") {
|
||||
using sm = Catch::StringMaker<double>;
|
||||
const auto oldPrecision = sm::precision;
|
||||
|
||||
const double testDouble = 1.123456789012345678901234567899;
|
||||
sm::precision = 5;
|
||||
auto str1 = sm::convert(testDouble);
|
||||
// "1." prefix = 2 chars
|
||||
CHECK(str1.size() == 2 + 5);
|
||||
|
||||
sm::precision = 15;
|
||||
auto str2 = sm::convert(testDouble);
|
||||
REQUIRE(str2.size() == 2 + 15);
|
||||
|
||||
sm::precision = oldPrecision;
|
||||
}
|
||||
}
|
||||
|
||||
namespace {
|
||||
|
||||
struct WhatException : std::exception {
|
||||
char const* what() const noexcept override {
|
||||
return "This exception has overridden what() method";
|
||||
}
|
||||
~WhatException() override;
|
||||
};
|
||||
|
||||
struct OperatorException : std::exception {
|
||||
~OperatorException() override;
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& out, OperatorException const&) {
|
||||
out << "OperatorException";
|
||||
return out;
|
||||
}
|
||||
|
||||
struct StringMakerException : std::exception {
|
||||
~StringMakerException() override;
|
||||
};
|
||||
|
||||
} // end anonymous namespace
|
||||
|
||||
namespace Catch {
|
||||
template <>
|
||||
struct StringMaker<StringMakerException> {
|
||||
static std::string convert(StringMakerException const&) {
|
||||
return "StringMakerException";
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Avoid -Wweak-tables
|
||||
WhatException::~WhatException() = default;
|
||||
OperatorException::~OperatorException() = default;
|
||||
StringMakerException::~StringMakerException() = default;
|
||||
|
||||
|
||||
|
||||
|
||||
TEST_CASE("Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified", "[toString][exception]") {
|
||||
REQUIRE(::Catch::Detail::stringify(WhatException{}) == "This exception has overridden what() method");
|
||||
REQUIRE(::Catch::Detail::stringify(OperatorException{}) == "OperatorException");
|
||||
REQUIRE(::Catch::Detail::stringify(StringMakerException{}) == "StringMakerException");
|
||||
}
|
||||
31
externals/catch2/tests/SelfTest/UsageTests/ToStringOptional.tests.cpp
vendored
Normal file
31
externals/catch2/tests/SelfTest/UsageTests/ToStringOptional.tests.cpp
vendored
Normal file
@@ -0,0 +1,31 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
|
||||
#if defined(CATCH_CONFIG_CPP17_OPTIONAL)
|
||||
|
||||
TEST_CASE( "std::optional<int> -> toString", "[toString][optional][approvals]" ) {
|
||||
using type = std::optional<int>;
|
||||
REQUIRE( "{ }" == ::Catch::Detail::stringify( type{} ) );
|
||||
REQUIRE( "0" == ::Catch::Detail::stringify( type{ 0 } ) );
|
||||
}
|
||||
|
||||
TEST_CASE( "std::optional<std::string> -> toString", "[toString][optional][approvals]" ) {
|
||||
using type = std::optional<std::string>;
|
||||
REQUIRE( "{ }" == ::Catch::Detail::stringify( type{} ) );
|
||||
REQUIRE( "\"abc\"" == ::Catch::Detail::stringify( type{ "abc" } ) );
|
||||
}
|
||||
|
||||
TEST_CASE( "std::vector<std::optional<int> > -> toString", "[toString][optional][approvals]" ) {
|
||||
using type = std::vector<std::optional<int> >;
|
||||
REQUIRE( "{ 0, { }, 2 }" == ::Catch::Detail::stringify( type{ 0, {}, 2 } ) );
|
||||
}
|
||||
|
||||
#endif // CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
|
||||
38
externals/catch2/tests/SelfTest/UsageTests/ToStringPair.tests.cpp
vendored
Normal file
38
externals/catch2/tests/SelfTest/UsageTests/ToStringPair.tests.cpp
vendored
Normal file
@@ -0,0 +1,38 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
|
||||
TEST_CASE( "std::pair<int,std::string> -> toString", "[toString][pair]" ) {
|
||||
std::pair<int,std::string> value( 34, "xyzzy" );
|
||||
REQUIRE( ::Catch::Detail::stringify( value ) == "{ 34, \"xyzzy\" }" );
|
||||
}
|
||||
|
||||
TEST_CASE( "std::pair<int,const std::string> -> toString", "[toString][pair]" ) {
|
||||
std::pair<int,const std::string> value( 34, "xyzzy" );
|
||||
REQUIRE( ::Catch::Detail::stringify(value) == "{ 34, \"xyzzy\" }" );
|
||||
}
|
||||
|
||||
TEST_CASE( "std::vector<std::pair<std::string,int> > -> toString", "[toString][pair]" ) {
|
||||
std::vector<std::pair<std::string,int> > pr;
|
||||
pr.push_back( std::make_pair("green", 55 ) );
|
||||
REQUIRE( ::Catch::Detail::stringify( pr ) == "{ { \"green\", 55 } }" );
|
||||
}
|
||||
|
||||
// This is pretty contrived - I figure if this works, anything will...
|
||||
TEST_CASE( "pair<pair<int,const char *,pair<std::string,int> > -> toString", "[toString][pair]" ) {
|
||||
typedef std::pair<int,const char *> left_t;
|
||||
typedef std::pair<std::string,int> right_t;
|
||||
|
||||
left_t left( 42, "Arthur" );
|
||||
right_t right( "Ford", 24 );
|
||||
|
||||
std::pair<left_t,right_t> pair( left, right );
|
||||
REQUIRE( ::Catch::Detail::stringify( pair ) == "{ { 42, \"Arthur\" }, { \"Ford\", 24 } }" );
|
||||
}
|
||||
54
externals/catch2/tests/SelfTest/UsageTests/ToStringTuple.tests.cpp
vendored
Normal file
54
externals/catch2/tests/SelfTest/UsageTests/ToStringTuple.tests.cpp
vendored
Normal file
@@ -0,0 +1,54 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
|
||||
#include <tuple>
|
||||
|
||||
TEST_CASE( "tuple<>", "[toString][tuple]" )
|
||||
{
|
||||
typedef std::tuple<> type;
|
||||
CHECK( "{ }" == ::Catch::Detail::stringify(type{}) );
|
||||
type value {};
|
||||
CHECK( "{ }" == ::Catch::Detail::stringify(value) );
|
||||
}
|
||||
|
||||
TEST_CASE( "tuple<int>", "[toString][tuple]" )
|
||||
{
|
||||
typedef std::tuple<int> type;
|
||||
CHECK( "{ 0 }" == ::Catch::Detail::stringify(type{0}) );
|
||||
}
|
||||
|
||||
|
||||
TEST_CASE( "tuple<float,int>", "[toString][tuple]" )
|
||||
{
|
||||
typedef std::tuple<float,int> type;
|
||||
CHECK( "1.2f" == ::Catch::Detail::stringify(float(1.2)) );
|
||||
CHECK( "{ 1.2f, 0 }" == ::Catch::Detail::stringify(type{1.2f,0}) );
|
||||
}
|
||||
|
||||
TEST_CASE( "tuple<string,string>", "[toString][tuple]" )
|
||||
{
|
||||
typedef std::tuple<std::string,std::string> type;
|
||||
CHECK( "{ \"hello\", \"world\" }" == ::Catch::Detail::stringify(type{"hello","world"}) );
|
||||
}
|
||||
|
||||
TEST_CASE( "tuple<tuple<int>,tuple<>,float>", "[toString][tuple]" )
|
||||
{
|
||||
typedef std::tuple<std::tuple<int>,std::tuple<>,float> type;
|
||||
type value { std::tuple<int>{42}, {}, 1.2f };
|
||||
CHECK( "{ { 42 }, { }, 1.2f }" == ::Catch::Detail::stringify(value) );
|
||||
}
|
||||
|
||||
TEST_CASE( "tuple<nullptr,int,const char *>", "[approvals][toString][tuple]" ) {
|
||||
typedef std::tuple<std::nullptr_t,int,const char *> type;
|
||||
type value { nullptr, 42, "Catch me" };
|
||||
CHECK( "{ nullptr, 42, \"Catch me\" }" == ::Catch::Detail::stringify(value) );
|
||||
}
|
||||
|
||||
99
externals/catch2/tests/SelfTest/UsageTests/ToStringVariant.tests.cpp
vendored
Normal file
99
externals/catch2/tests/SelfTest/UsageTests/ToStringVariant.tests.cpp
vendored
Normal file
@@ -0,0 +1,99 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
|
||||
#if defined(CATCH_CONFIG_CPP17_VARIANT)
|
||||
|
||||
#include <string>
|
||||
#include <variant>
|
||||
|
||||
// We need 2 types with non-trivial copies/moves
|
||||
struct MyType1 {
|
||||
MyType1() = default;
|
||||
[[noreturn]] MyType1(MyType1 const&) { throw 1; }
|
||||
MyType1& operator=(MyType1 const&) { throw 3; }
|
||||
};
|
||||
struct MyType2 {
|
||||
MyType2() = default;
|
||||
[[noreturn]] MyType2(MyType2 const&) { throw 2; }
|
||||
MyType2& operator=(MyType2 const&) { throw 4; }
|
||||
};
|
||||
|
||||
TEST_CASE( "variant<std::monostate>", "[toString][variant][approvals]")
|
||||
{
|
||||
using type = std::variant<std::monostate>;
|
||||
CHECK( "{ }" == ::Catch::Detail::stringify(type{}) );
|
||||
type value {};
|
||||
CHECK( "{ }" == ::Catch::Detail::stringify(value) );
|
||||
CHECK( "{ }" == ::Catch::Detail::stringify(std::get<0>(value)) );
|
||||
}
|
||||
|
||||
TEST_CASE( "variant<int>", "[toString][variant][approvals]")
|
||||
{
|
||||
using type = std::variant<int>;
|
||||
CHECK( "0" == ::Catch::Detail::stringify(type{0}) );
|
||||
}
|
||||
|
||||
TEST_CASE( "variant<float, int>", "[toString][variant][approvals]")
|
||||
{
|
||||
using type = std::variant<float, int>;
|
||||
CHECK( "0.5f" == ::Catch::Detail::stringify(type{0.5f}) );
|
||||
CHECK( "0" == ::Catch::Detail::stringify(type{0}) );
|
||||
}
|
||||
|
||||
TEST_CASE( "variant -- valueless-by-exception", "[toString][variant][approvals]" ) {
|
||||
using type = std::variant<MyType1, MyType2>;
|
||||
|
||||
type value;
|
||||
REQUIRE_THROWS_AS(value.emplace<MyType2>(MyType2{}), int);
|
||||
REQUIRE(value.valueless_by_exception());
|
||||
CHECK("{valueless variant}" == ::Catch::Detail::stringify(value));
|
||||
}
|
||||
|
||||
|
||||
TEST_CASE( "variant<string, int>", "[toString][variant][approvals]")
|
||||
{
|
||||
using type = std::variant<std::string, int>;
|
||||
CHECK( "\"foo\"" == ::Catch::Detail::stringify(type{"foo"}) );
|
||||
CHECK( "0" == ::Catch::Detail::stringify(type{0}) );
|
||||
}
|
||||
|
||||
TEST_CASE( "variant<variant<float, int>, string>", "[toString][variant][approvals]")
|
||||
{
|
||||
using inner = std::variant<MyType1, float, int>;
|
||||
using type = std::variant<inner, std::string>;
|
||||
CHECK( "0.5f" == ::Catch::Detail::stringify(type{0.5f}) );
|
||||
CHECK( "0" == ::Catch::Detail::stringify(type{0}) );
|
||||
CHECK( "\"foo\"" == ::Catch::Detail::stringify(type{"foo"}) );
|
||||
|
||||
SECTION("valueless nested variant") {
|
||||
type value = inner{0.5f};
|
||||
REQUIRE( std::holds_alternative<inner>(value) );
|
||||
REQUIRE( std::holds_alternative<float>(std::get<inner>(value)) );
|
||||
|
||||
REQUIRE_THROWS_AS( std::get<0>(value).emplace<MyType1>(MyType1{}), int );
|
||||
|
||||
// outer variant is still valid and contains inner
|
||||
REQUIRE( std::holds_alternative<inner>(value) );
|
||||
// inner variant is valueless
|
||||
REQUIRE( std::get<inner>(value).valueless_by_exception() );
|
||||
CHECK( "{valueless variant}" == ::Catch::Detail::stringify(value) );
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "variant<nullptr,int,const char *>", "[toString][variant][approvals]" )
|
||||
{
|
||||
using type = std::variant<std::nullptr_t,int,const char *>;
|
||||
CHECK( "nullptr" == ::Catch::Detail::stringify(type{nullptr}) );
|
||||
CHECK( "42" == ::Catch::Detail::stringify(type{42}) );
|
||||
CHECK( "\"Catch me\"" == ::Catch::Detail::stringify(type{"Catch me"}) );
|
||||
}
|
||||
|
||||
#endif // CATCH_INTERNAL_CONFIG_CPP17_VARIANT
|
||||
94
externals/catch2/tests/SelfTest/UsageTests/ToStringVector.tests.cpp
vendored
Normal file
94
externals/catch2/tests/SelfTest/UsageTests/ToStringVector.tests.cpp
vendored
Normal file
@@ -0,0 +1,94 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <vector>
|
||||
#include <array>
|
||||
|
||||
// vector
|
||||
TEST_CASE( "vector<int> -> toString", "[toString][vector]" )
|
||||
{
|
||||
std::vector<int> vv;
|
||||
REQUIRE( ::Catch::Detail::stringify(vv) == "{ }" );
|
||||
vv.push_back( 42 );
|
||||
REQUIRE( ::Catch::Detail::stringify(vv) == "{ 42 }" );
|
||||
vv.push_back( 250 );
|
||||
REQUIRE( ::Catch::Detail::stringify(vv) == "{ 42, 250 }" );
|
||||
}
|
||||
|
||||
TEST_CASE( "vector<string> -> toString", "[toString][vector]" )
|
||||
{
|
||||
std::vector<std::string> vv;
|
||||
REQUIRE( ::Catch::Detail::stringify(vv) == "{ }" );
|
||||
vv.emplace_back( "hello" );
|
||||
REQUIRE( ::Catch::Detail::stringify(vv) == "{ \"hello\" }" );
|
||||
vv.emplace_back( "world" );
|
||||
REQUIRE( ::Catch::Detail::stringify(vv) == "{ \"hello\", \"world\" }" );
|
||||
}
|
||||
|
||||
namespace {
|
||||
/* Minimal Allocator */
|
||||
template<typename T>
|
||||
struct minimal_allocator {
|
||||
using value_type = T;
|
||||
using size_type = std::size_t;
|
||||
|
||||
minimal_allocator() = default;
|
||||
template <typename U>
|
||||
minimal_allocator(const minimal_allocator<U>&) {}
|
||||
|
||||
|
||||
T *allocate( size_type n ) {
|
||||
return static_cast<T *>( ::operator new( n * sizeof(T) ) );
|
||||
}
|
||||
void deallocate( T *p, size_type /*n*/ ) {
|
||||
::operator delete( static_cast<void *>(p) );
|
||||
}
|
||||
template<typename U>
|
||||
bool operator==( const minimal_allocator<U>& ) const { return true; }
|
||||
template<typename U>
|
||||
bool operator!=( const minimal_allocator<U>& ) const { return false; }
|
||||
};
|
||||
}
|
||||
|
||||
TEST_CASE( "vector<int,allocator> -> toString", "[toString][vector,allocator]" ) {
|
||||
std::vector<int,minimal_allocator<int> > vv;
|
||||
REQUIRE( ::Catch::Detail::stringify(vv) == "{ }" );
|
||||
vv.push_back( 42 );
|
||||
REQUIRE( ::Catch::Detail::stringify(vv) == "{ 42 }" );
|
||||
vv.push_back( 250 );
|
||||
REQUIRE( ::Catch::Detail::stringify(vv) == "{ 42, 250 }" );
|
||||
}
|
||||
|
||||
TEST_CASE( "vec<vec<string,alloc>> -> toString", "[toString][vector,allocator]" ) {
|
||||
using inner = std::vector<std::string, minimal_allocator<std::string>>;
|
||||
using vector = std::vector<inner>;
|
||||
vector v;
|
||||
REQUIRE( ::Catch::Detail::stringify(v) == "{ }" );
|
||||
v.push_back( inner { "hello" } );
|
||||
v.push_back( inner { "world" } );
|
||||
REQUIRE( ::Catch::Detail::stringify(v) == "{ { \"hello\" }, { \"world\" } }" );
|
||||
}
|
||||
|
||||
// Based on PR by mat-so: https://github.com/catchorg/Catch2/pull/606/files#diff-43562f40f8c6dcfe2c54557316e0f852
|
||||
TEST_CASE( "vector<bool> -> toString", "[toString][containers][vector]" ) {
|
||||
std::vector<bool> bools;
|
||||
REQUIRE( ::Catch::Detail::stringify(bools) == "{ }");
|
||||
bools.push_back(true);
|
||||
REQUIRE( ::Catch::Detail::stringify(bools) == "{ true }");
|
||||
bools.push_back(false);
|
||||
REQUIRE( ::Catch::Detail::stringify(bools) == "{ true, false }");
|
||||
}
|
||||
TEST_CASE( "array<int, N> -> toString", "[toString][containers][array]" ) {
|
||||
std::array<int, 0> empty;
|
||||
REQUIRE( Catch::Detail::stringify( empty ) == "{ }" );
|
||||
std::array<int, 1> oneValue = {{ 42 }};
|
||||
REQUIRE( Catch::Detail::stringify( oneValue ) == "{ 42 }" );
|
||||
std::array<int, 2> twoValues = {{ 42, 250 }};
|
||||
REQUIRE( Catch::Detail::stringify( twoValues ) == "{ 42, 250 }" );
|
||||
}
|
||||
186
externals/catch2/tests/SelfTest/UsageTests/ToStringWhich.tests.cpp
vendored
Normal file
186
externals/catch2/tests/SelfTest/UsageTests/ToStringWhich.tests.cpp
vendored
Normal file
@@ -0,0 +1,186 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
|
||||
|
||||
|
||||
#if defined(__GNUC__)
|
||||
// This has to be left enabled until end of the TU, because the GCC
|
||||
// frontend reports operator<<(std::ostream& os, const has_maker_and_operator&)
|
||||
// as unused anyway
|
||||
# pragma GCC diagnostic ignored "-Wunused-function"
|
||||
#endif
|
||||
|
||||
namespace {
|
||||
|
||||
struct has_operator { };
|
||||
struct has_maker {};
|
||||
struct has_maker_and_operator {};
|
||||
struct has_neither {};
|
||||
struct has_template_operator {};
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, const has_operator&) {
|
||||
os << "operator<<( has_operator )";
|
||||
return os;
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, const has_maker_and_operator&) {
|
||||
os << "operator<<( has_maker_and_operator )";
|
||||
return os;
|
||||
}
|
||||
|
||||
template <typename StreamT>
|
||||
StreamT& operator<<(StreamT& os, const has_template_operator&) {
|
||||
os << "operator<<( has_template_operator )";
|
||||
return os;
|
||||
}
|
||||
|
||||
} // end anonymous namespace
|
||||
|
||||
namespace Catch {
|
||||
template<>
|
||||
struct StringMaker<has_maker> {
|
||||
static std::string convert( const has_maker& ) {
|
||||
return "StringMaker<has_maker>";
|
||||
}
|
||||
};
|
||||
template<>
|
||||
struct StringMaker<has_maker_and_operator> {
|
||||
static std::string convert( const has_maker_and_operator& ) {
|
||||
return "StringMaker<has_maker_and_operator>";
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Call the operator
|
||||
TEST_CASE( "stringify( has_operator )", "[toString]" ) {
|
||||
has_operator item;
|
||||
REQUIRE( ::Catch::Detail::stringify( item ) == "operator<<( has_operator )" );
|
||||
}
|
||||
|
||||
// Call the stringmaker
|
||||
TEST_CASE( "stringify( has_maker )", "[toString]" ) {
|
||||
has_maker item;
|
||||
REQUIRE( ::Catch::Detail::stringify( item ) == "StringMaker<has_maker>" );
|
||||
}
|
||||
|
||||
// Call the stringmaker
|
||||
TEST_CASE( "stringify( has_maker_and_operator )", "[toString]" ) {
|
||||
has_maker_and_operator item;
|
||||
REQUIRE( ::Catch::Detail::stringify( item ) == "StringMaker<has_maker_and_operator>" );
|
||||
}
|
||||
|
||||
TEST_CASE("stringify( has_neither )", "[toString]") {
|
||||
has_neither item;
|
||||
REQUIRE( ::Catch::Detail::stringify(item) == "{?}" );
|
||||
}
|
||||
|
||||
// Call the templated operator
|
||||
TEST_CASE( "stringify( has_template_operator )", "[toString]" ) {
|
||||
has_template_operator item;
|
||||
REQUIRE( ::Catch::Detail::stringify( item ) == "operator<<( has_template_operator )" );
|
||||
}
|
||||
|
||||
|
||||
// Vectors...
|
||||
|
||||
TEST_CASE( "stringify( vectors<has_operator> )", "[toString]" ) {
|
||||
std::vector<has_operator> v(1);
|
||||
REQUIRE( ::Catch::Detail::stringify( v ) == "{ operator<<( has_operator ) }" );
|
||||
}
|
||||
|
||||
TEST_CASE( "stringify( vectors<has_maker> )", "[toString]" ) {
|
||||
std::vector<has_maker> v(1);
|
||||
REQUIRE( ::Catch::Detail::stringify( v ) == "{ StringMaker<has_maker> }" );
|
||||
}
|
||||
|
||||
TEST_CASE( "stringify( vectors<has_maker_and_operator> )", "[toString]" ) {
|
||||
std::vector<has_maker_and_operator> v(1);
|
||||
REQUIRE( ::Catch::Detail::stringify( v ) == "{ StringMaker<has_maker_and_operator> }" );
|
||||
}
|
||||
|
||||
namespace {
|
||||
|
||||
// Range-based conversion should only be used if other possibilities fail
|
||||
struct int_iterator {
|
||||
using iterator_category = std::input_iterator_tag;
|
||||
using difference_type = std::ptrdiff_t;
|
||||
using value_type = int;
|
||||
using reference = int&;
|
||||
using pointer = int*;
|
||||
|
||||
int_iterator() = default;
|
||||
int_iterator(int i) :val(i) {}
|
||||
|
||||
value_type operator*() const { return val; }
|
||||
bool operator==(int_iterator rhs) const { return val == rhs.val; }
|
||||
bool operator!=(int_iterator rhs) const { return val != rhs.val; }
|
||||
int_iterator operator++() { ++val; return *this; }
|
||||
int_iterator operator++(int) {
|
||||
auto temp(*this);
|
||||
++val;
|
||||
return temp;
|
||||
}
|
||||
private:
|
||||
int val = 5;
|
||||
};
|
||||
|
||||
struct streamable_range {
|
||||
int_iterator begin() const { return int_iterator{ 1 }; }
|
||||
int_iterator end() const { return {}; }
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, const streamable_range&) {
|
||||
os << "op<<(streamable_range)";
|
||||
return os;
|
||||
}
|
||||
|
||||
struct stringmaker_range {
|
||||
int_iterator begin() const { return int_iterator{ 1 }; }
|
||||
int_iterator end() const { return {}; }
|
||||
};
|
||||
|
||||
} // end anonymous namespace
|
||||
|
||||
namespace Catch {
|
||||
template <>
|
||||
struct StringMaker<stringmaker_range> {
|
||||
static std::string convert(stringmaker_range const&) {
|
||||
return "stringmaker(streamable_range)";
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
namespace {
|
||||
|
||||
struct just_range {
|
||||
int_iterator begin() const { return int_iterator{ 1 }; }
|
||||
int_iterator end() const { return {}; }
|
||||
};
|
||||
|
||||
struct disabled_range {
|
||||
int_iterator begin() const { return int_iterator{ 1 }; }
|
||||
int_iterator end() const { return {}; }
|
||||
};
|
||||
|
||||
} // end anonymous namespace
|
||||
|
||||
namespace Catch {
|
||||
template <>
|
||||
struct is_range<disabled_range> {
|
||||
static const bool value = false;
|
||||
};
|
||||
}
|
||||
|
||||
TEST_CASE("stringify ranges", "[toString]") {
|
||||
REQUIRE(::Catch::Detail::stringify(streamable_range{}) == "op<<(streamable_range)");
|
||||
REQUIRE(::Catch::Detail::stringify(stringmaker_range{}) == "stringmaker(streamable_range)");
|
||||
REQUIRE(::Catch::Detail::stringify(just_range{}) == "{ 1, 2, 3, 4 }");
|
||||
REQUIRE(::Catch::Detail::stringify(disabled_range{}) == "{?}");
|
||||
}
|
||||
380
externals/catch2/tests/SelfTest/UsageTests/Tricky.tests.cpp
vendored
Normal file
380
externals/catch2/tests/SelfTest/UsageTests/Tricky.tests.cpp
vendored
Normal file
@@ -0,0 +1,380 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#ifdef __clang__
|
||||
#pragma clang diagnostic ignored "-Wpadded"
|
||||
#endif
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning (disable : 4702) // Disable unreachable code warning for the last test
|
||||
// that is triggered when compiling as Win32|Release
|
||||
#endif
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/generators/catch_generators.hpp>
|
||||
#include <catch2/generators/catch_generators_range.hpp>
|
||||
|
||||
#include <cstdio>
|
||||
#include <sstream>
|
||||
#include <iostream>
|
||||
|
||||
struct Opaque
|
||||
{
|
||||
int val;
|
||||
bool operator ==( const Opaque& o ) const
|
||||
{
|
||||
return val == o.val;
|
||||
}
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
TEST_CASE
|
||||
(
|
||||
"A failing expression with a non streamable type is still captured",
|
||||
"[Tricky][failing][.]"
|
||||
)
|
||||
{
|
||||
|
||||
Opaque o1, o2;
|
||||
o1.val = 7;
|
||||
o2.val = 8;
|
||||
|
||||
CHECK( &o1 == &o2 );
|
||||
CHECK( o1 == o2 );
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
TEST_CASE
|
||||
(
|
||||
"An expression with side-effects should only be evaluated once",
|
||||
"[Tricky]"
|
||||
)
|
||||
{
|
||||
int i = 7;
|
||||
|
||||
REQUIRE( i++ == 7 );
|
||||
REQUIRE( i++ == 8 );
|
||||
|
||||
}
|
||||
|
||||
namespace A {
|
||||
struct X
|
||||
{
|
||||
X() : a(4), b(2), c(7) {}
|
||||
X(int v) : a(v), b(2), c(7) {}
|
||||
int a;
|
||||
int b;
|
||||
int c;
|
||||
};
|
||||
}
|
||||
|
||||
namespace B {
|
||||
struct Y
|
||||
{
|
||||
Y() : a(4), b(2), c(7) {}
|
||||
Y(int v) : a(v), b(2), c(7) {}
|
||||
int a;
|
||||
int b;
|
||||
int c;
|
||||
};
|
||||
}
|
||||
|
||||
inline bool operator==(const A::X& lhs, const B::Y& rhs)
|
||||
{
|
||||
return (lhs.a == rhs.a);
|
||||
}
|
||||
|
||||
inline bool operator==(const B::Y& lhs, const A::X& rhs)
|
||||
{
|
||||
return (lhs.a == rhs.a);
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/* This, currently, does not compile with LLVM
|
||||
TEST_CASE
|
||||
(
|
||||
"Operators at different namespace levels not hijacked by Koenig lookup"
|
||||
"[Tricky]"
|
||||
)
|
||||
{
|
||||
A::X x;
|
||||
B::Y y;
|
||||
REQUIRE( x == y );
|
||||
}
|
||||
*/
|
||||
|
||||
namespace ObjectWithConversions
|
||||
{
|
||||
struct Object
|
||||
{
|
||||
operator unsigned int() const {return 0xc0000000;}
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
TEST_CASE
|
||||
(
|
||||
"Implicit conversions are supported inside assertion macros",
|
||||
"[Tricky][approvals]"
|
||||
)
|
||||
{
|
||||
Object o;
|
||||
REQUIRE(0xc0000000 == o );
|
||||
}
|
||||
}
|
||||
|
||||
namespace EnumBitFieldTests
|
||||
{
|
||||
enum Bits : uint32_t {
|
||||
bit0 = 0x0001,
|
||||
bit1 = 0x0002,
|
||||
bit2 = 0x0004,
|
||||
bit3 = 0x0008,
|
||||
bit1and2 = bit1 | bit2,
|
||||
bit30 = 0x40000000,
|
||||
bit31 = 0x80000000,
|
||||
bit30and31 = bit30 | bit31
|
||||
};
|
||||
|
||||
TEST_CASE( "Test enum bit values", "[Tricky]" )
|
||||
{
|
||||
REQUIRE( 0xc0000000 == bit30and31 );
|
||||
}
|
||||
}
|
||||
|
||||
struct Obj
|
||||
{
|
||||
Obj():prop(&p){}
|
||||
|
||||
int p = 0;
|
||||
int* prop;
|
||||
};
|
||||
|
||||
TEST_CASE("boolean member", "[Tricky]")
|
||||
{
|
||||
Obj obj;
|
||||
REQUIRE( obj.prop != nullptr );
|
||||
}
|
||||
|
||||
// Tests for a problem submitted by Ralph McArdell
|
||||
//
|
||||
// The static bool value should not need to be defined outside the
|
||||
// struct it is declared in - but when evaluating it in a deduced
|
||||
// context it appears to require the extra definition.
|
||||
// The issue was fixed by adding bool overloads to bypass the
|
||||
// templates that were there to deduce it.
|
||||
template <bool B>
|
||||
struct is_true
|
||||
{
|
||||
static const bool value = B;
|
||||
};
|
||||
|
||||
TEST_CASE( "(unimplemented) static bools can be evaluated", "[Tricky]" )
|
||||
{
|
||||
SECTION("compare to true")
|
||||
{
|
||||
REQUIRE( is_true<true>::value == true );
|
||||
REQUIRE( true == is_true<true>::value );
|
||||
}
|
||||
SECTION("compare to false")
|
||||
{
|
||||
REQUIRE( is_true<false>::value == false );
|
||||
REQUIRE( false == is_true<false>::value );
|
||||
}
|
||||
|
||||
SECTION("negation")
|
||||
{
|
||||
REQUIRE( !is_true<false>::value );
|
||||
}
|
||||
|
||||
SECTION("double negation")
|
||||
{
|
||||
REQUIRE( !!is_true<true>::value );
|
||||
}
|
||||
|
||||
SECTION("direct")
|
||||
{
|
||||
REQUIRE( is_true<true>::value );
|
||||
REQUIRE_FALSE( is_true<false>::value );
|
||||
}
|
||||
}
|
||||
|
||||
struct Boolable
|
||||
{
|
||||
explicit Boolable( bool value ) : m_value( value ) {}
|
||||
|
||||
explicit operator bool() const {
|
||||
return m_value;
|
||||
}
|
||||
|
||||
bool m_value;
|
||||
};
|
||||
|
||||
TEST_CASE( "Objects that evaluated in boolean contexts can be checked", "[Tricky][SafeBool]" )
|
||||
{
|
||||
Boolable True( true );
|
||||
Boolable False( false );
|
||||
|
||||
CHECK( True );
|
||||
CHECK( !False );
|
||||
CHECK_FALSE( False );
|
||||
}
|
||||
|
||||
TEST_CASE( "Assertions then sections", "[Tricky]" )
|
||||
{
|
||||
// This was causing a failure due to the way the console reporter was handling
|
||||
// the current section
|
||||
|
||||
REQUIRE( true );
|
||||
|
||||
SECTION( "A section" )
|
||||
{
|
||||
REQUIRE( true );
|
||||
|
||||
SECTION( "Another section" )
|
||||
{
|
||||
REQUIRE( true );
|
||||
}
|
||||
SECTION( "Another other section" )
|
||||
{
|
||||
REQUIRE( true );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct Awkward
|
||||
{
|
||||
operator int() const { return 7; }
|
||||
};
|
||||
|
||||
TEST_CASE( "non streamable - with conv. op", "[Tricky]" )
|
||||
{
|
||||
Awkward awkward;
|
||||
std::string s = ::Catch::Detail::stringify( awkward );
|
||||
REQUIRE( s == "7" );
|
||||
}
|
||||
|
||||
inline void foo() {}
|
||||
|
||||
typedef void (*fooptr_t)();
|
||||
|
||||
TEST_CASE( "Comparing function pointers", "[Tricky][function pointer]" )
|
||||
{
|
||||
// This was giving a warning in VS2010
|
||||
// #179
|
||||
fooptr_t a = foo;
|
||||
|
||||
REQUIRE( a );
|
||||
REQUIRE( a == &foo );
|
||||
}
|
||||
|
||||
struct S
|
||||
{
|
||||
void f() {}
|
||||
};
|
||||
|
||||
|
||||
TEST_CASE( "Comparing member function pointers", "[Tricky][member function pointer][approvals]" )
|
||||
{
|
||||
typedef void (S::*MF)();
|
||||
MF m = &S::f;
|
||||
|
||||
CHECK( m == &S::f );
|
||||
}
|
||||
|
||||
class ClassName {};
|
||||
|
||||
TEST_CASE( "pointer to class", "[Tricky]" )
|
||||
{
|
||||
ClassName *p = 0;
|
||||
REQUIRE( p == 0 );
|
||||
}
|
||||
|
||||
#include <memory>
|
||||
|
||||
TEST_CASE( "null_ptr", "[Tricky]" )
|
||||
{
|
||||
std::unique_ptr<int> ptr;
|
||||
REQUIRE(ptr.get() == nullptr);
|
||||
}
|
||||
|
||||
TEST_CASE( "X/level/0/a", "[Tricky]" ) { SUCCEED(""); }
|
||||
TEST_CASE( "X/level/0/b", "[Tricky][fizz]" ){ SUCCEED(""); }
|
||||
TEST_CASE( "X/level/1/a", "[Tricky]" ) { SUCCEED(""); }
|
||||
TEST_CASE( "X/level/1/b", "[Tricky]" ) { SUCCEED(""); }
|
||||
|
||||
TEST_CASE( "has printf" ) {
|
||||
|
||||
// This can cause problems as, currently, stdout itself is not redirected - only the cout (and cerr) buffer
|
||||
printf( "loose text artifact\n" );
|
||||
}
|
||||
|
||||
namespace {
|
||||
struct constructor_throws {
|
||||
[[noreturn]] constructor_throws() {
|
||||
throw 1;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
TEST_CASE("Commas in various macros are allowed") {
|
||||
REQUIRE_THROWS( std::vector<constructor_throws>{constructor_throws{}, constructor_throws{}} );
|
||||
CHECK_THROWS( std::vector<constructor_throws>{constructor_throws{}, constructor_throws{}} );
|
||||
REQUIRE_NOTHROW( std::vector<int>{1, 2, 3} == std::vector<int>{1, 2, 3} );
|
||||
CHECK_NOTHROW( std::vector<int>{1, 2, 3} == std::vector<int>{1, 2, 3} );
|
||||
|
||||
REQUIRE(std::vector<int>{1, 2} == std::vector<int>{1, 2});
|
||||
CHECK( std::vector<int>{1, 2} == std::vector<int>{1, 2} );
|
||||
REQUIRE_FALSE(std::vector<int>{1, 2} == std::vector<int>{1, 2, 3});
|
||||
CHECK_FALSE( std::vector<int>{1, 2} == std::vector<int>{1, 2, 3} );
|
||||
|
||||
CHECK_NOFAIL( std::vector<int>{1, 2} == std::vector<int>{1, 2} );
|
||||
CHECKED_IF( std::vector<int>{1, 2} == std::vector<int>{1, 2} ) {
|
||||
REQUIRE(true);
|
||||
} CHECKED_ELSE( std::vector<int>{1, 2} == std::vector<int>{1, 2} ) {
|
||||
CHECK(true);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "non-copyable objects", "[.][failing]" ) {
|
||||
// Thanks to Agustin Bergé (@k-ballo on the cpplang Slack) for raising this
|
||||
std::type_info const& ti = typeid(int);
|
||||
CHECK( ti == typeid(int) );
|
||||
}
|
||||
|
||||
TEST_CASE("#1514: stderr/stdout is not captured in tests aborted by an exception", "[output-capture][regression][.]") {
|
||||
std::cout << "This would not be caught previously\n" << std::flush;
|
||||
std::clog << "Nor would this\n" << std::flush;
|
||||
// FAIL aborts the test by throwing a Catch exception
|
||||
FAIL("1514");
|
||||
}
|
||||
|
||||
|
||||
TEST_CASE( "#2025: -c shouldn't cause infinite loop", "[sections][generators][regression][.approvals]" ) {
|
||||
SECTION( "Check cursor from buffer offset" ) {
|
||||
auto bufPos = GENERATE_REF( range( 0, 44 ) );
|
||||
WHEN( "Buffer position is " << bufPos ) { REQUIRE( 1 == 1 ); }
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("#2025: original repro", "[sections][generators][regression][.approvals]") {
|
||||
auto fov = GENERATE(true, false);
|
||||
DYNAMIC_SECTION("fov_" << fov) {
|
||||
std::cout << "inside with fov: " << fov << '\n';
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("#2025: same-level sections", "[sections][generators][regression][.approvals]") {
|
||||
SECTION("A") {
|
||||
SUCCEED();
|
||||
}
|
||||
auto i = GENERATE(1, 2, 3);
|
||||
SECTION("B") {
|
||||
REQUIRE(i < 4);
|
||||
}
|
||||
}
|
||||
29
externals/catch2/tests/SelfTest/UsageTests/VariadicMacros.tests.cpp
vendored
Normal file
29
externals/catch2/tests/SelfTest/UsageTests/VariadicMacros.tests.cpp
vendored
Normal file
@@ -0,0 +1,29 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
|
||||
|
||||
TEST_CASE()
|
||||
{
|
||||
SUCCEED( "anonymous test case" );
|
||||
}
|
||||
|
||||
TEST_CASE( "Test case with one argument" )
|
||||
{
|
||||
SUCCEED( "no assertions" );
|
||||
}
|
||||
|
||||
TEST_CASE( "Variadic macros", "[variadic][sections]" )
|
||||
{
|
||||
SECTION( "Section with one argument" )
|
||||
{
|
||||
SUCCEED( "no assertions" );
|
||||
}
|
||||
}
|
||||
|
||||
22
externals/catch2/tests/SelfTest/helpers/parse_test_spec.cpp
vendored
Normal file
22
externals/catch2/tests/SelfTest/helpers/parse_test_spec.cpp
vendored
Normal file
@@ -0,0 +1,22 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#include <helpers/parse_test_spec.hpp>
|
||||
|
||||
#include <catch2/internal/catch_test_spec_parser.hpp>
|
||||
#include <catch2/interfaces/catch_interfaces_tag_alias_registry.hpp>
|
||||
|
||||
namespace Catch {
|
||||
|
||||
TestSpec parseTestSpec( std::string const& arg ) {
|
||||
return TestSpecParser( ITagAliasRegistry::get() )
|
||||
.parse( arg )
|
||||
.testSpec();
|
||||
}
|
||||
|
||||
} // namespace Catch
|
||||
20
externals/catch2/tests/SelfTest/helpers/parse_test_spec.hpp
vendored
Normal file
20
externals/catch2/tests/SelfTest/helpers/parse_test_spec.hpp
vendored
Normal file
@@ -0,0 +1,20 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#ifndef CATCH_TEST_HELPERS_PARSE_TEST_SPEC_HPP_INCLUDED
|
||||
#define CATCH_TEST_HELPERS_PARSE_TEST_SPEC_HPP_INCLUDED
|
||||
|
||||
#include <catch2/catch_test_spec.hpp>
|
||||
|
||||
#include <string>
|
||||
|
||||
namespace Catch {
|
||||
TestSpec parseTestSpec( std::string const& arg );
|
||||
}
|
||||
|
||||
#endif // CATCH_TEST_HELPERS_PARSE_TEST_SPEC_HPP_INCLUDED
|
||||
210
externals/catch2/tests/SelfTest/helpers/range_test_helpers.hpp
vendored
Normal file
210
externals/catch2/tests/SelfTest/helpers/range_test_helpers.hpp
vendored
Normal file
@@ -0,0 +1,210 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#ifndef CATCH_TEST_HELPERS_RANGE_TEST_HELPERS_HPP_INCLUDED
|
||||
#define CATCH_TEST_HELPERS_RANGE_TEST_HELPERS_HPP_INCLUDED
|
||||
|
||||
#include <catch2/catch_tostring.hpp>
|
||||
|
||||
#include <initializer_list>
|
||||
#include <list>
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
|
||||
namespace unrelated {
|
||||
template <typename T>
|
||||
class needs_ADL_begin {
|
||||
std::vector<T> m_elements;
|
||||
|
||||
public:
|
||||
using iterator = typename std::vector<T>::iterator;
|
||||
using const_iterator = typename std::vector<T>::const_iterator;
|
||||
|
||||
needs_ADL_begin( std::initializer_list<T> init ): m_elements( init ) {}
|
||||
|
||||
const_iterator Begin() const { return m_elements.begin(); }
|
||||
const_iterator End() const { return m_elements.end(); }
|
||||
|
||||
friend const_iterator begin( needs_ADL_begin const& lhs ) {
|
||||
return lhs.Begin();
|
||||
}
|
||||
friend const_iterator end( needs_ADL_begin const& rhs ) {
|
||||
return rhs.End();
|
||||
}
|
||||
};
|
||||
|
||||
struct ADL_empty {
|
||||
bool Empty() const { return true; }
|
||||
|
||||
friend bool empty( ADL_empty e ) { return e.Empty(); }
|
||||
};
|
||||
|
||||
struct ADL_size {
|
||||
size_t sz() const { return 12; }
|
||||
friend size_t size( ADL_size s ) { return s.sz(); }
|
||||
};
|
||||
|
||||
} // namespace unrelated
|
||||
|
||||
#if defined( __clang__ )
|
||||
# pragma clang diagnostic push
|
||||
# pragma clang diagnostic ignored "-Wunused-function"
|
||||
#endif
|
||||
|
||||
template <typename T>
|
||||
class has_different_begin_end_types {
|
||||
// Using std::vector<T> leads to annoying issues when T is bool
|
||||
// so we just use list because the perf is not critical and ugh.
|
||||
std::list<T> m_elements;
|
||||
|
||||
// Different type for the "end" iterator
|
||||
struct iterator_end {};
|
||||
// Fake-ish forward iterator that only compares to a different type
|
||||
class iterator {
|
||||
using underlying_iter = typename std::list<T>::const_iterator;
|
||||
underlying_iter m_start;
|
||||
underlying_iter m_end;
|
||||
|
||||
public:
|
||||
iterator( underlying_iter start, underlying_iter end ):
|
||||
m_start( start ), m_end( end ) {}
|
||||
|
||||
using iterator_category = std::forward_iterator_tag;
|
||||
using difference_type = std::ptrdiff_t;
|
||||
using value_type = T;
|
||||
using const_reference = T const&;
|
||||
using pointer = T const*;
|
||||
|
||||
friend bool operator==( iterator iter, iterator_end ) {
|
||||
return iter.m_start == iter.m_end;
|
||||
}
|
||||
friend bool operator==(iterator lhs, iterator rhs) {
|
||||
return lhs.m_start == rhs.m_start && lhs.m_end == rhs.m_end;
|
||||
}
|
||||
friend bool operator!=( iterator iter, iterator_end ) {
|
||||
return iter.m_start != iter.m_end;
|
||||
}
|
||||
friend bool operator!=( iterator lhs, iterator rhs ) {
|
||||
return !( lhs == rhs );
|
||||
}
|
||||
iterator& operator++() {
|
||||
++m_start;
|
||||
return *this;
|
||||
}
|
||||
iterator operator++( int ) {
|
||||
auto tmp( *this );
|
||||
++m_start;
|
||||
return tmp;
|
||||
}
|
||||
const_reference operator*() const { return *m_start; }
|
||||
pointer operator->() const { return m_start; }
|
||||
};
|
||||
|
||||
public:
|
||||
explicit has_different_begin_end_types( std::initializer_list<T> init ):
|
||||
m_elements( init ) {}
|
||||
|
||||
iterator begin() const { return { m_elements.begin(), m_elements.end() }; }
|
||||
|
||||
iterator_end end() const { return {}; }
|
||||
};
|
||||
|
||||
#if defined( __clang__ )
|
||||
# pragma clang diagnostic pop
|
||||
#endif
|
||||
|
||||
template <typename T>
|
||||
struct with_mocked_iterator_access {
|
||||
std::vector<T> m_elements;
|
||||
|
||||
// use plain arrays to have nicer printouts with CHECK(...)
|
||||
mutable std::unique_ptr<bool[]> m_derefed;
|
||||
|
||||
// We want to check which elements were dereferenced when iterating, so
|
||||
// we can check whether iterator-using code traverses range correctly
|
||||
template <bool is_const>
|
||||
class basic_iterator {
|
||||
template <typename U>
|
||||
using constify_t = std::conditional_t<is_const, std::add_const_t<U>, U>;
|
||||
|
||||
constify_t<with_mocked_iterator_access>* m_origin;
|
||||
size_t m_origin_idx;
|
||||
|
||||
public:
|
||||
using iterator_category = std::forward_iterator_tag;
|
||||
using difference_type = std::ptrdiff_t;
|
||||
using value_type = constify_t<T>;
|
||||
using const_reference = typename std::vector<T>::const_reference;
|
||||
using reference = typename std::vector<T>::reference;
|
||||
using pointer = typename std::vector<T>::pointer;
|
||||
|
||||
basic_iterator( constify_t<with_mocked_iterator_access>* origin,
|
||||
std::size_t origin_idx ):
|
||||
m_origin{ origin }, m_origin_idx{ origin_idx } {}
|
||||
|
||||
friend bool operator==( basic_iterator lhs, basic_iterator rhs ) {
|
||||
return lhs.m_origin == rhs.m_origin &&
|
||||
lhs.m_origin_idx == rhs.m_origin_idx;
|
||||
}
|
||||
friend bool operator!=( basic_iterator lhs, basic_iterator rhs ) {
|
||||
return !( lhs == rhs );
|
||||
}
|
||||
basic_iterator& operator++() {
|
||||
++m_origin_idx;
|
||||
return *this;
|
||||
}
|
||||
basic_iterator operator++( int ) {
|
||||
auto tmp( *this );
|
||||
++( *this );
|
||||
return tmp;
|
||||
}
|
||||
const_reference operator*() const {
|
||||
assert( m_origin_idx < m_origin->m_elements.size() &&
|
||||
"Attempted to deref invalid position" );
|
||||
m_origin->m_derefed[m_origin_idx] = true;
|
||||
return m_origin->m_elements[m_origin_idx];
|
||||
}
|
||||
pointer operator->() const {
|
||||
assert( m_origin_idx < m_origin->m_elements.size() &&
|
||||
"Attempted to deref invalid position" );
|
||||
return &m_origin->m_elements[m_origin_idx];
|
||||
}
|
||||
};
|
||||
|
||||
using iterator = basic_iterator<false>;
|
||||
using const_iterator = basic_iterator<true>;
|
||||
|
||||
with_mocked_iterator_access( std::initializer_list<T> init ):
|
||||
m_elements( init ),
|
||||
m_derefed( std::make_unique<bool[]>( m_elements.size() ) ) {}
|
||||
|
||||
const_iterator begin() const { return { this, 0 }; }
|
||||
const_iterator end() const { return { this, m_elements.size() }; }
|
||||
iterator begin() { return { this, 0 }; }
|
||||
iterator end() { return { this, m_elements.size() }; }
|
||||
};
|
||||
|
||||
|
||||
namespace Catch {
|
||||
// make sure with_mocked_iterator_access is not considered a range by Catch,
|
||||
// so that below StringMaker is used instead of the default one for ranges
|
||||
template <typename T>
|
||||
struct is_range<with_mocked_iterator_access<T>> : std::false_type {};
|
||||
|
||||
template <typename T>
|
||||
struct StringMaker<with_mocked_iterator_access<T>> {
|
||||
static std::string
|
||||
convert( with_mocked_iterator_access<T> const& access ) {
|
||||
// We have to avoid the type's iterators, because we check
|
||||
// their use in tests
|
||||
return ::Catch::Detail::stringify( access.m_elements );
|
||||
}
|
||||
};
|
||||
} // namespace Catch
|
||||
|
||||
#endif // CATCH_TEST_HELPERS_RANGE_TEST_HELPERS_HPP_INCLUDED
|
||||
44
externals/catch2/tests/SelfTest/helpers/type_with_lit_0_comparisons.hpp
vendored
Normal file
44
externals/catch2/tests/SelfTest/helpers/type_with_lit_0_comparisons.hpp
vendored
Normal file
@@ -0,0 +1,44 @@
|
||||
|
||||
// Copyright Catch2 Authors
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE.txt or copy at
|
||||
// https://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// SPDX-License-Identifier: BSL-1.0
|
||||
|
||||
#ifndef CATCH_TEST_HELPERS_TYPE_WITH_LIT_0_COMPARISONS_HPP_INCLUDED
|
||||
#define CATCH_TEST_HELPERS_TYPE_WITH_LIT_0_COMPARISONS_HPP_INCLUDED
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
// Should only be constructible from literal 0.
|
||||
// Used by `TypeWithLit0Comparisons` for testing comparison
|
||||
// ops that only work with literal zero, the way std::*orderings do
|
||||
struct ZeroLiteralDetector {
|
||||
constexpr ZeroLiteralDetector( ZeroLiteralDetector* ) noexcept {}
|
||||
|
||||
template <typename T,
|
||||
typename = std::enable_if_t<!std::is_same<T, int>::value>>
|
||||
constexpr ZeroLiteralDetector( T ) = delete;
|
||||
};
|
||||
|
||||
struct TypeWithLit0Comparisons {
|
||||
#define DEFINE_COMP_OP( op ) \
|
||||
friend bool operator op( TypeWithLit0Comparisons, ZeroLiteralDetector ) { \
|
||||
return true; \
|
||||
} \
|
||||
friend bool operator op( ZeroLiteralDetector, TypeWithLit0Comparisons ) { \
|
||||
return false; \
|
||||
}
|
||||
|
||||
DEFINE_COMP_OP( < )
|
||||
DEFINE_COMP_OP( <= )
|
||||
DEFINE_COMP_OP( > )
|
||||
DEFINE_COMP_OP( >= )
|
||||
DEFINE_COMP_OP( == )
|
||||
DEFINE_COMP_OP( != )
|
||||
|
||||
#undef DEFINE_COMP_OP
|
||||
};
|
||||
|
||||
#endif // CATCH_TEST_HELPERS_TYPE_WITH_LIT_0_COMPARISONS_HPP_INCLUDED
|
||||
Reference in New Issue
Block a user